Subversion Repositories Scribus

Rev

Rev 5721 | Rev 5774 | Go to most recent revision | 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 "cmdtext.h"
8
#include "cmdutil.h"
3829 cbradney 9
#include "pageitem_textframe.h"
2834 cbradney 10
#include "prefsmanager.h"
3934 cbradney 11
#include "selection.h"
5569 avox 12
#include "util.h"
82 Franz 13
 
2790 craig 14
PyObject *scribus_getfontsize(PyObject* /* self */, PyObject* args)
82 Franz 15
{
934 subik 16
        char *Name = const_cast<char*>("");
900 cbradney 17
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 18
                return NULL;
649 fschmid 19
        if(!checkHaveDocument())
20
                return NULL;
900 cbradney 21
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 22
        if (it == NULL)
23
                return NULL;
3625 avox 24
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 25
        {
26
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get font size of non-text frame.","python error"));
27
                return NULL;
28
        }
720 subik 29
        if (it->HasSel)
213 Franz 30
        {
5753 jghali 31
                for (int b = 0; b < it->itemText.length(); b++)
5721 avox 32
                        if (it->itemText.selected(b))
33
                                return PyFloat_FromDouble(static_cast<double>(it->itemText.charStyle(b).fontSize() / 10.0));
1162 cbradney 34
                return NULL;
213 Franz 35
        }
720 subik 36
        else
5559 avox 37
                return PyFloat_FromDouble(static_cast<long>(it->currentCharStyle().fontSize() / 10.0));
82 Franz 38
}
39
 
2790 craig 40
PyObject *scribus_getfont(PyObject* /* self */, PyObject* args)
82 Franz 41
{
934 subik 42
        char *Name = const_cast<char*>("");
900 cbradney 43
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 44
                return NULL;
649 fschmid 45
        if(!checkHaveDocument())
46
                return NULL;
900 cbradney 47
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 48
        if (it == NULL)
49
                return NULL;
3625 avox 50
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 51
        {
52
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get font of non-text frame.","python error"));
53
                return NULL;
54
        }
720 subik 55
        if (it->HasSel)
213 Franz 56
        {
5753 jghali 57
                for (int b = 0; b < it->itemText.length(); b++)
5721 avox 58
                        if (it->itemText.selected(b))
59
                                return PyString_FromString(it->itemText.charStyle(b).font()->scName().utf8());
1162 cbradney 60
                return NULL;
213 Franz 61
        }
720 subik 62
        else
5559 avox 63
                return PyString_FromString(it->currentCharStyle().font()->scName().utf8());
82 Franz 64
}
65
 
2790 craig 66
PyObject *scribus_gettextsize(PyObject* /* self */, PyObject* args)
82 Franz 67
{
934 subik 68
        char *Name = const_cast<char*>("");
900 cbradney 69
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 70
                return NULL;
649 fschmid 71
        if(!checkHaveDocument())
72
                return NULL;
900 cbradney 73
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
853 subik 74
        if (i == NULL)
75
                return NULL;
3625 avox 76
        if (!(i->asTextFrame()) && !(i->asPathText()))
853 subik 77
        {
78
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get text size of non-text frame.","python error"));
79
                return NULL;
80
        }
5721 avox 81
        return PyInt_FromLong(static_cast<long>(i->itemText.length()));
82 Franz 82
}
83
 
2790 craig 84
PyObject *scribus_getcolumns(PyObject* /* self */, PyObject* args)
138 Franz 85
{
934 subik 86
        char *Name = const_cast<char*>("");
900 cbradney 87
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
138 Franz 88
                return NULL;
649 fschmid 89
        if(!checkHaveDocument())
90
                return NULL;
900 cbradney 91
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
853 subik 92
        if (i == NULL)
93
                return NULL;
3625 avox 94
        if (!i->asTextFrame())
853 subik 95
        {
96
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get column count of non-text frame.","python error"));
97
                return NULL;
98
        }
99
        return PyInt_FromLong(static_cast<long>(i->Cols));
138 Franz 100
}
101
 
2790 craig 102
PyObject *scribus_getlinespace(PyObject* /* self */, PyObject* args)
82 Franz 103
{
934 subik 104
        char *Name = const_cast<char*>("");
900 cbradney 105
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 106
                return NULL;
649 fschmid 107
        if(!checkHaveDocument())
108
                return NULL;
900 cbradney 109
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
853 subik 110
        if (i == NULL)
111
                return NULL;
3625 avox 112
        if (!i->asTextFrame())
853 subik 113
        {
114
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get line space of non-text frame.","python error"));
115
                return NULL;
116
        }
5559 avox 117
        return PyFloat_FromDouble(static_cast<double>(i->currentStyle().lineSpacing()));
82 Franz 118
}
119
 
