Subversion Repositories Scribus

Rev

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