Subversion Repositories Scribus

Rev

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