2790 craig 120
PyObject *scribus_getcolumngap(PyObject* /* self */, PyObject* args)
138 Franz 121
{
934 subik 122
        char *Name = const_cast<char*>("");
900 cbradney 123
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
138 Franz 124
                return NULL;
649 fschmid 125
        if(!checkHaveDocument())
126
                return NULL;
900 cbradney 127
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
853 subik 128
        if (i == NULL)
129
                return NULL;
3625 avox 130
        if (!i->asTextFrame())
853 subik 131
        {
132
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get column gap of non-text frame.","python error"));
133
                return NULL;
134
        }
1512 craig 135
        return PyFloat_FromDouble(PointToValue(static_cast<double>(i->ColGap)));
138 Franz 136
}
137
 
2790 craig 138
PyObject *scribus_getframetext(PyObject* /* self */, PyObject* args)
95 Franz 139
{
934 subik 140
        char *Name = const_cast<char*>("");
900 cbradney 141
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
95 Franz 142
                return NULL;
649 fschmid 143
        if(!checkHaveDocument())
144
                return NULL;
95 Franz 145
        QString text = "";
900 cbradney 146
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 147
        if (it == NULL)
148
                return NULL;
3625 avox 149
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 150
        {
151
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get text of non-text frame.","python error"));
152
                return NULL;
153
        }
5753 jghali 154
        for (int a = it->firstInFrame(); a < it->lastInFrame(); a++)
213 Franz 155
        {
720 subik 156
                if (it->HasSel)
213 Franz 157
                {
5721 avox 158
                        if (it->itemText.selected(a))
159
                                text += it->itemText.text(a);
213 Franz 160
                }
720 subik 161
                else
162
                {
5721 avox 163
                        text += it->itemText.text(a);
720 subik 164
                }
213 Franz 165
        }
900 cbradney 166
        return PyString_FromString(text.utf8());
95 Franz 167
}
168
 
2790 craig 169
PyObject *scribus_gettext(PyObject* /* self */, PyObject* args)
82 Franz 170
{
934 subik 171
        char *Name = const_cast<char*>("");
900 cbradney 172
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 173
                return NULL;
649 fschmid 174
        if(!checkHaveDocument())
175
                return NULL;
87 Franz 176
        QString text = "";
900 cbradney 177
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 178
        if (it == NULL)
179
                return NULL;
3625 avox 180
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 181
        {
182
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot get text of non-text frame.","python error"));
183
                return NULL;
184
        }
5721 avox 185
 
186
        // collect all chars from a storytext
5753 jghali 187
        for (int a = 0; a < it->itemText.length(); a++)
213 Franz 188
        {
720 subik 189
                if (it->HasSel)
190
                {
5721 avox 191
                        if (it->itemText.selected(a))
192
                                text += it->itemText.text(a);
720 subik 193
                }
194
                else
195
                {
5721 avox 196
                        text += it->itemText.text(a);
720 subik 197
                }
198
        } // for
900 cbradney 199
        return PyString_FromString(text.utf8());
82 Franz 200
}
201
 
2790 craig 202
PyObject *scribus_setboxtext(PyObject* /* self */, PyObject* args)
82 Franz 203
{
934 subik 204
        char *Name = const_cast<char*>("");
82 Franz 205
        char *Text;
900 cbradney 206
        if (!PyArg_ParseTuple(args, "es|es", "utf-8", &Text, "utf-8", &Name))
82 Franz 207
                return NULL;
649 fschmid 208
        if(!checkHaveDocument())
209
                return NULL;
1957 cbradney 210
        PageItem *currItem = GetUniqueItem(QString::fromUtf8(Name));
211
        if (currItem == NULL)
720 subik 212
                return NULL;
3625 avox 213
        if (!(currItem->asTextFrame()) && !(currItem->asPathText()))
853 subik 214
        {
215
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set text of non-text frame.","python error"));
216
                return NULL;
217
        }
391 Franz 218
        QString Daten = QString::fromUtf8(Text);
219
        PyMem_Free(Text);
1957 cbradney 220
        currItem->itemText.clear();
221
        currItem->CPos = 0;
4026 craig 222
        for (uint a = 0; a < ScMW->doc->FrameItems.count(); ++a)
2447 fschmid 223
        {
4026 craig 224
                ScMW->doc->FrameItems.at(a)->ItemNr = a;
2447 fschmid 225
        }
5721 avox 226
        currItem->itemText.insertChars(0, Daten);
2703 fschmid 227
        currItem->Dirty = false;
647 fschmid 228
        Py_INCREF(Py_None);
82 Franz 229
        return Py_None;
230
}
231
 
