Subversion Repositories Scribus

Rev

Rev 647 | Rev 655 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
104 Franz 1
#include <Python.h>
103 Franz 2
#include "cmdpage.h"
82 Franz 3
#include "cmdvar.h"
201 Franz 4
#include "cmdutil.h"
82 Franz 5
 
6
PyObject *scribus_actualpage(PyObject *self, PyObject* args)
7
{
8
        if (!PyArg_ParseTuple(args, ""))
332 Franz 9
        {
421 Franz 10
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("currentPage()"));
82 Franz 11
                return NULL;
332 Franz 12
        }
649 fschmid 13
        if(!checkHaveDocument())
14
                return NULL;
82 Franz 15
        return PyInt_FromLong(static_cast<long>(Carrier->doc->ActPage->PageNr + 1));
16
}
17
 
18
PyObject *scribus_redraw(PyObject *self, PyObject* args)
19
{
20
        if (!PyArg_ParseTuple(args, ""))
332 Franz 21
        {
421 Franz 22
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("redrawAll()"));
82 Franz 23
                return NULL;
332 Franz 24
        }
649 fschmid 25
        if(!checkHaveDocument())
26
                return NULL;
647 fschmid 27
        Carrier->view->DrawNew();
82 Franz 28
        Py_INCREF(Py_None);
29
        return Py_None;
30
}
31
 
32
PyObject *scribus_savepageeps(PyObject *self, PyObject* args)
33
{
34
        char *Name;
35
        if (!PyArg_ParseTuple(args, "s", &Name))
332 Franz 36
        {
421 Franz 37
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("savePageAsEPS(filename)"));
82 Franz 38
                return NULL;
332 Franz 39
        }
649 fschmid 40
        if(!checkHaveDocument())
41
                return NULL;
173 Franz 42
        bool ret = Carrier->DoSaveAsEps(QString(Name));
43
        return PyInt_FromLong(static_cast<long>(ret));
82 Franz 44
}
45
 
46
PyObject *scribus_deletepage(PyObject *self, PyObject* args)
47
{
48
        int e;
49
        if (!PyArg_ParseTuple(args, "i", &e))
332 Franz 50
        {
421 Franz 51
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("deletePage(pagenumber)"));
82 Franz 52
                return NULL;
332 Franz 53
        }
649 fschmid 54
        if(!checkHaveDocument())
55
                return NULL;
82 Franz 56
        e--;
643 fschmid 57
        if ((e < 0) || (e > static_cast<int>(Carrier->view->Pages.count())-1))
646 fschmid 58
        {
59
                PyErr_SetString(PyExc_IndexError, "Page number out of range");
60
                return NULL;
61
        }
82 Franz 62
        Carrier->DeletePage2(e);
646 fschmid 63
        Py_INCREF(Py_None);
82 Franz 64
        return Py_None;
65
}
66
 
67
PyObject *scribus_gotopage(PyObject *self, PyObject* args)
68
{
69
        int e;
70
        if (!PyArg_ParseTuple(args, "i", &e))
332 Franz 71
        {
421 Franz 72
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("gotoPage(pagenumber)"));
82 Franz 73
                return NULL;
332 Franz 74
        }
649 fschmid 75
        if(!checkHaveDocument())
76
                return NULL;
82 Franz 77
        e--;
643 fschmid 78
        if ((e < 0) || (e > static_cast<int>(Carrier->view->Pages.count())-1))
646 fschmid 79
        {
80
                PyErr_SetString(PyExc_IndexError, "Page number out of range");
81
                return NULL;
82
        }
82 Franz 83
        Carrier->view->GotoPage(e);
646 fschmid 84
        Py_INCREF(Py_None);
82 Franz 85
        return Py_None;
86
}
87
 
88
PyObject *scribus_newpage(PyObject *self, PyObject* args)
89
{
90
        int e;
91
        char *name = "Normal";
92
        if (!PyArg_ParseTuple(args, "i|s", &e, &name))
332 Franz 93
        {
421 Franz 94
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("newPage(pagenumber [, pagename])"));
82 Franz 95
                return NULL;
332 Franz 96
        }
649 fschmid 97
        if(!checkHaveDocument())
98
                return NULL;
82 Franz 99
        if (e < 0)
643 fschmid 100
                Carrier->slotNewPageP(Carrier->view->Pages.count(), QString(name));
