Rev 24091 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4430 | cbradney | 1 | /* |
2 | For general Scribus (>=1.3.2) copyright and licensing information please refer |
||
3 | to the COPYING file provided with the program. Following this notice may exist |
||
4 | a copyright and/or license notice that predates the release of Scribus 1.3.2 |
||
5 | for which a new license (GPL+exception) is in place. |
||
6 | */ |
||
103 | Franz | 7 | #include "cmdpage.h" |
201 | Franz | 8 | #include "cmdutil.h" |
16736 | jghali | 9 | #include "commonstrings.h" |
16729 | fschmid | 10 | #include "scpage.h" |
5781 | cbradney | 11 | #include "scribuscore.h" |
13805 | jghali | 12 | #include "scribusdoc.h" |
19093 | craig | 13 | #include "scribusview.h" |
82 | Franz | 14 | |
16546 | jghali | 15 | #include <QApplication> |
16 | |||
23385 | jghali | 17 | PyObject *scribus_currentpage(PyObject* /* self */) |
82 | Franz | 18 | { |
22653 | jghali | 19 | if (!checkHaveDocument()) |
22537 | craig | 20 | return nullptr; |
23278 | jghali | 21 | return PyLong_FromLong(static_cast<long>(ScCore->primaryMainWindow()->doc->currentPageNumber() + 1)); |
82 | Franz | 22 | } |
23 | |||
25284 | craig | 24 | PyObject *scribus_currentpagenumberforsection(PyObject* /* self */) |
25 | { |
||
26 | if (!checkHaveDocument()) |
||
27 | return nullptr; |
||
28 | int i = ScCore->primaryMainWindow()->doc->currentPageNumber(); |
||
29 | return PyUnicode_FromString(ScCore->primaryMainWindow()->doc->getSectionPageNumberForPageIndex(i).toUtf8()); |
||
30 | } |
||
31 | |||
2790 | craig | 32 | PyObject *scribus_redraw(PyObject* /* self */) |
82 | Franz | 33 | { |
22653 | jghali | 34 | if (!checkHaveDocument()) |
22537 | craig | 35 | return nullptr; |
5781 | cbradney | 36 | ScCore->primaryMainWindow()->view->DrawNew(); |
13782 | jghali | 37 | qApp->processEvents(); |
23692 | jghali | 38 | |
8301 | cbradney | 39 | Py_RETURN_NONE; |
82 | Franz | 40 | } |
41 | |||
23385 | jghali | 42 | PyObject *scribus_getpagetype(PyObject* /* self */, PyObject* args) |
6299 | fschmid | 43 | { |
44 | int e; |
||
45 | if (!PyArg_ParseTuple(args, "i", &e)) |
||
22537 | craig | 46 | return nullptr; |
22653 | jghali | 47 | if (!checkHaveDocument()) |
22537 | craig | 48 | return nullptr; |
6299 | fschmid | 49 | e--; |
50 | if ((e < 0) || (e > static_cast<int>(ScCore->primaryMainWindow()->doc->Pages->count())-1)) |
||
51 | { |
||
10598 | cbradney | 52 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
22537 | craig | 53 | return nullptr; |
6299 | fschmid | 54 | } |
23278 | jghali | 55 | return PyLong_FromLong(static_cast<long>(ScCore->primaryMainWindow()->doc->locationOfPage(e))); |
6299 | fschmid | 56 | } |
57 | |||
2790 | craig | 58 | PyObject *scribus_savepageeps(PyObject* /* self */, PyObject* args) |
82 | Franz | 59 | { |
60 | char *Name; |
||
900 | cbradney | 61 | if (!PyArg_ParseTuple(args, "es", "utf-8", &Name)) |
22537 | craig | 62 | return nullptr; |
22653 | jghali | 63 | if (!checkHaveDocument()) |
22537 | craig | 64 | return nullptr; |
11060 | jghali | 65 | QString epsError; |
66 | bool ret = ScCore->primaryMainWindow()->DoSaveAsEps(QString::fromUtf8(Name), epsError); |
||
899 | cbradney | 67 | if (!ret) |
68 | { |
||
11060 | jghali | 69 | QString message = QObject::tr("Failed to save EPS.","python error"); |
70 | if (!epsError.isEmpty()) |
||
71 | message += QString("\n%1").arg(epsError); |
||
72 | PyErr_SetString(ScribusException, message.toLocal8Bit().constData()); |
||
22537 | craig | 73 | return nullptr; |
899 | cbradney | 74 | } |
8319 | fschmid | 75 | // Py_INCREF(Py_True); // return True not None for backward compat |
76 | // return Py_True; |
||
11322 | fschmid | 77 | // Py_RETURN_TRUE; |
78 | return PyBool_FromLong(static_cast<long>(true)); |
||
82 | Franz | 79 | } |
80 | |||
2790 | craig | 81 | PyObject *scribus_deletepage(PyObject* /* self */, PyObject* args) |
82 | Franz | 82 | { |
83 | int e; |
||
84 | if (!PyArg_ParseTuple(args, "i", &e)) |
||
22537 | craig | 85 | return nullptr; |
22653 | jghali | 86 | if (!checkHaveDocument()) |
22537 | craig | 87 | return nullptr; |
82 | Franz | 88 | e--; |
5781 | cbradney | 89 | if ((e < 0) || (e > static_cast<int>(ScCore->primaryMainWindow()->doc->Pages->count())-1)) |
646 | fschmid | 90 | { |
10598 | cbradney | 91 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
22537 | craig | 92 | return nullptr; |
646 | fschmid | 93 | } |
17213 | craig | 94 | ScCore->primaryMainWindow()->deletePage2(e); |
8319 | fschmid | 95 | // Py_INCREF(Py_None); |
96 | // return Py_None; |
||
8301 | cbradney | 97 | Py_RETURN_NONE; |
82 | Franz | 98 | } |
99 | |||
2790 | craig | 100 | PyObject *scribus_gotopage(PyObject* /* self */, PyObject* args) |
82 | Franz | 101 | { |
102 | int e; |
||
103 | if (!PyArg_ParseTuple(args, "i", &e)) |
||
22537 | craig | 104 | return nullptr; |
22653 | jghali | 105 | if (!checkHaveDocument()) |
22537 | craig | 106 | return nullptr; |
82 | Franz | 107 | e--; |
5781 | cbradney | 108 | if ((e < 0) || (e > static_cast<int>(ScCore->primaryMainWindow()->doc->Pages->count())-1)) |
646 | fschmid | 109 | { |
10598 | cbradney | 110 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
22537 | craig | 111 | return nullptr; |
646 | fschmid | 112 | } |
5781 | cbradney | 113 | ScCore->primaryMainWindow()->view->GotoPage(e); |
8319 | fschmid | 114 | // Py_INCREF(Py_None); |
115 | // return Py_None; |
||
8301 | cbradney | 116 | Py_RETURN_NONE; |
82 | Franz | 117 | } |
118 | |||
2790 | craig | 119 | PyObject *scribus_newpage(PyObject* /* self */, PyObject* args) |
82 | Franz | 120 | { |
121 | int e; |
||
7954 | subik | 122 | char *name = const_cast<char*>(""); |
123 | QString qName(CommonStrings::trMasterPageNormal); |
||
900 | cbradney | 124 | if (!PyArg_ParseTuple(args, "i|es", &e, "utf-8", &name)) |
22537 | craig | 125 | return nullptr; |
22653 | jghali | 126 | if (!checkHaveDocument()) |
22537 | craig | 127 | return nullptr; |
7954 | subik | 128 | |
22693 | jghali | 129 | ScribusMainWindow* mainWin = ScCore->primaryMainWindow(); |
22659 | jghali | 130 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
131 | |||
132 | int loc = (e > -1) ? e : currentDoc->Pages->count(); |
||
133 | if (currentDoc->pageSets()[currentDoc->pagePositioning()].Columns != 1) |
||
5052 | subik | 134 | { |
22659 | jghali | 135 | switch (currentDoc->locationOfPage(loc)) |
7954 | subik | 136 | { |
137 | case LeftPage: |
||
138 | qName = CommonStrings::trMasterPageNormalLeft; |
||
139 | break; |
||
140 | case RightPage: |
||
141 | qName = CommonStrings::trMasterPageNormalRight; |
||
142 | break; |
||
143 | case MiddlePage: |
||
144 | qName = CommonStrings::trMasterPageNormalMiddle; |
||
145 | break; |
||
146 | } |
||
147 | } |
||
148 | if (QString(name).length() != 0) |
||
149 | qName = QString::fromUtf8(name); |
||
150 | |||
22659 | jghali | 151 | if (!currentDoc->MasterNames.contains(qName)) |
7954 | subik | 152 | { |
10598 | cbradney | 153 | PyErr_SetString(PyExc_IndexError, QObject::tr("Given master page name does not match any existing.","python error").toLocal8Bit().constData()); |
22537 | craig | 154 | return nullptr; |
5052 | subik | 155 | } |
82 | Franz | 156 | if (e < 0) |
22693 | jghali | 157 | mainWin->slotNewPageP(loc, qName); |
82 | Franz | 158 | else |
411 | Franz | 159 | { |
82 | Franz | 160 | e--; |
7954 | subik | 161 | if ((e < 0) || (e > static_cast<int>(loc - 1))) |
646 | fschmid | 162 | { |
10598 | cbradney | 163 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
22537 | craig | 164 | return nullptr; |
646 | fschmid | 165 | } |
22693 | jghali | 166 | mainWin->slotNewPageP(e, qName); |
411 | Franz | 167 | } |
8319 | fschmid | 168 | // Py_INCREF(Py_None); |
169 | // return Py_None; |
||
8301 | cbradney | 170 | Py_RETURN_NONE; |
82 | Franz | 171 | } |
172 | |||
2790 | craig | 173 | PyObject *scribus_pagecount(PyObject* /* self */) |
82 | Franz | 174 | { |
22653 | jghali | 175 | if (!checkHaveDocument()) |
22537 | craig | 176 | return nullptr; |
23278 | jghali | 177 | return PyLong_FromLong(static_cast<long>(ScCore->primaryMainWindow()->doc->Pages->count())); |
82 | Franz | 178 | } |
179 | |||
24091 | jghali | 180 | PyObject *scribus_getpagesize(PyObject* /* self */) |
201 | Franz | 181 | { |
22653 | jghali | 182 | if (!checkHaveDocument()) |
22537 | craig | 183 | return nullptr; |
22659 | jghali | 184 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
185 | |||
201 | Franz | 186 | PyObject *t; |
187 | t = Py_BuildValue( |
||
646 | fschmid | 188 | "(dd)", |
22659 | jghali | 189 | PointToValue(currentDoc->pageWidth()), // it's just view scale... * ScCore->primaryMainWindow()->doc->Scale), |
190 | PointToValue(currentDoc->pageHeight()) // * ScCore->primaryMainWindow()->doc->Scale) |
||
646 | fschmid | 191 | ); |
201 | Franz | 192 | return t; |
193 | } |
||
194 | |||
23385 | jghali | 195 | PyObject *scribus_getpagensize(PyObject* /* self */, PyObject* args) |
14142 | cbradney | 196 | { |
197 | int e; |
||
198 | if (!PyArg_ParseTuple(args, "i", &e)) |
||
22537 | craig | 199 | return nullptr; |
22653 | jghali | 200 | if (!checkHaveDocument()) |
22537 | craig | 201 | return nullptr; |
22659 | jghali | 202 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
203 | |||
14142 | cbradney | 204 | e--; |
22659 | jghali | 205 | if ((e < 0) || (e > static_cast<int>(currentDoc->Pages->count())-1)) |
14142 | cbradney | 206 | { |
207 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
||
22537 | craig | 208 | return nullptr; |
14142 | cbradney | 209 | } |
210 | PyObject *t; |
||
211 | t = Py_BuildValue( |
||
212 | "(dd)", |
||
22659 | jghali | 213 | PointToValue(currentDoc->Pages->at(e)->width()), |
214 | PointToValue(currentDoc->Pages->at(e)->height()) |
||
14142 | cbradney | 215 | ); |
216 | return t; |
||
217 | } |
||
218 | |||
23385 | jghali | 219 | PyObject *scribus_getpagenmargins(PyObject* /* self */, PyObject* args) |
14142 | cbradney | 220 | { |
221 | int e; |
||
222 | if (!PyArg_ParseTuple(args, "i", &e)) |
||
22537 | craig | 223 | return nullptr; |
22653 | jghali | 224 | if (!checkHaveDocument()) |
22537 | craig | 225 | return nullptr; |
22659 | jghali | 226 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
227 | |||
14142 | cbradney | 228 | e--; |
22659 | jghali | 229 | if ((e < 0) || (e > static_cast<int>(currentDoc->Pages->count())-1)) |
14142 | cbradney | 230 | { |
231 | PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData()); |
||
22537 | craig | 232 | return nullptr; |
14142 | cbradney | 233 | } |
22537 | craig | 234 | PyObject *margins = nullptr; |
22659 | jghali | 235 | margins = Py_BuildValue("ffff", PointToValue(currentDoc->Pages->at(e)->Margins.top()), |
236 | PointToValue(currentDoc->Pages->at(e)->Margins.left()), |
||
237 | PointToValue(currentDoc->Pages->at(e)->Margins.right()), |
||
238 | PointToValue(currentDoc->Pages->at(e)->Margins.bottom())); |
||
14142 | cbradney | 239 | return margins; |
240 | } |
||
241 | |||
2790 | craig | 242 | PyObject *scribus_getpageitems(PyObject* /* self */) |
216 | Franz | 243 | { |
22653 | jghali | 244 | if (!checkHaveDocument()) |
22537 | craig | 245 | return nullptr; |
22659 | jghali | 246 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
247 | |||
248 | if (currentDoc->Items->count() == 0) |
||
216 | Franz | 249 | return Py_BuildValue((char*)"[]"); |
3410 | fschmid | 250 | uint counter = 0; |
22659 | jghali | 251 | int pageNr = currentDoc->currentPageNumber(); |
252 | for (int lam2 = 0; lam2 < currentDoc->Items->count(); ++lam2) |
||
3410 | fschmid | 253 | { |
22659 | jghali | 254 | if (pageNr == currentDoc->Items->at(lam2)->OwnPage) |
3410 | fschmid | 255 | counter++; |
256 | } |
||
257 | PyObject *l = PyList_New(counter); |
||
216 | Franz | 258 | PyObject *row; |
3410 | fschmid | 259 | counter = 0; |
22659 | jghali | 260 | for (int i = 0; i<currentDoc->Items->count(); ++i) |
216 | Franz | 261 | { |
22659 | jghali | 262 | if (pageNr == currentDoc->Items->at(i)->OwnPage) |
3410 | fschmid | 263 | { |
264 | row = Py_BuildValue((char*)"(sii)", |
||
22659 | jghali | 265 | currentDoc->Items->at(i)->itemName().toUtf8().constData(), |
266 | currentDoc->Items->at(i)->itemType(), |
||
267 | currentDoc->Items->at(i)->uniqueNr |
||
3410 | fschmid | 268 | ); |
269 | PyList_SetItem(l, counter, row); |
||
270 | counter++; |
||
271 | } |
||
216 | Franz | 272 | } // for |
273 | return l; |
||
274 | } |
||
411 | Franz | 275 | |
2790 | craig | 276 | PyObject *scribus_getHguides(PyObject* /* self */) |
411 | Franz | 277 | { |
22653 | jghali | 278 | if (!checkHaveDocument()) |
22537 | craig | 279 | return nullptr; |
5781 | cbradney | 280 | Guides g = ScCore->primaryMainWindow()->doc->currentPage()->guides.horizontals(GuideManagerCore::Standard); |
281 | int n = g.count();//ScCore->primaryMainWindow()->doc->currentPage->YGuides.count(); |
||
647 | fschmid | 282 | if (n == 0) |
720 | subik | 283 | return Py_BuildValue((char*)"[]"); |
411 | Franz | 284 | int i; |
285 | double tmp; |
||
286 | PyObject *l, *guide; |
||
287 | l = PyList_New(0); |
||
288 | for (i=0; i<n; i++) |
||
289 | { |
||
5087 | subik | 290 | tmp = g[i]; |
411 | Franz | 291 | guide = Py_BuildValue("d", PointToValue(tmp)); |
292 | PyList_Append(l, guide); |
||
293 | } |
||
294 | return l; |
||
295 | } |
||
296 | |||
2790 | craig | 297 | PyObject *scribus_setHguides(PyObject* /* self */, PyObject* args) |
411 | Franz | 298 | { |
299 | PyObject *l; |
||
300 | if (!PyArg_ParseTuple(args, "O", &l)) |
||
22537 | craig | 301 | return nullptr; |
22653 | jghali | 302 | if (!checkHaveDocument()) |
22537 | craig | 303 | return nullptr; |
22659 | jghali | 304 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
305 | |||
411 | Franz | 306 | if (!PyList_Check(l)) |
307 | { |
||
10598 | cbradney | 308 | PyErr_SetString(PyExc_TypeError, QObject::tr("argument is not list: must be list of float values.","python error").toLocal8Bit().constData()); |
22537 | craig | 309 | return nullptr; |
411 | Franz | 310 | } |
311 | int i, n; |
||
312 | n = PyList_Size(l); |
||
313 | double guide; |
||
22659 | jghali | 314 | currentDoc->currentPage()->guides.clearHorizontals(GuideManagerCore::Standard); |
411 | Franz | 315 | for (i=0; i<n; i++) |
316 | { |
||
317 | if (!PyArg_Parse(PyList_GetItem(l, i), "d", &guide)) |
||
318 | { |
||
10598 | cbradney | 319 | PyErr_SetString(PyExc_TypeError, QObject::tr("argument contains non-numeric values: must be list of float values.","python error").toLocal8Bit().constData()); |
22537 | craig | 320 | return nullptr; |
411 | Franz | 321 | } |
22659 | jghali | 322 | currentDoc->currentPage()->guides.addHorizontal(ValueToPoint(guide), GuideManagerCore::Standard); |
411 | Franz | 323 | } |
23692 | jghali | 324 | |
8301 | cbradney | 325 | Py_RETURN_NONE; |
411 | Franz | 326 | } |
327 | |||
2790 | craig | 328 | PyObject *scribus_getVguides(PyObject* /* self */) |
411 | Franz | 329 | { |
22653 | jghali | 330 | if (!checkHaveDocument()) |
22537 | craig | 331 | return nullptr; |
5781 | cbradney | 332 | Guides g = ScCore->primaryMainWindow()->doc->currentPage()->guides.verticals(GuideManagerCore::Standard); |
333 | int n = g.count();//ScCore->primaryMainWindow()->doc->currentPage->XGuides.count(); |
||
647 | fschmid | 334 | if (n == 0) |
720 | subik | 335 | return Py_BuildValue((char*)"[]"); |
411 | Franz | 336 | int i; |
337 | double tmp; |
||
338 | PyObject *l, *guide; |
||
339 | l = PyList_New(0); |
||
340 | for (i=0; i<n; i++) |
||
341 | { |
||
5087 | subik | 342 | tmp = g[i]; |
411 | Franz | 343 | guide = Py_BuildValue("d", PointToValue(tmp)); |
344 | PyList_Append(l, guide); |
||
345 | } |
||
346 | return l; |
||
347 | } |
||
348 | |||
2790 | craig | 349 | PyObject *scribus_setVguides(PyObject* /* self */, PyObject* args) |
411 | Franz | 350 | { |
351 | PyObject *l; |
||
352 | if (!PyArg_ParseTuple(args, "O", &l)) |
||
22537 | craig | 353 | return nullptr; |
22653 | jghali | 354 | if (!checkHaveDocument()) |
22537 | craig | 355 | return nullptr; |
22659 | jghali | 356 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
357 | |||
411 | Franz | 358 | if (!PyList_Check(l)) |
359 | { |
||
10598 | cbradney | 360 | PyErr_SetString(PyExc_TypeError, QObject::tr("argument is not list: must be list of float values.","python error").toLocal8Bit().constData()); |
22537 | craig | 361 | return nullptr; |
411 | Franz | 362 | } |
363 | int i, n; |
||
364 | n = PyList_Size(l); |
||
365 | double guide; |
||
22659 | jghali | 366 | currentDoc->currentPage()->guides.clearVerticals(GuideManagerCore::Standard); |
411 | Franz | 367 | for (i=0; i<n; i++) |
368 | { |
||
369 | if (!PyArg_Parse(PyList_GetItem(l, i), "d", &guide)) |
||
370 | { |
||
10598 | cbradney | 371 | PyErr_SetString(PyExc_TypeError, QObject::tr("argument contains no-numeric values: must be list of float values.","python error").toLocal8Bit().constData()); |
22537 | craig | 372 | return nullptr; |
411 | Franz | 373 | } |
22659 | jghali | 374 | currentDoc->currentPage()->guides.addVertical(ValueToPoint(guide), GuideManagerCore::Standard); |
411 | Franz | 375 | } |
23692 | jghali | 376 | |
8301 | cbradney | 377 | Py_RETURN_NONE; |
411 | Franz | 378 | } |
418 | Franz | 379 | |
2790 | craig | 380 | PyObject *scribus_getpagemargins(PyObject* /* self */) |
418 | Franz | 381 | { |
22537 | craig | 382 | PyObject *margins = nullptr; |
22653 | jghali | 383 | if (!checkHaveDocument()) |
22537 | craig | 384 | return nullptr; |
22659 | jghali | 385 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
386 | |||
387 | margins = Py_BuildValue("ffff", PointToValue(currentDoc->margins()->top()), |
||
388 | PointToValue(currentDoc->margins()->left()), |
||
389 | PointToValue(currentDoc->margins()->right()), |
||
390 | PointToValue(currentDoc->margins()->bottom())); |
||
418 | Franz | 391 | return margins; |
392 | } |
||
6200 | subik | 393 | |
11048 | jghali | 394 | /*! |
12071 | subik | 395 | \fn import_addpages(int total, int pos) |
11048 | jghali | 396 | \author Alessandro Pira <alex@alessandropira.org> |
397 | \date 11-11-2007 |
||
12071 | subik | 398 | \param total number of pages to add, pos: position in the document |
399 | \param pos position of the imported pages |
||
11048 | jghali | 400 | \retval void |
401 | */ |
||
402 | // This function is used by scribus_importpage() to add new pages |
||
22659 | jghali | 403 | void import_addpages(int total, int pos) |
404 | { |
||
405 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
||
406 | |||
13424 | subik | 407 | for (int i=0; i<total; i++) |
408 | { |
||
11048 | jghali | 409 | int locreal = pos + i; |
410 | int loc = pos + i + 1; |
||
411 | |||
22659 | jghali | 412 | if (loc > currentDoc->Pages->count()) |
413 | loc = currentDoc->Pages->count(); |
||
13424 | subik | 414 | |
11048 | jghali | 415 | QString qName(CommonStrings::trMasterPageNormal); |
416 | |||
22659 | jghali | 417 | if (currentDoc->pageSets()[currentDoc->pagePositioning()].Columns != 1) { |
418 | currentDoc->locationOfPage(loc); |
||
419 | switch (currentDoc->locationOfPage(loc)) |
||
11048 | jghali | 420 | { |
421 | case LeftPage: |
||
422 | qName = CommonStrings::trMasterPageNormalLeft; |
||
423 | break; |
||
424 | case RightPage: |
||
425 | qName = CommonStrings::trMasterPageNormalRight; |
||
426 | break; |
||
427 | case MiddlePage: |
||
428 | qName = CommonStrings::trMasterPageNormalMiddle; |
||
429 | break; |
||
430 | } |
||
431 | } |
||
432 | ScCore->primaryMainWindow()->slotNewPageP(locreal, qName); |
||
433 | } |
||
434 | } |
||
435 | |||
436 | /*! |
||
12071 | subik | 437 | \fn scribus_importpage(PyObject*, PyObject* args) |
11048 | jghali | 438 | \author Alessandro Pira <alex@alessandropira.org> |
439 | \date 11-11-2007 |
||
12071 | subik | 440 | \param PyObject unused reference |
441 | \param args Python function args ("fromDoc", (pageList), [create, imortwhere, importwherePage]) |
||
11048 | jghali | 442 | \retval Py_RETURN_NONE if ok, null if error |
443 | */ |
||
444 | PyObject *scribus_importpage(PyObject* /* self */, PyObject* args) |
||
445 | { |
||
22537 | craig | 446 | char *doc = nullptr; |
447 | PyObject *pages = nullptr; |
||
11048 | jghali | 448 | int createPageI = 1; |
449 | int importWhere = 2; |
||
450 | int importWherePage = 0; |
||
451 | |||
452 | if (!PyArg_ParseTuple(args, "sO|iii", &doc, &pages, &createPageI, &importWhere, &importWherePage)) |
||
22537 | craig | 453 | return nullptr; |
22653 | jghali | 454 | if (!checkHaveDocument()) |
22537 | craig | 455 | return nullptr; |
11048 | jghali | 456 | |
457 | if (!PyTuple_Check(pages)) |
||
458 | { |
||
21200 | craig | 459 | PyErr_SetString(PyExc_TypeError, QObject::tr("second argument is not tuple: must be tuple of integer values.","python error").toLocal8Bit().constData()); |
22537 | craig | 460 | return nullptr; |
11048 | jghali | 461 | } |
462 | |||
463 | Py_INCREF(pages); |
||
464 | std::vector<int> pageNs; |
||
465 | int i, n, p; |
||
466 | n = PyTuple_Size(pages); |
||
467 | for (i=0; i<n; i++) |
||
468 | { |
||
469 | if (!PyArg_Parse(PyTuple_GetItem(pages, i), "i", &p)) |
||
470 | { |
||
21200 | craig | 471 | PyErr_SetString(PyExc_TypeError, QObject::tr("second argument contains non-numeric values: must be list of integer values.","python error").toLocal8Bit().constData()); |
11048 | jghali | 472 | Py_DECREF(pages); |
22537 | craig | 473 | return nullptr; |
11048 | jghali | 474 | } |
475 | pageNs.push_back(p); |
||
476 | } |
||
477 | Py_DECREF(pages); |
||
478 | |||
479 | QString fromDoc = QString(doc); |
||
480 | bool createPage = (createPageI != 0); |
||
481 | |||
482 | int startPage=0, nrToImport=pageNs.size(); |
||
483 | bool doIt = true; |
||
484 | |||
22659 | jghali | 485 | ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc; |
486 | if (currentDoc->masterPageMode()) |
||
11048 | jghali | 487 | { |
488 | if (nrToImport > 1) |
||
489 | ScCore->primaryMainWindow()->loadPage(fromDoc, pageNs[0] - 1, false); |
||
490 | doIt = false; |
||
491 | } |
||
492 | else if (createPage) |
||
493 | { |
||
494 | if (importWhere == 0) //Before page |
||
495 | startPage = importWherePage; |
||
496 | else if (importWhere == 1) //After page |
||
497 | startPage = importWherePage + 1; |
||
498 | else //at end |
||
22659 | jghali | 499 | startPage = currentDoc->DocPages.count();// + 1; |
11048 | jghali | 500 | |
501 | import_addpages(nrToImport, startPage); |
||
502 | } |
||
503 | else |
||
504 | { |
||
22659 | jghali | 505 | startPage = currentDoc->currentPage()->pageNr() + 1; |
506 | if (nrToImport > (currentDoc->DocPages.count() - currentDoc->currentPage()->pageNr())) |
||
11048 | jghali | 507 | { |
22659 | jghali | 508 | int tmp=nrToImport - (currentDoc->DocPages.count() - currentDoc->currentPage()->pageNr()); |
509 | import_addpages(tmp, currentDoc->DocPages.count()); |
||
11048 | jghali | 510 | } |
511 | } |
||
512 | |||
513 | if (doIt) |
||
514 | { |
||
515 | if (nrToImport > 0) |
||
516 | { |
||
517 | int counter = startPage + 1; |
||
518 | for (int i = 0; i < nrToImport; ++i) |
||
519 | { |
||
520 | ScCore->primaryMainWindow()->view->GotoPa(counter); |
||
521 | ScCore->primaryMainWindow()->loadPage(fromDoc, pageNs[i] - 1, false); |
||
522 | counter++; |
||
523 | } |
||
524 | } |
||
525 | } |
||
526 | |||
527 | Py_RETURN_NONE; |
||
528 | } |
||
529 | |||
6200 | subik | 530 | /*! HACK: this removes "warning: 'blah' defined but not used" compiler warnings |
531 | with header files structure untouched (docstrings are kept near declarations) |
||
532 | PV */ |
||
533 | void cmdpagedocwarnings() |
||
534 | { |
||
20424 | jghali | 535 | QStringList s; |
23385 | jghali | 536 | s << scribus_currentpage__doc__ |
537 | << scribus_deletepage__doc__ |
||
538 | << scribus_getHguides__doc__ |
||
539 | << scribus_getVguides__doc__ |
||
540 | << scribus_getpageitems__doc__ |
||
541 | << scribus_getpagemargins__doc__ |
||
542 | << scribus_getpagensize__doc__ |
||
543 | << scribus_getpagetype__doc__ |
||
544 | << scribus_gotopage__doc__ |
||
545 | << scribus_importpage__doc__ |
||
546 | << scribus_newpage__doc__ |
||
547 | << scribus_pagecount__doc__ |
||
24091 | jghali | 548 | << scribus_getpagesize__doc__ |
23385 | jghali | 549 | << scribus_getpagenmargins__doc__ |
550 | << scribus_redraw__doc__ |
||
551 | << scribus_savepageeps__doc__ |
||
552 | << scribus_setHguides__doc__ |
||
553 | << scribus_setVguides__doc__; |
||
6200 | subik | 554 | } |