2790 craig 232
PyObject *scribus_inserttext(PyObject* /* self */, PyObject* args)
82 Franz 233
{
934 subik 234
        char *Name = const_cast<char*>("");
82 Franz 235
        char *Text;
87 Franz 236
        int pos;
900 cbradney 237
        if (!PyArg_ParseTuple(args, "esi|es", "utf-8", &Text, &pos, "utf-8", &Name))
82 Franz 238
                return NULL;
649 fschmid 239
        if(!checkHaveDocument())
240
                return NULL;
900 cbradney 241
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 242
        if (it == NULL)
243
                return NULL;
3625 avox 244
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 245
        {
246
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot insert text into non-text frame.","python error"));
247
                return NULL;
248
        }
391 Franz 249
        QString Daten = QString::fromUtf8(Text);
250
        PyMem_Free(Text);
5721 avox 251
        if ((pos < -1) || (pos > static_cast<int>(it->itemText.length())))
213 Franz 252
        {
1525 cbradney 253
                PyErr_SetString(PyExc_IndexError, QObject::tr("Insert index out of bounds.","python error"));
720 subik 254
                return NULL;
213 Franz 255
        }
1977 craig 256
        if (pos == -1)
5721 avox 257
                pos = it->itemText.length();
5559 avox 258
        it->itemText.insertChars(pos, Daten);
720 subik 259
        it->CPos = pos + Daten.length();
4210 subik 260
        it->Dirty = true;
261
        if (ScMW->doc->DoDrawing)
4211 subik 262
        {
4210 subik 263
                it->paintObj();
4211 subik 264
                it->Dirty = false;
265
        }
647 fschmid 266
        Py_INCREF(Py_None);
82 Franz 267
        return Py_None;
268
}
269
 
2790 craig 270
PyObject *scribus_setalign(PyObject* /* self */, PyObject* args)
82 Franz 271
{
934 subik 272
        char *Name = const_cast<char*>("");
720 subik 273
        int alignment;
900 cbradney 274
        if (!PyArg_ParseTuple(args, "i|es", &alignment, "utf-8", &Name))
82 Franz 275
                return NULL;
649 fschmid 276
        if(!checkHaveDocument())
277
                return NULL;
816 subik 278
        if ((alignment > 4) || (alignment < 0))
647 fschmid 279
        {
853 subik 280
                PyErr_SetString(PyExc_ValueError, QObject::tr("Alignment out of range. Use one of the scribus.ALIGN* constants.","python error"));
720 subik 281
                return NULL;
647 fschmid 282
        }
900 cbradney 283
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 284
        if (i == NULL)
285
                return NULL;
3625 avox 286
        if (!i->asTextFrame())
213 Franz 287
        {
1525 cbradney 288
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set text alignment on a non-text frame.","python error"));
720 subik 289
                return NULL;
213 Franz 290
        }
4026 craig 291
        int Apm = ScMW->doc->appMode;
4847 cbradney 292
        ScMW->doc->m_Selection->clear();
293
        ScMW->doc->m_Selection->addItem(i);
720 subik 294
        if (i->HasSel)
4026 craig 295
                ScMW->doc->appMode = modeEdit;
296
        ScMW->setNewAbStyle(alignment);
297
        ScMW->doc->appMode = Apm;
298
        ScMW->view->Deselect();
647 fschmid 299
        Py_INCREF(Py_None);
82 Franz 300
        return Py_None;
301
}
302
 
2790 craig 303
PyObject *scribus_setfontsize(PyObject* /* self */, PyObject* args)
82 Franz 304
{
934 subik 305
        char *Name = const_cast<char*>("");
111 Franz 306
        double size;
900 cbradney 307
        if (!PyArg_ParseTuple(args, "d|es", &size, "utf-8", &Name))
82 Franz 308
                return NULL;
649 fschmid 309
        if(!checkHaveDocument())
310
                return NULL;
82 Franz 311
        if ((size > 512) || (size < 1))
647 fschmid 312
        {
1525 cbradney 313
                PyErr_SetString(PyExc_ValueError, QObject::tr("Font size out of bounds - must be 1 <= size <= 512.","python error"));
720 subik 314
                return NULL;
647 fschmid 315
        }
900 cbradney 316
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 317
        if (i == NULL)
318
                return NULL;
1217 subik 319
 
3625 avox 320
        if (!i->asTextFrame())
213 Franz 321
        {
1525 cbradney 322
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set font size on a non-text frame.","python error"));
720 subik 323
                return NULL;
213 Franz 324
        }
4026 craig 325
        int Apm = ScMW->doc->appMode;
4847 cbradney 326
        ScMW->doc->m_Selection->clear();
327
        ScMW->doc->m_Selection->addItem(i);
720 subik 328
        if (i->HasSel)
4026 craig 329
                ScMW->doc->appMode = modeEdit;
4584 cbradney 330
        ScMW->doc->chFSize(qRound(size * 10.0));
4026 craig 331
        ScMW->doc->appMode = Apm;
332
        ScMW->view->Deselect();
647 fschmid 333
        Py_INCREF(Py_None);
82 Franz 334
        return Py_None;
335
}
336
 