82 Franz 101
        else
411 Franz 102
        {
82 Franz 103
                e--;
643 fschmid 104
                if ((e < 0) || (e > static_cast<int>(Carrier->view->Pages.count())-1))
646 fschmid 105
                {
106
                        PyErr_SetString(PyExc_IndexError, "Page number out of range");
107
                        return NULL;
108
                }
82 Franz 109
                Carrier->slotNewPageP(e, QString(name));
411 Franz 110
        }
646 fschmid 111
        Py_INCREF(Py_None);
82 Franz 112
        return Py_None;
113
}
114
 
115
PyObject *scribus_pagecount(PyObject *self, PyObject* args)
116
{
117
        if (!PyArg_ParseTuple(args, ""))
332 Franz 118
        {
421 Franz 119
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("pageCount()"));
82 Franz 120
                return NULL;
332 Franz 121
        }
649 fschmid 122
        if(!checkHaveDocument())
123
                return NULL;
643 fschmid 124
        return PyInt_FromLong(static_cast<long>(Carrier->view->Pages.count()));
82 Franz 125
}
126
 
201 Franz 127
PyObject *scribus_pagedimension(PyObject *self, PyObject *args)
128
{
332 Franz 129
        if (!PyArg_ParseTuple(args, ""))
130
        {
421 Franz 131
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("getPageSize()"));
201 Franz 132
                return NULL;
133
        }
649 fschmid 134
        if(!checkHaveDocument())
135
                return NULL;
201 Franz 136
        PyObject *t;
137
        t = Py_BuildValue(
646 fschmid 138
                        "(dd)",
139
                        PointToValue(Carrier->doc->PageB), // it's just view scale... * Carrier->doc->Scale),
140
                        PointToValue(Carrier->doc->PageH)  // * Carrier->doc->Scale)
141
                );
201 Franz 142
        return t;
143
}
144
 
216 Franz 145
PyObject *scribus_getpageitems(PyObject *self, PyObject* args)
146
{
147
        if (!PyArg_ParseTuple(args, ""))
332 Franz 148
        {
421 Franz 149
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("getPageItems()"));
216 Franz 150
                return NULL;
332 Franz 151
        }
649 fschmid 152
        if(!checkHaveDocument())
153
                return NULL;
647 fschmid 154
        if (Carrier->doc->ActPage->Items.count() == 0)
216 Franz 155
                return Py_BuildValue((char*)"[]");
643 fschmid 156
        PyObject *l = PyList_New(Carrier->doc->ActPage->Items.count());
216 Franz 157
        PyObject *row;
643 fschmid 158
        for (uint i = 0; i<Carrier->doc->ActPage->Items.count(); ++i)
216 Franz 159
        {
160
                row = Py_BuildValue((char*)"(sii)",
643 fschmid 161
                                    Carrier->doc->ActPage->Items.at(i)->AnName.ascii(),
162
                                    Carrier->doc->ActPage->Items.at(i)->PType,
163
                                    Carrier->doc->ActPage->Items.at(i)->ItemNr
164
                                   );
216 Franz 165
                PyList_SetItem(l, i, row);
166
        } // for
167
        return l;
168
}
411 Franz 169
 
170
PyObject *scribus_getHguides(PyObject *self, PyObject* args)
171
{
172
        if (!PyArg_ParseTuple(args, ""))
173
        {
421 Franz 174
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("getHGuides()"));
411 Franz 175
                return NULL;
176
        }
649 fschmid 177
        if(!checkHaveDocument())
178
                return NULL;
647 fschmid 179
        int n = Carrier->doc->ActPage->YGuides.count();
180
        if (n == 0)
411 Franz 181
        {
182
                Py_INCREF(Py_None);
183
                return Py_None;
184
        }
185
        int i;
186
        double tmp;
187
        PyObject *l, *guide;
188
        l = PyList_New(0);
189
        for (i=0; i<n; i++)
190
        {
191
                tmp = Carrier->doc->ActPage->YGuides[i];
192
                guide = Py_BuildValue("d", PointToValue(tmp));
193
                PyList_Append(l, guide);
194
        }
195
        return l;
196
}
197
 
