Subversion Repositories Scribus

Rev

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