2790 craig 337
PyObject *scribus_setfont(PyObject* /* self */, PyObject* args)
82 Franz 338
{
934 subik 339
        char *Name = const_cast<char*>("");
340
        char *Font = const_cast<char*>("");
900 cbradney 341
        if (!PyArg_ParseTuple(args, "es|es", "utf-8", &Font, "utf-8", &Name))
82 Franz 342
                return NULL;
649 fschmid 343
        if(!checkHaveDocument())
344
                return NULL;
900 cbradney 345
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 346
        if (i == NULL)
347
                return NULL;
3625 avox 348
        if (!(i->asTextFrame()) && !(i->asPathText()))
213 Franz 349
        {
1525 cbradney 350
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set font on a non-text frame.","python error"));
720 subik 351
                return NULL;
352
        }
2834 cbradney 353
        if (PrefsManager::instance()->appPrefs.AvailFonts.find(QString::fromUtf8(Font)))
720 subik 354
        {
4026 craig 355
                int Apm = ScMW->doc->appMode;
4847 cbradney 356
                ScMW->doc->m_Selection->clear();
357
                ScMW->doc->m_Selection->addItem(i);
332 Franz 358
                if (i->HasSel)
4026 craig 359
                        ScMW->doc->appMode = modeEdit;
360
                ScMW->SetNewFont(QString::fromUtf8(Font));
361
                ScMW->doc->appMode = Apm;
362
                ScMW->view->Deselect();
213 Franz 363
        }
720 subik 364
        else
365
        {
1525 cbradney 366
                PyErr_SetString(PyExc_ValueError, QObject::tr("Font not found.","python error"));
720 subik 367
                return NULL;
368
        }
647 fschmid 369
        Py_INCREF(Py_None);
82 Franz 370
        return Py_None;
371
}
372
 
2790 craig 373
PyObject *scribus_setlinespace(PyObject* /* self */, PyObject* args)
82 Franz 374
{
934 subik 375
        char *Name = const_cast<char*>("");
82 Franz 376
        double w;
900 cbradney 377
        if (!PyArg_ParseTuple(args, "d|es", &w, "utf-8", &Name))
82 Franz 378
                return NULL;
649 fschmid 379
        if(!checkHaveDocument())
380
                return NULL;
647 fschmid 381
        if (w < 0.1)
382
        {
1525 cbradney 383
                PyErr_SetString(PyExc_ValueError, QObject::tr("Line space out of bounds, must be >= 0.1.","python error"));
720 subik 384
                return NULL;
647 fschmid 385
        }
900 cbradney 386
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 387
        if (i == NULL)
388
                return NULL;
3625 avox 389
        if (!i->asTextFrame())
853 subik 390
        {
1525 cbradney 391
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set line spacing on a non-text frame.","python error"));
853 subik 392
                return NULL;
393
        }
5559 avox 394
//      i->setLineSpacing(w);
647 fschmid 395
        Py_INCREF(Py_None);
82 Franz 396
        return Py_None;
397
}
398
 
2790 craig 399
PyObject *scribus_setcolumngap(PyObject* /* self */, PyObject* args)
138 Franz 400
{
934 subik 401
        char *Name = const_cast<char*>("");
138 Franz 402
        double w;
900 cbradney 403
        if (!PyArg_ParseTuple(args, "d|es", &w, "utf-8", &Name))
138 Franz 404
                return NULL;
649 fschmid 405
        if(!checkHaveDocument())
406
                return NULL;
647 fschmid 407
        if (w < 0.0)
408
        {
1525 cbradney 409
                PyErr_SetString(PyExc_ValueError, QObject::tr("Column gap out of bounds, must be positive.","python error"));
720 subik 410
                return NULL;
647 fschmid 411
        }
900 cbradney 412
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 413
        if (i == NULL)
414
                return NULL;
3625 avox 415
        if (!i->asTextFrame())
853 subik 416
        {
1525 cbradney 417
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set column gap on a non-text frame.","python error"));
853 subik 418
                return NULL;
419
        }
1512 craig 420
        i->ColGap = ValueToPoint(w);
647 fschmid 421
        Py_INCREF(Py_None);
138 Franz 422
        return Py_None;
423
}
424
 
2790 craig 425
PyObject *scribus_setcolumns(PyObject* /* self */, PyObject* args)
138 Franz 426
{
934 subik 427
        char *Name = const_cast<char*>("");
138 Franz 428
        int w;
900 cbradney 429
        if (!PyArg_ParseTuple(args, "i|es", &w, "utf-8", &Name))
138 Franz 430
                return NULL;
649 fschmid 431
        if(!checkHaveDocument())
432
                return NULL;
647 fschmid 433
        if (w < 1)
434
        {
1525 cbradney 435
                PyErr_SetString(PyExc_ValueError, QObject::tr("Column count out of bounds, must be > 1.","python error"));
720 subik 436
                return NULL;
647 fschmid 437
        }
900 cbradney 438
        PageItem *i = GetUniqueItem(QString::fromUtf8(Name));
720 subik 439
        if (i == NULL)
440
                return NULL;
3625 avox 441
        if (!i->asTextFrame())
853 subik 442
        {
1525 cbradney 443
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set number of columns on a non-text frame.","python error"));
853 subik 444
                return NULL;
445
        }
720 subik 446
        i->Cols = w;
647 fschmid 447
        Py_INCREF(Py_None);
138 Franz 448
        return Py_None;
449
}
450
 