198
PyObject *scribus_setHguides(PyObject *self, PyObject* args)
199
{
200
        PyObject *l;
201
        if (!PyArg_ParseTuple(args, "O", &l))
202
        {
421 Franz 203
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("setHGuides(guides)"));
411 Franz 204
                return NULL;
205
        }
649 fschmid 206
        if(!checkHaveDocument())
207
                return NULL;
411 Franz 208
        if (!PyList_Check(l))
209
        {
210
                PyErr_SetString(PyExc_TypeError, QString("argument is not list: must be list of float values"));
211
                return NULL;
212
        }
213
        int i, n;
214
        n = PyList_Size(l);
215
        double guide;
216
        Carrier->doc->ActPage->YGuides.clear();
217
        for (i=0; i<n; i++)
218
        {
219
                if (!PyArg_Parse(PyList_GetItem(l, i), "d", &guide))
220
                {
221
                        PyErr_SetString(PyExc_TypeError, QString("argument contains no-numeric values: must be list of float values"));
222
                        return NULL;
223
                }
224
                Carrier->doc->ActPage->YGuides += ValueToPoint(guide);
225
        }
646 fschmid 226
        Py_INCREF(Py_None);
411 Franz 227
        return Py_None;
228
}
229
 
230
PyObject *scribus_getVguides(PyObject *self, PyObject* args)
231
{
232
        if (!PyArg_ParseTuple(args, ""))
233
        {
421 Franz 234
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("getVGuides()"));
411 Franz 235
                return NULL;
236
        }
649 fschmid 237
        if(!checkHaveDocument())
238
                return NULL;
647 fschmid 239
        int n = Carrier->doc->ActPage->XGuides.count();
240
        if (n == 0)
411 Franz 241
        {
242
                Py_INCREF(Py_None);
243
                return Py_None;
244
        }
245
        int i;
246
        double tmp;
247
        PyObject *l, *guide;
248
        l = PyList_New(0);
249
        for (i=0; i<n; i++)
250
        {
251
                tmp = Carrier->doc->ActPage->XGuides[i];
252
                guide = Py_BuildValue("d", PointToValue(tmp));
253
                PyList_Append(l, guide);
254
        }
255
        return l;
256
}
257
 
258
PyObject *scribus_setVguides(PyObject *self, PyObject* args)
259
{
260
        PyObject *l;
261
        if (!PyArg_ParseTuple(args, "O", &l))
262
        {
421 Franz 263
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("setVGuides(guides)"));
411 Franz 264
                return NULL;
265
        }
649 fschmid 266
        if(!checkHaveDocument())
267
                return NULL;
411 Franz 268
        if (!PyList_Check(l))
269
        {
270
                PyErr_SetString(PyExc_TypeError, QString("argument is not list: must be list of float values"));
271
                return NULL;
272
        }
273
        int i, n;
274
        n = PyList_Size(l);
275
        double guide;
276
        Carrier->doc->ActPage->XGuides.clear();
277
        for (i=0; i<n; i++)
278
        {
279
                if (!PyArg_Parse(PyList_GetItem(l, i), "d", &guide))
280
                {
281
                        PyErr_SetString(PyExc_TypeError, QString("argument contains no-numeric values: must be list of float values"));
282
                        return NULL;
283
                }
284
                Carrier->doc->ActPage->XGuides += ValueToPoint(guide);
285
        }
646 fschmid 286
        Py_INCREF(Py_None);
411 Franz 287
        return Py_None;
288
}
418 Franz 289
 
290
PyObject *scribus_getpagemargins(PyObject *self,  PyObject* args)
291
{
292
        PyObject *margins = NULL;
293
        if (!PyArg_ParseTuple(args, ""))
294
        {
421 Franz 295
                PyErr_SetString(PyExc_Exception, ERRPARAM + QString("getPageMargins()"));
418 Franz 296
                return NULL;
297
        }
649 fschmid 298
        if(!checkHaveDocument())
299
                return NULL;
418 Franz 300
        margins = Py_BuildValue("ffff", Carrier->doc->PageM.Top, Carrier->doc->PageM.Left,
301
                                                         Carrier->doc->PageM.Right, Carrier->doc->PageM.Bottom);
302
        if (margins == NULL)
303
        {
304
                PyErr_SetString(PyExc_Exception, "Building margin tuple failed!");
305
                return NULL;
306
        }
307
        Py_INCREF(margins);
308
        return margins;
309
}