Subversion Repositories Scribus

Rev

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
}