2790 craig 451
PyObject *scribus_selecttext(PyObject* /* self */, PyObject* args)
82 Franz 452
{
934 subik 453
        char *Name = const_cast<char*>("");
1217 subik 454
        int start, selcount;
455
        if (!PyArg_ParseTuple(args, "ii|es", &start, &selcount, "utf-8", &Name))
82 Franz 456
                return NULL;
649 fschmid 457
        if(!checkHaveDocument())
458
                return NULL;
900 cbradney 459
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 460
        if (it == NULL)
461
                return NULL;
1217 subik 462
        if (selcount == -1)
213 Franz 463
        {
1217 subik 464
                // user wants to select all after the start point -- CR
5721 avox 465
                selcount = it->itemText.length() - start;
1217 subik 466
                if (selcount < 0)
467
                        // user passed start that's > text in the frame
468
                        selcount = 0;
469
        }
470
        // cr 2005-01-18 fixed off-by-one with end bound that made selecting the last char impossible
5721 avox 471
        if ((start < 0) || ((start + selcount) > static_cast<int>(it->itemText.length())))
1217 subik 472
        {
473
                PyErr_SetString(PyExc_IndexError, QObject::tr("Selection index out of bounds", "python error"));
720 subik 474
                return NULL;
213 Franz 475
        }
3625 avox 476
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 477
        {
1525 cbradney 478
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot select text in a non-text frame", "python error"));
853 subik 479
                return NULL;
480
        }
720 subik 481
        /* FIXME: not sure if we should make this check or not
482
        if (start > ende)
483
        {
484
                PyErr_SetString(PyExc_ValueError, QString("Selection start > selection end"));
485
                return NULL;
486
        }
487
        */
5721 avox 488
        it->itemText.deselectAll();
1217 subik 489
        if (selcount == 0)
720 subik 490
        {
491
                it->HasSel = false;
492
                Py_INCREF(Py_None);
493
                return Py_None;
494
        }
5721 avox 495
        it->itemText.select(start, selcount, true);
720 subik 496
        it->HasSel = true;
647 fschmid 497
        Py_INCREF(Py_None);
498
        return Py_None;
82 Franz 499
}
500
 
2790 craig 501
PyObject *scribus_deletetext(PyObject* /* self */, PyObject* args)
82 Franz 502
{
934 subik 503
        char *Name = const_cast<char*>("");
900 cbradney 504
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &Name))
82 Franz 505
                return NULL;
649 fschmid 506
        if(!checkHaveDocument())
507
                return NULL;
900 cbradney 508
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 509
        if (it == NULL)
510
                return NULL;
3625 avox 511
        if (!(it->asTextFrame()) && !(it->asPathText()))
853 subik 512
        {
1525 cbradney 513
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot delete text from a non-text frame.","python error"));
853 subik 514
                return NULL;
515
        }
720 subik 516
        if (it->HasSel)
3829 cbradney 517
                dynamic_cast<PageItem_TextFrame*>(it)->deleteSelectedTextFromFrame();
720 subik 518
        else
213 Franz 519
        {
1065 cbradney 520
                it->itemText.clear();
720 subik 521
                it->CPos = 0;
4026 craig 522
                for (uint a = 0; a < ScMW->doc->FrameItems.count(); ++a)
2447 fschmid 523
                {
4026 craig 524
                        ScMW->doc->FrameItems.at(a)->ItemNr = a;
2447 fschmid 525
                }
213 Franz 526
        }
647 fschmid 527
        Py_INCREF(Py_None);
82 Franz 528
        return Py_None;
529
}
530
 
2790 craig 531
PyObject *scribus_settextfill(PyObject* /* self */, PyObject* args)
82 Franz 532
{
934 subik 533
        char *Name = const_cast<char*>("");
82 Franz 534
        char *Color;
900 cbradney 535
        if (!PyArg_ParseTuple(args, "es|es", "utf-8", &Color, "utf-8", &Name))
82 Franz 536
                return NULL;
649 fschmid 537
        if(!checkHaveDocument())
538
                return NULL;
900 cbradney 539
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 540
        if (it == NULL)
541
                return NULL;
3625 avox 542
        if (!(it->asTextFrame()) && !(it->asPathText()))
213 Franz 543
        {
1525 cbradney 544
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set text fill on a non-text frame.","python error"));
853 subik 545
                return NULL;
546
        }
547
        else
548
        {
5753 jghali 549
                for (int b = 0; b < it->itemText.length(); b++)
213 Franz 550
                {
5721 avox 551
                        //FIXME: doc method
332 Franz 552
                        if (it->HasSel)
82 Franz 553
                        {
5721 avox 554
                                if (it->itemText.selected(b))
555
                                        it->itemText.item(b)->setFillColor(QString::fromUtf8(Color));
213 Franz 556
                        }
332 Franz 557
                        else
5721 avox 558
                                it->itemText.item(b)->setFillColor(QString::fromUtf8(Color));
82 Franz 559
                }
5559 avox 560
//              it->TxtFill = QString::fromUtf8(Color);
720 subik 561
        }
647 fschmid 562
        Py_INCREF(Py_None);
82 Franz 563
        return Py_None;
564
}
565
 
