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 */
7 #include "cmdmisc.h"
8 #include "cmdutil.h"
9
10 #include "qbuffer.h"
11 #include "qpixmap.h"
12 //Added by qt3to4:
13 #include <QList>
14
15 #include "prefsmanager.h"
16 #include "scribuscore.h"
17 #include "scribusdoc.h"
18 #include "scribusview.h"
19 #include "selection.h"
20 #include "fonts/scfontmetrics.h"
21 #include "pdfoptionsio.h"
22
scribus_setredraw(PyObject *,PyObject * args)23 PyObject *scribus_setredraw(PyObject* /* self */, PyObject* args)
24 {
25 int e;
26 if (!PyArg_ParseTuple(args, "i", &e))
27 return nullptr;
28 if (!checkHaveDocument())
29 return nullptr;
30 ScCore->primaryMainWindow()->doc->DoDrawing = static_cast<bool>(e);
31 Py_RETURN_NONE;
32 }
33
scribus_getfontnames(PyObject *)34 PyObject *scribus_getfontnames(PyObject* /* self */)
35 {
36 int cc2 = 0;
37 SCFontsIterator it2(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts);
38 for ( ; it2.hasNext() ; it2.next())
39 {
40 if (it2.current().usable())
41 cc2++;
42 }
43 PyObject *l = PyList_New(cc2);
44 SCFontsIterator it(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts);
45 int cc = 0;
46 for ( ; it.hasNext() ; it.next())
47 {
48 if (it.current().usable())
49 {
50 PyList_SetItem(l, cc, PyUnicode_FromString(it.currentKey().toUtf8()));
51 cc++;
52 }
53 }
54 return l;
55 }
56
scribus_xfontnames(PyObject *)57 PyObject *scribus_xfontnames(PyObject* /* self */)
58 {
59 PyObject *l = PyList_New(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts.count());
60 SCFontsIterator it(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts);
61 int cc = 0;
62 PyObject *row;
63 for ( ; it.hasNext() ; it.next())
64 {
65 row = Py_BuildValue((char*)"(sssiis)",
66 it.currentKey().toUtf8().data(),
67 it.current().family().toUtf8().data(),
68 it.current().psName().toUtf8().data(),
69 it.current().subset(),
70 it.current().embedPs(),
71 it.current().fontFilePath().toUtf8().data()
72 );
73 PyList_SetItem(l, cc, row);
74 cc++;
75 } // for
76 return l;
77 }
78
79 // This function is fairly complex because it can either save its output to a
80 // file, or return it as a Python string.
scribus_renderfont(PyObject *,PyObject * args,PyObject * kw)81 PyObject *scribus_renderfont(PyObject* /*self*/, PyObject* args, PyObject* kw)
82 {
83 char *Name = const_cast<char*>("");
84 char *FileName = const_cast<char*>("");
85 char *Sample = const_cast<char*>("");
86 char *format = nullptr;
87 int Size;
88 bool ret = false;
89 char *kwargs[] = {const_cast<char*>("fontname"),
90 const_cast<char*>("filename"),
91 const_cast<char*>("sample"),
92 const_cast<char*>("size"),
93 const_cast<char*>("format"),
94 nullptr};
95 if (!PyArg_ParseTupleAndKeywords(args, kw, "esesesi|es", kwargs,
96 "utf-8", &Name, "utf-8", &FileName, "utf-8", &Sample, &Size, "ascii", &format))
97 return nullptr;
98 if (!PrefsManager::instance().appPrefs.fontPrefs.AvailFonts.contains(QString::fromUtf8(Name)))
99 {
100 PyErr_SetString(NotFoundError, QObject::tr("Font not found.","python error").toLocal8Bit().constData());
101 return nullptr;
102 }
103 QVector<uint> ts = QString::fromUtf8(Sample).toUcs4();
104 if (ts.isEmpty())
105 {
106 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot render an empty sample.","python error").toLocal8Bit().constData());
107 return nullptr;
108 }
109 if (!format)
110 // User specified no format, so use the historical default of PPM format.
111 format = const_cast<char*>("PPM");
112 QPixmap pm = FontSample(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts[QString::fromUtf8(Name)], Size, ts, Qt::white);
113 // If the user specified an empty filename, return the image data as bytes. Otherwise, save it to disk.
114 if (QString::fromUtf8(FileName).isEmpty())
115 {
116 QByteArray buffer_string = "";
117 QBuffer buffer(&buffer_string);
118 buffer.open(QIODevice::WriteOnly);
119 bool ret = pm.save(&buffer, format);
120 if (!ret)
121 {
122 PyErr_SetString(ScribusException, QObject::tr("Unable to save pixmap","scripter error").toLocal8Bit().constData());
123 return nullptr;
124 }
125 int bufferSize = buffer.size();
126 buffer.close();
127 // Now make a Python string from the data we generated
128 PyObject* stringPython = PyBytes_FromStringAndSize(buffer_string, bufferSize);
129 // Return even if the result is nullptr (error) since an exception will have been
130 // set in that case.
131 return stringPython;
132 }
133
134 // Save the pixmap to a file, since the filename is non-empty
135 ret = pm.save(QString::fromUtf8(FileName), format);
136 if (!ret)
137 {
138 PyErr_SetString(PyExc_Exception, QObject::tr("Unable to save pixmap","scripter error").toLocal8Bit().constData());
139 return nullptr;
140 }
141 // For historical reasons, we need to return true on success.
142 // Py_INCREF(Py_True);
143 // return Py_True;
144 // Py_RETURN_TRUE;
145 return PyBool_FromLong(static_cast<long>(true));
146 }
147
scribus_getlayers(PyObject *)148 PyObject *scribus_getlayers(PyObject* /* self */)
149 {
150 if (!checkHaveDocument())
151 return nullptr;
152 ScribusDoc* doc = ScCore->primaryMainWindow()->doc;
153 PyObject *l = PyList_New(doc->Layers.count());
154 for (int i = 0; i < doc->Layers.count(); i++)
155 PyList_SetItem(l, i, PyUnicode_FromString(doc->Layers[i].Name.toUtf8()));
156 return l;
157 }
158
scribus_setactivelayer(PyObject *,PyObject * args)159 PyObject *scribus_setactivelayer(PyObject* /* self */, PyObject* args)
160 {
161 char *Name = const_cast<char*>("");
162 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
163 return nullptr;
164 if (!checkHaveDocument())
165 return nullptr;
166 if (Name == nullptr)
167 {
168 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
169 return nullptr;
170 }
171 bool found = ScCore->primaryMainWindow()->doc->setActiveLayer(QString::fromUtf8(Name));
172 if (found)
173 ScCore->primaryMainWindow()->changeLayer(ScCore->primaryMainWindow()->doc->activeLayer());
174 else
175 {
176 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
177 return nullptr;
178 }
179 Py_RETURN_NONE;
180 }
181
scribus_getactivelayer(PyObject *)182 PyObject *scribus_getactivelayer(PyObject* /* self */)
183 {
184 if (!checkHaveDocument())
185 return nullptr;
186 return PyUnicode_FromString(ScCore->primaryMainWindow()->doc->activeLayerName().toUtf8());
187 }
188
scribus_loweractivelayer(PyObject *)189 PyObject *scribus_loweractivelayer(PyObject* /* self */)
190 {
191 if (!checkHaveDocument())
192 return nullptr;
193 int activeLayer = ScCore->primaryMainWindow()->doc->activeLayer();
194 ScCore->primaryMainWindow()->doc->lowerLayer(activeLayer);
195 Py_RETURN_NONE;
196 }
197
scribus_raiseactivelayer(PyObject *)198 PyObject *scribus_raiseactivelayer(PyObject* /* self */)
199 {
200 if (!checkHaveDocument())
201 return nullptr;
202 int activeLayer = ScCore->primaryMainWindow()->doc->activeLayer();
203 ScCore->primaryMainWindow()->doc->raiseLayer(activeLayer);
204 Py_RETURN_NONE;
205 }
206
scribus_sendtolayer(PyObject *,PyObject * args)207 PyObject *scribus_sendtolayer(PyObject* /* self */, PyObject* args)
208 {
209 char *Name = const_cast<char*>("");
210 char *Layer = const_cast<char*>("");
211 if (!PyArg_ParseTuple(args, "es|es", "utf-8", &Layer, "utf-8", &Name))
212 return nullptr;
213 if (!checkHaveDocument())
214 return nullptr;
215 if (strlen(Layer) == 0)
216 {
217 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
218 return nullptr;
219 }
220 PageItem *item = GetUniqueItem(QString::fromUtf8(Name));
221 if (item == nullptr)
222 return nullptr;
223 ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
224 ScribusView* currentView = ScCore->primaryMainWindow()->view;
225 const ScLayer *scLayer = currentDoc->Layers.layerByName( QString::fromUtf8(Layer) );
226 if (!scLayer)
227 {
228 PyErr_SetString(ScribusException, QString("Layer not found").toLocal8Bit().constData());
229 return nullptr;
230 }
231 // If no name have been specified in args, process whole selection
232 currentView->selectItem(item);
233 if (strlen(Name) == 0)
234 {
235 for (int i = 0; i < currentDoc->m_Selection->count(); ++i)
236 {
237 item = currentDoc->m_Selection->itemAt(i);
238 item->m_layerID = scLayer->ID;
239 }
240 }
241 else
242 {
243 item->m_layerID = scLayer->ID;
244 }
245
246 Py_RETURN_NONE;
247 }
248
scribus_setlayervisible(PyObject *,PyObject * args)249 PyObject *scribus_setlayervisible(PyObject* /* self */, PyObject* args)
250 {
251 char *Name = const_cast<char*>("");
252 int vis = 1;
253 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
254 return nullptr;
255 if (!checkHaveDocument())
256 return nullptr;
257 if (strlen(Name) == 0)
258 {
259 PyErr_SetString(PyExc_ValueError, QString("Cannot have an empty layer name").toLocal8Bit().constData());
260 return nullptr;
261 }
262 bool found = false;
263 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
264 {
265 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
266 {
267 ScCore->primaryMainWindow()->doc->Layers[lam].isViewable = vis;
268 found = true;
269 break;
270 }
271 }
272 if (!found)
273 {
274 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
275 return nullptr;
276 }
277 Py_RETURN_NONE;
278 }
279
scribus_setlayerprintable(PyObject *,PyObject * args)280 PyObject *scribus_setlayerprintable(PyObject* /* self */, PyObject* args)
281 {
282 char *Name = const_cast<char*>("");
283 int vis = 1;
284 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
285 return nullptr;
286 if (!checkHaveDocument())
287 return nullptr;
288 if (strlen(Name) == 0)
289 {
290 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
291 return nullptr;
292 }
293 bool found = false;
294 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
295 {
296 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
297 {
298 ScCore->primaryMainWindow()->doc->Layers[lam].isPrintable = vis;
299 found = true;
300 break;
301 }
302 }
303 if (!found)
304 {
305 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
306 return nullptr;
307 }
308 Py_RETURN_NONE;
309 }
310
scribus_setlayerlocked(PyObject *,PyObject * args)311 PyObject *scribus_setlayerlocked(PyObject* /* self */, PyObject* args)
312 {
313 char *Name = const_cast<char*>("");
314 int vis = 1;
315 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
316 return nullptr;
317 if (!checkHaveDocument())
318 return nullptr;
319 if (strlen(Name) == 0)
320 {
321 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
322 return nullptr;
323 }
324 bool found = false;
325 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
326 {
327 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
328 {
329 ScCore->primaryMainWindow()->doc->Layers[lam].isEditable = vis;
330 found = true;
331 break;
332 }
333 }
334 if (!found)
335 {
336 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
337 return nullptr;
338 }
339 Py_RETURN_NONE;
340 }
341
scribus_setlayeroutlined(PyObject *,PyObject * args)342 PyObject *scribus_setlayeroutlined(PyObject* /* self */, PyObject* args)
343 {
344 char *Name = const_cast<char*>("");
345 int vis = 1;
346 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
347 return nullptr;
348 if (!checkHaveDocument())
349 return nullptr;
350 if (strlen(Name) == 0)
351 {
352 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
353 return nullptr;
354 }
355 bool found = false;
356 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
357 {
358 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
359 {
360 ScCore->primaryMainWindow()->doc->Layers[lam].outlineMode = vis;
361 found = true;
362 break;
363 }
364 }
365 if (!found)
366 {
367 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
368 return nullptr;
369 }
370 Py_RETURN_NONE;
371 }
372
scribus_setlayerflow(PyObject *,PyObject * args)373 PyObject *scribus_setlayerflow(PyObject* /* self */, PyObject* args)
374 {
375 char *Name = const_cast<char*>("");
376 int vis = 1;
377 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
378 return nullptr;
379 if (!checkHaveDocument())
380 return nullptr;
381 if (strlen(Name) == 0)
382 {
383 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
384 return nullptr;
385 }
386 bool found = false;
387 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
388 {
389 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
390 {
391 ScCore->primaryMainWindow()->doc->Layers[lam].flowControl = vis;
392 found = true;
393 break;
394 }
395 }
396 if (!found)
397 {
398 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
399 return nullptr;
400 }
401 Py_RETURN_NONE;
402 }
403
scribus_setlayerblendmode(PyObject *,PyObject * args)404 PyObject *scribus_setlayerblendmode(PyObject* /* self */, PyObject* args)
405 {
406 char *Name = const_cast<char*>("");
407 int vis = 0;
408 if (!PyArg_ParseTuple(args, "esi", "utf-8", &Name, &vis))
409 return nullptr;
410 if (!checkHaveDocument())
411 return nullptr;
412 if (strlen(Name) == 0)
413 {
414 PyErr_SetString(PyExc_ValueError, QString("Cannot have an empty layer name").toLocal8Bit().constData());
415 return nullptr;
416 }
417 bool found = false;
418 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
419 {
420 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
421 {
422 ScCore->primaryMainWindow()->doc->Layers[lam].blendMode = vis;
423 found = true;
424 break;
425 }
426 }
427 if (!found)
428 {
429 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
430 return nullptr;
431 }
432 Py_RETURN_NONE;
433 }
434
scribus_setlayertransparency(PyObject *,PyObject * args)435 PyObject *scribus_setlayertransparency(PyObject* /* self */, PyObject* args)
436 {
437 char *Name = const_cast<char*>("");
438 double vis = 1.0;
439 if (!PyArg_ParseTuple(args, "esd", "utf-8", &Name, &vis))
440 return nullptr;
441 if (!checkHaveDocument())
442 return nullptr;
443 if (strlen(Name) == 0)
444 {
445 PyErr_SetString(PyExc_ValueError, QString("Cannot have an empty layer name").toLocal8Bit().constData());
446 return nullptr;
447 }
448 bool found = false;
449 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
450 {
451 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
452 {
453 ScCore->primaryMainWindow()->doc->Layers[lam].transparency = vis;
454 found = true;
455 break;
456 }
457 }
458 if (!found)
459 {
460 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
461 return nullptr;
462 }
463 Py_RETURN_NONE;
464 }
465
scribus_islayervisible(PyObject *,PyObject * args)466 PyObject *scribus_islayervisible(PyObject* /* self */, PyObject* args)
467 {
468 char *Name = const_cast<char*>("");
469 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
470 return nullptr;
471 if (!checkHaveDocument())
472 return nullptr;
473 if (strlen(Name) == 0)
474 {
475 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
476 return nullptr;
477 }
478 int i = 0;
479 bool found = false;
480 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
481 {
482 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
483 {
484 i = static_cast<int>(ScCore->primaryMainWindow()->doc->Layers[lam].isViewable);
485 found = true;
486 break;
487 }
488 }
489 if (!found)
490 {
491 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
492 return nullptr;
493 }
494 return PyLong_FromLong(static_cast<long>(i));
495 }
496
scribus_islayerprintable(PyObject *,PyObject * args)497 PyObject *scribus_islayerprintable(PyObject* /* self */, PyObject* args)
498 {
499 char *Name = const_cast<char*>("");
500 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
501 return nullptr;
502 if (!checkHaveDocument())
503 return nullptr;
504 if (strlen(Name) == 0)
505 {
506 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
507 return nullptr;
508 }
509 int i = 0;
510 bool found = false;
511 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
512 {
513 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
514 {
515 i = static_cast<int>(ScCore->primaryMainWindow()->doc->Layers[lam].isPrintable);
516 found = true;
517 break;
518 }
519 }
520 if (!found)
521 {
522 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
523 return nullptr;
524 }
525 return PyLong_FromLong(static_cast<long>(i));
526 }
527
scribus_islayerlocked(PyObject *,PyObject * args)528 PyObject *scribus_islayerlocked(PyObject* /* self */, PyObject* args)
529 {
530 char *Name = const_cast<char*>("");
531 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
532 return nullptr;
533 if (!checkHaveDocument())
534 return nullptr;
535 if (strlen(Name) == 0)
536 {
537 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
538 return nullptr;
539 }
540 int i = 0;
541 bool found = false;
542 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
543 {
544 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
545 {
546 i = static_cast<int>(ScCore->primaryMainWindow()->doc->Layers[lam].isEditable);
547 found = true;
548 break;
549 }
550 }
551 if (!found)
552 {
553 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
554 return nullptr;
555 }
556 return PyLong_FromLong(static_cast<long>(i));
557 }
558
scribus_islayeroutlined(PyObject *,PyObject * args)559 PyObject *scribus_islayeroutlined(PyObject* /* self */, PyObject* args)
560 {
561 char *Name = const_cast<char*>("");
562 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
563 return nullptr;
564 if (!checkHaveDocument())
565 return nullptr;
566 if (strlen(Name) == 0)
567 {
568 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
569 return nullptr;
570 }
571 int i = 0;
572 bool found = false;
573 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
574 {
575 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
576 {
577 i = static_cast<int>(ScCore->primaryMainWindow()->doc->Layers[lam].outlineMode);
578 found = true;
579 break;
580 }
581 }
582 if (!found)
583 {
584 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
585 return nullptr;
586 }
587 return PyLong_FromLong(static_cast<long>(i));
588 }
589
scribus_islayerflow(PyObject *,PyObject * args)590 PyObject *scribus_islayerflow(PyObject* /* self */, PyObject* args)
591 {
592 char *Name = const_cast<char*>("");
593 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
594 return nullptr;
595 if (!checkHaveDocument())
596 return nullptr;
597 if (strlen(Name) == 0)
598 {
599 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
600 return nullptr;
601 }
602 int i = 0;
603 bool found = false;
604 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
605 {
606 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
607 {
608 i = static_cast<int>(ScCore->primaryMainWindow()->doc->Layers[lam].flowControl);
609 found = true;
610 break;
611 }
612 }
613 if (!found)
614 {
615 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
616 return nullptr;
617 }
618 return PyLong_FromLong(static_cast<long>(i));
619 }
620
scribus_getlayerblendmode(PyObject *,PyObject * args)621 PyObject *scribus_getlayerblendmode(PyObject* /* self */, PyObject* args)
622 {
623 char *Name = const_cast<char*>("");
624 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
625 return nullptr;
626 if (!checkHaveDocument())
627 return nullptr;
628 if (strlen(Name) == 0)
629 {
630 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
631 return nullptr;
632 }
633 int i = 0;
634 bool found = false;
635 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
636 {
637 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
638 {
639 i = ScCore->primaryMainWindow()->doc->Layers[lam].blendMode;
640 found = true;
641 break;
642 }
643 }
644 if (!found)
645 {
646 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
647 return nullptr;
648 }
649 return PyLong_FromLong(static_cast<long>(i));
650 }
651
scribus_getlayertransparency(PyObject *,PyObject * args)652 PyObject *scribus_getlayertransparency(PyObject* /* self */, PyObject* args)
653 {
654 char *Name = const_cast<char*>("");
655 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
656 return nullptr;
657 if (!checkHaveDocument())
658 return nullptr;
659 if (strlen(Name) == 0)
660 {
661 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
662 return nullptr;
663 }
664 double i = 1.0;
665 bool found = false;
666 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); lam++)
667 {
668 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
669 {
670 i = ScCore->primaryMainWindow()->doc->Layers[lam].transparency;
671 found = true;
672 break;
673 }
674 }
675 if (!found)
676 {
677 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
678 return nullptr;
679 }
680 return PyFloat_FromDouble(i);
681 }
682
scribus_deletelayer(PyObject *,PyObject * args)683 PyObject *scribus_deletelayer(PyObject* /* self */, PyObject* args)
684 {
685 //FIXME: Use the docs remove layer code
686 char *Name = const_cast<char*>("");
687 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
688 return nullptr;
689 if (!checkHaveDocument())
690 return nullptr;
691 if (strlen(Name) == 0)
692 {
693 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot have an empty layer name.","python error").toLocal8Bit().constData());
694 return nullptr;
695 }
696 if (ScCore->primaryMainWindow()->doc->Layers.count() == 1)
697 {
698 PyErr_SetString(ScribusException, QObject::tr("Cannot remove the last layer.","python error").toLocal8Bit().constData());
699 return nullptr;
700 }
701 bool found = false;
702 for (int lam=0; lam < ScCore->primaryMainWindow()->doc->Layers.count(); ++lam)
703 {
704 if (ScCore->primaryMainWindow()->doc->Layers[lam].Name == QString::fromUtf8(Name))
705 {
706 ScLayer it2 = ScCore->primaryMainWindow()->doc->Layers.at(lam);
707 int num2 = it2.ID;
708 if (!num2)
709 {
710 // FIXME: WTF DOES THIS DO?
711 Py_INCREF(Py_None);
712 return Py_None;
713 }
714 ScCore->primaryMainWindow()->doc->removeLayer(num2);
715 ScCore->primaryMainWindow()->doc->Layers.removeLayerByID(num2);
716 ScCore->primaryMainWindow()->doc->setActiveLayer(0);
717 ScCore->primaryMainWindow()->changeLayer(0);
718 found = true;
719 break;
720 }
721 }
722 if (!found)
723 {
724 PyErr_SetString(NotFoundError, QObject::tr("Layer not found.","python error").toLocal8Bit().constData());
725 return nullptr;
726 }
727 Py_RETURN_NONE;
728 }
729
scribus_createlayer(PyObject *,PyObject * args)730 PyObject *scribus_createlayer(PyObject* /* self */, PyObject* args)
731 {
732 char *Name = const_cast<char*>("");
733 if (!PyArg_ParseTuple(args, "es", "utf-8", &Name))
734 return nullptr;
735 if (!checkHaveDocument())
736 return nullptr;
737 if (strlen(Name) == 0)
738 {
739 PyErr_SetString(PyExc_ValueError, QObject::tr("Cannot create layer without a name.","python error").toLocal8Bit().constData());
740 return nullptr;
741 }
742 ScCore->primaryMainWindow()->doc->addLayer(QString::fromUtf8(Name), true);
743 ScCore->primaryMainWindow()->changeLayer(ScCore->primaryMainWindow()->doc->activeLayer());
744 Py_RETURN_NONE;
745 }
746
scribus_filequit(PyObject *,PyObject * args)747 PyObject *scribus_filequit(PyObject* /* self */, PyObject* args)
748 {
749 QMetaObject::invokeMethod(ScCore->primaryMainWindow(), "slotFileQuit", Qt::QueuedConnection);
750 Py_RETURN_NONE;
751 }
752
scribus_getlanguage(PyObject *)753 PyObject *scribus_getlanguage(PyObject* /* self */)
754 {
755 return PyUnicode_FromString(ScCore->getGuiLanguage().toUtf8());
756 }
757
758 /*! 04.01.2007 : Joachim Neu : Moves item selection to front. */
scribus_moveselectiontofront(PyObject *)759 PyObject *scribus_moveselectiontofront(PyObject*)
760 {
761 ScCore->primaryMainWindow()->doc->bringItemSelectionToFront();
762 Py_RETURN_NONE;
763 }
764
765 /*! 04.01.2007 : Joachim Neu : Moves item selection to back. */
scribus_moveselectiontoback(PyObject *)766 PyObject *scribus_moveselectiontoback(PyObject*)
767 {
768 ScCore->primaryMainWindow()->doc->sendItemSelectionToBack();
769 Py_RETURN_NONE;
770 }
771
scribus_savepdfoptions(PyObject *,PyObject * args)772 PyObject *scribus_savepdfoptions(PyObject* /* self */, PyObject* args)
773 {
774 char* file;
775 if (!checkHaveDocument())
776 return nullptr;
777 if (!PyArg_ParseTuple(args, const_cast<char*>("es"), "utf-8", &file))
778 return nullptr;
779
780 PDFOptionsIO io(ScCore->primaryMainWindow()->doc->pdfOptions());
781 if (!io.writeTo(file))
782 {
783 PyErr_SetString(ScribusException, io.lastError().toUtf8());
784 return nullptr;
785 }
786 Py_RETURN_NONE;
787 }
788
scribus_readpdfoptions(PyObject *,PyObject * args)789 PyObject *scribus_readpdfoptions(PyObject* /* self */, PyObject* args)
790 {
791 char* file;
792 if (!checkHaveDocument())
793 return nullptr;
794 if (!PyArg_ParseTuple(args, const_cast<char*>("es"), "utf-8", &file))
795 return nullptr;
796
797 PDFOptionsIO io(ScCore->primaryMainWindow()->doc->pdfOptions());
798 if (!io.readFrom(file))
799 {
800 PyErr_SetString(ScribusException, io.lastError().toUtf8());
801 return nullptr;
802 }
803 Py_RETURN_NONE;
804 }
805
806 /*! HACK: this removes "warning: 'blah' defined but not used" compiler warnings
807 with header files structure untouched (docstrings are kept near declarations)
808 PV */
cmdmiscdocwarnings()809 void cmdmiscdocwarnings()
810 {
811 QStringList s;
812 s << scribus_createlayer__doc__
813 << scribus_deletelayer__doc__
814 << scribus_filequit__doc__
815 << scribus_getfontnames__doc__
816 << scribus_getactivelayer__doc__
817 << scribus_getlanguage__doc__
818 << scribus_getlayerblendmode__doc__
819 << scribus_getlayers__doc__
820 << scribus_getlayertransparency__doc__
821 << scribus_islayerflow__doc__
822 << scribus_islayerlocked__doc__
823 << scribus_islayeroutlined__doc__
824 << scribus_islayerprintable__doc__
825 << scribus_islayervisible__doc__
826 << scribus_loweractivelayer__doc__
827 << scribus_moveselectiontoback__doc__
828 << scribus_moveselectiontofront__doc__
829 << scribus_raiseactivelayer__doc__
830 << scribus_readpdfoptions__doc__
831 << scribus_renderfont__doc__
832 << scribus_savepdfoptions__doc__
833 << scribus_sendtolayer__doc__
834 << scribus_setactivelayer__doc__
835 << scribus_setlayerblendmode__doc__
836 << scribus_setlayerflow__doc__
837 << scribus_setlayerlocked__doc__
838 << scribus_setlayeroutlined__doc__
839 << scribus_setlayerprintable__doc__
840 << scribus_setlayertransparency__doc__
841 << scribus_setlayervisible__doc__
842 << scribus_setredraw__doc__
843 << scribus_xfontnames__doc__;
844 }
845