Subversion Repositories Scribus

Rev

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