2790 craig 566
PyObject *scribus_settextstroke(PyObject* /* self */, PyObject* args)
82 Franz 567
{
934 subik 568
        char *Name = const_cast<char*>("");
82 Franz 569
        char *Color;
900 cbradney 570
        if (!PyArg_ParseTuple(args, "es|es", "utf-8", &Color, "utf-8", &Name))
82 Franz 571
                return NULL;
649 fschmid 572
        if(!checkHaveDocument())
573
                return NULL;
900 cbradney 574
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 575
        if (it == NULL)
576
                return NULL;
3625 avox 577
        if (!(it->asTextFrame()) && (it->asPathText()))
213 Franz 578
        {
1525 cbradney 579
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set text stroke on a non-text frame.","python error"));
853 subik 580
                return NULL;
581
        }
582
        else
583
        {
5753 jghali 584
                for (int b = 0; b < it->itemText.length(); b++)
213 Franz 585
                {
5721 avox 586
                        //FIXME:NLS use document method for this
332 Franz 587
                        if (it->HasSel)
82 Franz 588
                        {
5721 avox 589
                                if (it->itemText.selected(b))
590
                                        it->itemText.item(b)->setStrokeColor(QString::fromUtf8(Color));
213 Franz 591
                        }
332 Franz 592
                        else
5721 avox 593
                                it->itemText.item(b)->setStrokeColor(QString::fromUtf8(Color));
82 Franz 594
                }
5559 avox 595
//              it->TxtStroke = QString::fromUtf8(Color);
720 subik 596
        }
647 fschmid 597
        Py_INCREF(Py_None);
82 Franz 598
        return Py_None;
599
}
600
 
2790 craig 601
PyObject *scribus_settextshade(PyObject* /* self */, PyObject* args)
82 Franz 602
{
934 subik 603
        char *Name = const_cast<char*>("");
87 Franz 604
        int w;
900 cbradney 605
        if (!PyArg_ParseTuple(args, "i|es", &w, "utf-8", &Name))
82 Franz 606
                return NULL;
649 fschmid 607
        if(!checkHaveDocument())
608
                return NULL;
647 fschmid 609
        if ((w < 0) || (w > 100))
610
        {
611
                Py_INCREF(Py_None);
82 Franz 612
                return Py_None;
647 fschmid 613
        }
900 cbradney 614
        PageItem *it = GetUniqueItem(QString::fromUtf8(Name));
720 subik 615
        if (it == NULL)
616
                return NULL;
3625 avox 617
        if (!(it->asTextFrame()) && !(it->asPathText()))
213 Franz 618
        {
1525 cbradney 619
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot set text shade on a non-text frame.","python error"));
853 subik 620
                return NULL;
621
        }
622
        else
623
        {
5721 avox 624
                //FIXME:NLS use document method for that
5753 jghali 625
                for (int b = 0; b < it->itemText.length(); ++b)
213 Franz 626
                {
332 Franz 627
                        if (it->HasSel)
82 Franz 628
                        {
5721 avox 629
                                if (it->itemText.selected(b))
630
                                        it->itemText.item(b)->setFillShade(w);
82 Franz 631
                        }
332 Franz 632
                        else
5721 avox 633
                                it->itemText.item(b)->setFillShade(w);
213 Franz 634
                }
5559 avox 635
//      it->ShTxtFill = w;
213 Franz 636
        }
647 fschmid 637
        Py_INCREF(Py_None);
82 Franz 638
        return Py_None;
639
}
640
 
