Subversion Repositories Scribus

Rev

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