2790 craig 641
PyObject *scribus_linktextframes(PyObject* /* self */, PyObject* args)
213 Franz 642
{
643
        char *name1;
644
        char *name2;
645
 
900 cbradney 646
        if (!PyArg_ParseTuple(args, "eses", "utf-8", &name1, "utf-8", &name2))
213 Franz 647
                return NULL;
649 fschmid 648
        if(!checkHaveDocument())
649
                return NULL;
900 cbradney 650
        PageItem *fromitem = GetUniqueItem(QString::fromUtf8(name1));
720 subik 651
        if (fromitem == NULL)
652
                return NULL;
900 cbradney 653
        PageItem *toitem = GetUniqueItem(QString::fromUtf8(name2));
720 subik 654
        if (toitem == NULL)
655
                return NULL;
3625 avox 656
        if (!(fromitem->asTextFrame()) || !(toitem->asTextFrame()))
853 subik 657
        {
1525 cbradney 658
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Can only link text frames.","python error"));
853 subik 659
                return NULL;
660
        }
5721 avox 661
        if (toitem->itemText.length() > 0)
647 fschmid 662
        {
1525 cbradney 663
                PyErr_SetString(ScribusException, QObject::tr("Target frame must be empty.","python error"));
720 subik 664
                return NULL;
647 fschmid 665
        }
720 subik 666
        if (toitem->NextBox != 0)
647 fschmid 667
        {
1525 cbradney 668
                PyErr_SetString(ScribusException, QObject::tr("Target frame links to another frame.","python error"));
720 subik 669
                return NULL;
647 fschmid 670
        }
720 subik 671
        if (toitem->BackBox != 0)
213 Franz 672
        {
1525 cbradney 673
                PyErr_SetString(ScribusException, QObject::tr("Target frame is linked to by another frame.","python error"));
720 subik 674
                return NULL;
675
        }
676
        if (toitem == fromitem)
677
        {
1525 cbradney 678
                PyErr_SetString(ScribusException, QObject::tr("Source and target are the same object.","python error"));
720 subik 679
                return NULL;
680
        }
681
        // references to the others boxes
682
        fromitem->NextBox = toitem;
683
        toitem->BackBox = fromitem;
4026 craig 684
        ScMW->view->DrawNew();
720 subik 685
        // enable 'save icon' stuff
4026 craig 686
        ScMW->slotDocCh();
647 fschmid 687
        Py_INCREF(Py_None);
213 Franz 688
        return Py_None;
689
}
690
 
2790 craig 691
PyObject *scribus_unlinktextframes(PyObject* /* self */, PyObject* args)
213 Franz 692
{
693
        char *name;
900 cbradney 694
        if (!PyArg_ParseTuple(args, "es", "utf-8", &name))
213 Franz 695
                return NULL;
649 fschmid 696
        if(!checkHaveDocument())
697
                return NULL;
900 cbradney 698
        PageItem *item = GetUniqueItem(QString::fromUtf8(name));
720 subik 699
        if (item == NULL)
700
                return NULL;
3625 avox 701
        if (!item->asTextFrame())
853 subik 702
        {
1525 cbradney 703
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot unlink a non-text frame.","python error"));
853 subik 704
                return NULL;
705
        }
720 subik 706
        // only linked
707
        if (item->BackBox == 0)
647 fschmid 708
        {
853 subik 709
                PyErr_SetString(ScribusException, QObject::tr("Object is not a linked text frame, can't unlink.","python error"));
720 subik 710
                return NULL;
647 fschmid 711
        }
720 subik 712
        if (item->NextBox == 0)
213 Franz 713
        {
853 subik 714
                PyErr_SetString(ScribusException, QObject::tr("Object the last frame in a series, can't unlink. Unlink the previous frame instead.","python error"));
720 subik 715
                return NULL;
716
        }
5721 avox 717
/*      PageItem* nextbox = item->NextBox;
718
 
720 subik 719
        while (nextbox != 0)
720
        {
1065 cbradney 721
                uint a = nextbox->itemText.count();
720 subik 722
                for (uint s=0; s<a; ++s)
1065 cbradney 723
                        item->itemText.append(nextbox->itemText.take(0));
720 subik 724
                nextbox = nextbox->NextBox;
725
        } // while
1065 cbradney 726
        uint a2 = item->itemText.count();
720 subik 727
        for (uint s = 0; s < a2; ++s)
1065 cbradney 728
                item->BackBox->itemText.append(item->itemText.take(0));
5721 avox 729
*/
720 subik 730
        item->BackBox->NextBox = 0;
731
        item->BackBox = 0;
5721 avox 732
        item->itemText = StoryText(item->document());
213 Franz 733
        // enable 'save icon' stuff
4026 craig 734
        ScMW->slotDocCh();
735
        ScMW->view->DrawNew();
647 fschmid 736
        Py_INCREF(Py_None);
213 Franz 737
        return Py_None;
738
}
739
 
411 Franz 740
/*
720 subik 741
 * Convert the selected text frame to outlines.
411 Franz 742
 *
743
 * 2004-09-07 (Craig Ringer)
720 subik 744
 * 2004-09-14 pv frame type, optional frame name param
411 Franz 745
 */
2790 craig 746
PyObject *scribus_tracetext(PyObject* /* self */, PyObject* args)
411 Franz 747
{
934 subik 748
        char *name = const_cast<char*>("");
900 cbradney 749
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &name))
411 Franz 750
                return NULL;
649 fschmid 751
        if(!checkHaveDocument())
752
                return NULL;
900 cbradney 753
        PageItem *item = GetUniqueItem(QString::fromUtf8(name));
720 subik 754
        if (item == NULL)
755
                return NULL;
3625 avox 756
        if (!item->asTextFrame())
411 Franz 757
        {
1525 cbradney 758
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Cannot convert a non-text frame to outlines.","python error"));
720 subik 759
                return NULL;
411 Franz 760
        }
4026 craig 761
        ScMW->view->Deselect(true);
762
        ScMW->view->SelectItemNr(item->ItemNr);
763
        ScMW->view->TextToPath();
647 fschmid 764
        Py_INCREF(Py_None);
411 Franz 765
        return Py_None;
766
}
1419 subik 767
 
1607 subik 768
PyObject *scribus_istextoverflowing(PyObject * self, PyObject* args, PyObject* kw)
1419 subik 769
{
770
        char *name = const_cast<char*>("");
1607 subik 771
        bool nolinks = false;
772
        char *kwargs[] = {const_cast<char*>("name"), const_cast<char*>("nolinks"), NULL};
773
        if (!PyArg_ParseTupleAndKeywords(args, kw, "|esi", kwargs, "utf-8", &name, &nolinks))
1419 subik 774
                return NULL;
775
        if(!checkHaveDocument())
776
                return NULL;
777
        PageItem *item = GetUniqueItem(QString::fromUtf8(name));
778
        if (item == NULL)
779
                return NULL;
3625 avox 780
        if (!item->asTextFrame())
1419 subik 781
        {
782
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Only text frames can be checked for overflowing", "python error"));
783
                return NULL;
784
        }
1607 subik 785
        /* original solution
786
        if (item->itemText.count() > item->MaxChars)
787
        return PyBool_FromLong(static_cast<long>(true));
788
        return PyBool_FromLong(static_cast<long>(false)); */
5559 avox 789
        /*
790
         uint firstFrame = 0;
1607 subik 791
        if (nolinks)
792
                firstFrame = item->itemText.count();
793
        uint chars = item->itemText.count();
794
        uint maxchars = item->MaxChars;
795
        while (item->NextBox != 0) {
796
                item = item->NextBox;
797
                chars += item->itemText.count();
798
                maxchars += item->MaxChars;
799
        }
800
        // no overrun
801
        if (nolinks)
802
                return PyInt_FromLong(maxchars - firstFrame);
803
 
804
        if (maxchars > chars)
805
                return PyInt_FromLong(0);
806
        // number of overrunning letters
807
        return PyInt_FromLong(static_cast<long>(chars - maxchars));
5559 avox 808
         */
809
        return PyInt_FromLong(static_cast<long>(item->frameOverflows()));
1419 subik 810
}
1534 subik 811
 
2790 craig 812
PyObject *scribus_setpdfbookmark(PyObject* /* self */, PyObject* args)
1534 subik 813
{
814
        char *name = const_cast<char*>("");
815
        bool toggle;
816
        if (!PyArg_ParseTuple(args, "b|es", &toggle, "utf-8", &name))
817
                return NULL;
818
        if (!checkHaveDocument())
819
                return NULL;
820
        PageItem *i = GetUniqueItem(QString::fromUtf8(name));
821
        if (i == NULL)
822
                return NULL;
3625 avox 823
        if (!i->asTextFrame())
1534 subik 824
        {
825
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Can't set bookmark on a non-text frame", "python error"));
826
                return NULL;
827
        }
828
        if (i->isBookmark == toggle)
829
        {
830
                Py_INCREF(Py_None);
831
                return Py_None;
832
        }
833
        if (toggle)
834
        {
4084 cbradney 835
                i->setIsAnnotation(false);
4026 craig 836
                ScMW->AddBookMark(i);
1534 subik 837
        }
838
        else
4026 craig 839
                ScMW->DelBookMark(i);
1534 subik 840
        i->isBookmark = toggle;
841
        Py_INCREF(Py_None);
842
        return Py_None;
843
}
844
 
2790 craig 845
PyObject *scribus_ispdfbookmark(PyObject* /* self */, PyObject* args)
1534 subik 846
{
847
        char *name = const_cast<char*>("");
848
        if (!PyArg_ParseTuple(args, "|es", "utf-8", &name))
849
                return NULL;
850
        if (!checkHaveDocument())
851
                return NULL;
852
        PageItem *i = GetUniqueItem(QString::fromUtf8(name));
853
        if (i == NULL)
854
                return NULL;
3625 avox 855
        if (i->asTextFrame())
1534 subik 856
        {
857
                PyErr_SetString(WrongFrameTypeError, QObject::tr("Can't get info from a non-text frame", "python error"));
858
                return NULL;
859
        }
860
        if (i->isBookmark)
861
                return PyBool_FromLong(1);
862
        return PyBool_FromLong(0);
863
}