Subversion Repositories Scribus

Rev

Rev 9672 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5850 tsoots 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
*/
4829 tsoots 7
 
8
#include "smlinestyle.h"
8521 cbradney 9
//#include "smlinestyle.moc"
4829 tsoots 10
#include "scribusdoc.h"
11
#include "linecombo.h"
8602 cbradney 12
#include "scrspinbox.h"
7747 jghali 13
#include "colorlistbox.h"
6125 cbradney 14
#include "colorutil.h"
6396 cbradney 15
#include "commonstrings.h"
5859 tsoots 16
#include "selection.h"
6044 tsoots 17
#include "scribusview.h"
6066 tsoots 18
#include "scribus.h"
7478 jghali 19
#include "sccolorengine.h"
6066 tsoots 20
#include "mpalette.h"
8501 cbradney 21
#include <q3header.h>
4829 tsoots 22
#include <qlineedit.h>
8501 cbradney 23
#include <q3listview.h>
4829 tsoots 24
#include <qpushbutton.h>
25
#include <qpixmap.h>
8501 cbradney 26
#include <q3valuelist.h>
4829 tsoots 27
#include <qtabwidget.h>
28
#include <qlayout.h>
8501 cbradney 29
#include <q3listbox.h>
4829 tsoots 30
 
31
extern QPixmap loadIcon(QString nam);
32
 
33
/*** LineStyleWidget *******************************************************/
34
 
8524 subik 35
LineStyleWidget::LineStyleWidget() : QWidget()
4829 tsoots 36
{
8524 subik 37
        setupUi(this);
4829 tsoots 38
        addButton->setPixmap(loadIcon("penciladd.png"));
39
        removeButton->setPixmap(loadIcon("pencilsub.png"));
40
 
41
        dashCombo = new LineCombo(this);
8632 cbradney 42
//qt4   lineLayout->addWidget(dashCombo, 0, 0);
43
        gridLayout->addWidget(dashCombo, 0, 0);
4829 tsoots 44
 
8632 cbradney 45
        lineWidth = new ScrSpinBox( 0, 300, this, 0 );
46
//qt4   widthLayout->addWidget(lineWidth, 0, 1);
47
        gridLayout1->addWidget(lineWidth, 0, 1);
4829 tsoots 48
 
49
        endCombo->insertItem(loadIcon("ButtCap.png"), tr( "Flat Cap" ) );
50
        endCombo->insertItem(loadIcon("SquareCap.png"), tr( "Square Cap" ) );
51
        endCombo->insertItem(loadIcon("RoundCap.png"), tr( "Round Cap" ) );
52
 
53
        joinCombo->insertItem(loadIcon("MiterJoin.png"), tr( "Miter Join" ) );
54
        joinCombo->insertItem(loadIcon("BevelJoin.png"), tr( "Bevel Join" ) );
55
        joinCombo->insertItem(loadIcon("RoundJoin.png"), tr( "Round Join" ) );
7039 tsoots 56
 
57
        languageChange();
4829 tsoots 58
}
59
 
7039 tsoots 60
void LineStyleWidget::languageChange()
61
{
62
/***********************************/
63
/*      Begin Tooltips             */
64
/***********************************/
65
// These are for the line style page
66
 
67
        QToolTip::add(addButton,    tr("Add a new line"));
68
        QToolTip::add(removeButton, tr("Remove a line"));
69
        QToolTip::add(dashCombo,    tr("Line style"));
70
        QToolTip::add(lineWidth,    tr("Line width"));
71
        QToolTip::add(endCombo,     tr("End style"));
72
        QToolTip::add(joinCombo,    tr("Join style"));
73
        QToolTip::add(colorCombo,   tr("Line color"));
74
        QToolTip::add(shadeBox,     tr("Line shade"));
75
 
76
/***********************************/
77
/*      End Tooltips               */
78
/***********************************/
79
 
80
 
81
}
82
 
6066 tsoots 83
void LineStyleWidget::showStyle(const multiLine &lineStyle, ColorList &colorList, int subLine)
4829 tsoots 84
{
6066 tsoots 85
        disconnect(lineStyles, SIGNAL(highlighted(int)), this, SLOT(slotEditNewLine(int)));
4829 tsoots 86
        currentStyle = lineStyle;
87
        colorCombo->clear();
88
        ColorList::Iterator it;
7478 jghali 89
        ScribusDoc* doc = colorList.document();
4829 tsoots 90
        for (it = colorList.begin(); it != colorList.end(); ++it)
8632 cbradney 91
        {
8658 subik 92
//Qt4           colorCombo->listBox()->insertItem(new ColorWidePixmapItem(colorList[it.key()], doc, it.key()));
8632 cbradney 93
        }
4829 tsoots 94
        colors = colorList;
95
        updateLineList();
6066 tsoots 96
        slotEditNewLine(subLine);
97
        connect(lineStyles, SIGNAL(highlighted(int)), this, SLOT(slotEditNewLine(int)));
4829 tsoots 98
}
99
 
100
void LineStyleWidget::slotEditNewLine(int i)
101
{
102
        lineStyles->setSelected(i, true);
6066 tsoots 103
        //currentLine_ = i;
4829 tsoots 104
        lineWidth->setValue(currentStyle[i].Width);
105
        colorCombo->setCurrentText(currentStyle[i].Color);
106
        shadeBox->setValue(currentStyle[i].Shade);
5153 tsoots 107
 
8501 cbradney 108
        switch (static_cast<Qt::PenStyle>(currentStyle[i].Dash))
4829 tsoots 109
        {
8522 cbradney 110
        case Qt::SolidLine:
4829 tsoots 111
                dashCombo->setCurrentItem(0);
112
                break;
8522 cbradney 113
        case Qt::DashLine:
4829 tsoots 114
                dashCombo->setCurrentItem(1);
115
                break;
8522 cbradney 116
        case Qt::DotLine:
4829 tsoots 117
                dashCombo->setCurrentItem(2);
118
                break;
8522 cbradney 119
        case Qt::DashDotLine:
4829 tsoots 120
                dashCombo->setCurrentItem(3);
121
                break;
8522 cbradney 122
        case Qt::DashDotDotLine:
4829 tsoots 123
                dashCombo->setCurrentItem(4);
124
                break;
125
        default:
126
                dashCombo->setCurrentItem(0);
127
                break;
128
        }
5153 tsoots 129
 
8501 cbradney 130
        switch (static_cast<Qt::PenCapStyle>(currentStyle[i].LineEnd))
4829 tsoots 131
        {
8522 cbradney 132
        case Qt::FlatCap:
4829 tsoots 133
                endCombo->setCurrentItem(0);
134
                break;
8583 cbradney 135
        case Qt::SquareCap:
4829 tsoots 136
                endCombo->setCurrentItem(1);
137
                break;
8522 cbradney 138
        case Qt::RoundCap:
4829 tsoots 139
                endCombo->setCurrentItem(2);
140
                break;
141
        default:
142
                endCombo->setCurrentItem(0);
143
                break;
144
        }
6066 tsoots 145
 
8501 cbradney 146
        switch (static_cast<Qt::PenJoinStyle>(currentStyle[i].LineJoin))
4829 tsoots 147
        {
8522 cbradney 148
        case Qt::MiterJoin:
4829 tsoots 149
                joinCombo->setCurrentItem(0);
150
                break;
8522 cbradney 151
        case Qt::BevelJoin:
4829 tsoots 152
                joinCombo->setCurrentItem(1);
153
                break;
8522 cbradney 154
        case Qt::RoundJoin:
4829 tsoots 155
                joinCombo->setCurrentItem(2);
156
                break;
157
        default:
158
                joinCombo->setCurrentItem(0);
159
                break;
160
        }
161
}
162
 
163
void LineStyleWidget::updateLineList()
164
{
165
        QString tmp, tmp2;
166
        lineStyles->clear();
167
        QPixmap * pm2;
168
        for (multiLine::iterator it = currentStyle.begin(); it != currentStyle.end(); ++it)
169
        {
170
                pm2 = getWidePixmap(getColor((*it).Color, (*it).Shade));
171
                tmp2 = " "+tmp.setNum((*it).Width)+ tr(" pt")+" ";
8501 cbradney 172
                tmp2 += CommonStrings::translatePenStyleName(static_cast<Qt::PenStyle>((*it).Dash));
4829 tsoots 173
                tmp2 += " ";
174
                lineStyles->insertItem(*pm2, tmp2);
175
        }
176
}
177
 
178
QColor LineStyleWidget::getColor(const QString &name, int shade)
179
{
7478 jghali 180
        const ScColor& color = colors[name];
181
        QColor tmpf = ScColorEngine::getDisplayColor(color, colors.document(), shade);
4829 tsoots 182
        return tmpf;
183
}
184
 
185
LineStyleWidget::~LineStyleWidget()
186
{
187
 
188
}
189
 
6066 tsoots 190
/*************************************************************************/
191
/*************************************************************************/
4829 tsoots 192
 
8478 jghali 193
SMLineStyle::SMLineStyle() : StyleItem(), doc_(0), widget_(0), twidget_(0), selectionIsDirty_(false)
4829 tsoots 194
{
195
 
196
}
197
 
198
QTabWidget* SMLineStyle::widget()
199
{
200
        if (!twidget_)
201
        {
202
                twidget_ = new QTabWidget();
203
                widget_ = new LineStyleWidget();
204
                twidget_->addTab(widget_, tr("Properties"));
6066 tsoots 205
                connect(widget_->lineStyles, SIGNAL(highlighted(int)), this, SLOT(slotCurrentLineChanged(int)));
4829 tsoots 206
        }
207
        return twidget_;
208
}
209
 
6029 tsoots 210
QString SMLineStyle::typeNamePlural()
4829 tsoots 211
{
5850 tsoots 212
        return tr("Line Styles");
4829 tsoots 213
}
214
 
6029 tsoots 215
QString SMLineStyle::typeNameSingular()
216
{
217
        return tr("Line Style");
218
}
219
 
4829 tsoots 220
void SMLineStyle::currentDoc(ScribusDoc *doc)
221
{
222
        doc_ = doc;
223
        if (doc_)
6072 tsoots 224
        {
4829 tsoots 225
                tmpLines = doc_->MLineStyles;
6072 tsoots 226
                selection_.clear();
7622 jghali 227
        }
6072 tsoots 228
        else
229
        {
230
                tmpLines.clear();
231
                selection_.clear();
232
        }
233
}
4829 tsoots 234
 
8501 cbradney 235
Q3ValueList<StyleName> SMLineStyle::styles(bool reloadFromDoc)
4829 tsoots 236
{
6066 tsoots 237
        if (doc_ && reloadFromDoc) {
238
                tmpLines = doc_->MLineStyles;
239
        }
240
 
8501 cbradney 241
        Q3ValueList<StyleName> tmp;
6066 tsoots 242
        QMap<QString,multiLine>::Iterator it;
243
 
244
        for (it = tmpLines.begin(); it != tmpLines.end(); ++it)
245
                tmp << StyleName(it.key(), QString::null);
246
 
4829 tsoots 247
        return tmp;
248
}
249
 
6029 tsoots 250
void SMLineStyle::reload()
251
{
6072 tsoots 252
        if (!doc_)
253
                return;
254
 
6066 tsoots 255
        selection_.clear();
256
        tmpLines = doc_->MLineStyles;
6029 tsoots 257
}
258
 
4829 tsoots 259
void SMLineStyle::selected(const QStringList &styleNames)
260
{
6066 tsoots 261
        selection_.clear();
262
        selectionIsDirty_ = false;
4829 tsoots 263
 
6066 tsoots 264
        removeConnections();
265
 
266
        if (styleNames.count() > 1)
4829 tsoots 267
                setMultiSelection(styleNames);
268
        else if (styleNames.count() == 1)
269
                setSelection(styleNames[0]);
270
 
6066 tsoots 271
        updatePreview();
272
        setupConnections();
4829 tsoots 273
}
274
 
275
void SMLineStyle::setSelection(const QString& styleName)
276
{
6072 tsoots 277
        if (!doc_)
278
                return;
279
 
4829 tsoots 280
        if (!tmpLines.contains(styleName))
281
                return; // something's wrong here
282
 
6066 tsoots 283
        selection_.clear();
284
        selection_[styleName] = &tmpLines[styleName];
4829 tsoots 285
        widget_->showStyle(tmpLines[styleName], doc_->PageColors);
6066 tsoots 286
        currentLine_ = 0;
4829 tsoots 287
}
288
 
289
void SMLineStyle::setMultiSelection(const QStringList& styles)
290
{
6066 tsoots 291
        selection_.clear();
8583 cbradney 292
        for (int i = 0; i < styles.count(); ++i)
6066 tsoots 293
        {
294
                if (!tmpLines.contains(styles[i]))
295
                        continue;
296
                selection_[styles[i]] = &tmpLines[styles[i]];
297
        }
298
        currentLine_ = 0;
299
        // todo do the tricks for clever showing of multiple styles
4829 tsoots 300
}
301
 
5859 tsoots 302
QString SMLineStyle::fromSelection() const
303
{
8461 cbradney 304
        QString lsName(QString::null);
6072 tsoots 305
        if (!doc_)
306
                return lsName;
5859 tsoots 307
 
8632 cbradney 308
        for (uint i = 0; i < doc_->m_Selection->count(); ++i)
5859 tsoots 309
        {
310
                PageItem *item = doc_->m_Selection->itemAt(i);
311
                QString tmpName = item->customLineStyle();
8461 cbradney 312
                if (lsName.isNull() && !tmpName.isEmpty() && tmpName != "")
5859 tsoots 313
                {
314
                        lsName = item->customLineStyle();
315
                }
8461 cbradney 316
                else if (!lsName.isNull() && !tmpName.isEmpty() && tmpName != "" && lsName != tmpName)
5859 tsoots 317
                {
318
                        lsName = QString::null;
319
                        break;
320
                }
321
        }
322
        return lsName;
323
}
324
 
6044 tsoots 325
void SMLineStyle::toSelection(const QString &styleName) const
326
{
6072 tsoots 327
        if (!doc_)
328
                return;
6044 tsoots 329
 
8632 cbradney 330
        for (uint i = 0; i < doc_->m_Selection->count(); ++i)
6044 tsoots 331
        {
8461 cbradney 332
                if (styleName.isNull())
6044 tsoots 333
                        doc_->m_Selection->itemAt(i)->setCustomLineStyle("");
334
                else
335
                        doc_->m_Selection->itemAt(i)->setCustomLineStyle(styleName);
336
 
337
                doc_->view()->RefreshItem(doc_->m_Selection->itemAt(i));
338
        }
339
}
340
 
341
QString SMLineStyle::newStyle()
342
{
9521 jghali 343
        if (!doc_)
344
                return QString::null;
8548 cbradney 345
        struct SingleLine sl;
9035 subik 346
//      sl.Color = "Black";
347
//      sl.Shade = 100;
348
//      sl.Dash = SolidLine;
349
//      sl.LineEnd = FlatCap;
350
//      sl.LineJoin = MiterJoin;
351
//      sl.Width = 1.0;
352
        sl.Color = doc_->toolSettings.dPenLine;
353
        sl.Shade = doc_->toolSettings.dShadeLine;
354
        sl.Dash = Qt::SolidLine;//Docu->toolSettings.;
355
        sl.LineEnd = Qt::FlatCap;//Docu->toolSettings.;
356
        sl.LineJoin = doc_->toolSettings.dLstyleLine;
357
        sl.Width = doc_->toolSettings.dWidthLine;
6066 tsoots 358
        multiLine ml;
359
        ml.push_back(sl);
6260 fschmid 360
        QString name = getUniqueName( tr("New Style"));
6066 tsoots 361
        tmpLines[name] = ml;
362
        return name;
6044 tsoots 363
}
364
 
6047 tsoots 365
QString SMLineStyle::newStyle(const QString &fromStyle)
366
{
6066 tsoots 367
        Q_ASSERT(tmpLines.contains(fromStyle));
368
 
369
        multiLine ml(tmpLines[fromStyle]);
6260 fschmid 370
        QString name = getUniqueName( tr("Clone of %1").arg(fromStyle));
6066 tsoots 371
        tmpLines[name] = ml;
372
        return name;
6047 tsoots 373
}
374
 
6066 tsoots 375
QString SMLineStyle::getUniqueName(const QString &name)
376
{
377
        int id = 0;
378
        QString s = name;
379
 
8788 cbradney 380
        while (tmpLines.contains(s))
6066 tsoots 381
        {
382
                ++id;
8788 cbradney 383
                s = tr("%1 (%2)", "This for unique name when creating "
384
                        "a new character style. %1 will be the name "
385
                        "of the style and %2 will be a number forming "
386
                        "a style name like: New Style (2)").arg(name).arg(id);
6066 tsoots 387
        }
388
 
389
        return s;
390
}
391
 
4829 tsoots 392
void SMLineStyle::apply()
393
{
6072 tsoots 394
        if (!doc_)
395
                return;
396
 
6066 tsoots 397
        PageItem* ite;
398
        doc_->MLineStyles = tmpLines;
399
        QMap<QString, QString> replacement;
8583 cbradney 400
        for (int i = 0; i < deleted_.count(); ++i)
6066 tsoots 401
                replacement[deleted_[i].first] = deleted_[i].second;
402
 
403
        deleted_.clear();
404
 
8632 cbradney 405
        for (uint d = 0; d < doc_->DocItems.count(); ++d)
6066 tsoots 406
        {
407
                ite = doc_->DocItems.at(d);
408
                if (!ite->NamedLStyle.isEmpty())
409
                {
410
                        if (!doc_->MLineStyles.contains(ite->NamedLStyle))
411
                                ite->NamedLStyle = replacement[ite->NamedLStyle];
412
                }
413
        }
8632 cbradney 414
        for (uint d1 = 0; d1 < doc_->MasterItems.count(); ++d1)
6066 tsoots 415
        {
416
                ite = doc_->MasterItems.at(d1);
417
                if (!ite->NamedLStyle.isEmpty())
418
                {
419
                        if (!doc_->MLineStyles.contains(ite->NamedLStyle))
420
                                ite->NamedLStyle = replacement[ite->NamedLStyle];
421
                }
422
        }
8632 cbradney 423
        for (uint d1 = 0; d1 < doc_->FrameItems.count(); ++d1)
6066 tsoots 424
        {
425
                ite = doc_->FrameItems.at(d1);
426
                if (!ite->NamedLStyle.isEmpty())
427
                {
428
                        if (!doc_->MLineStyles.contains(ite->NamedLStyle))
429
                                ite->NamedLStyle = replacement[ite->NamedLStyle];
430
                }
431
        }
8916 avox 432
        doc_->changed();
6066 tsoots 433
        doc_->scMW()->propertiesPalette->SetLineFormats(doc_);
434
        doc_->view()->DrawNew();
435
        selectionIsDirty_ = false;
4829 tsoots 436
}
437
 
6949 tsoots 438
QString SMLineStyle::shortcut(const QString &stylename) const
439
{
6951 tsoots 440
        Q_ASSERT(tmpLines.contains(stylename));
441
        return tmpLines[stylename].shortcut;
6949 tsoots 442
}
443
 
444
void SMLineStyle::setShortcut(const QString &shortcut)
445
{
6951 tsoots 446
        Q_ASSERT(selection_.count() == 1);
447
        if (selection_.count() != 1)
448
                return;
449
 
450
        QMap<QString, multiLine*>::iterator it;
451
        for (it = selection_.begin(); it != selection_.end(); ++it)
452
                (*it)->shortcut = shortcut;
453
 
454
        if (!selectionIsDirty_)
455
        {
456
                selectionIsDirty_ = true;
457
                emit selectionDirty();
458
        }
6949 tsoots 459
}
460
 
8501 cbradney 461
void SMLineStyle::deleteStyles(const Q3ValueList<RemoveItem> &removeList)
4829 tsoots 462
{
8632 cbradney 463
        for (int i = 0; i < removeList.count(); ++i)
6066 tsoots 464
        {
465
                selection_.remove(selection_.find(removeList[i].first));
466
                tmpLines.remove(tmpLines.find(removeList[i].first));
467
                deleted_.append(removeList[i]);
468
        }
4829 tsoots 469
}
470
 
471
void SMLineStyle::nameChanged(const QString &newName)
472
{
8965 avox 473
        if (selection_.count() != 1)
474
        {
475
                qDebug(QString("SMLineStyle::nameChanged #selection=%1").arg(selection_.count()));
476
                return;
477
        }
6072 tsoots 478
        QString oldName = selection_.begin().key();
479
        multiLine *tmpLine = selection_.begin().data();
480
        multiLine newLine(*tmpLine);
481
 
482
        selection_.clear();
483
        tmpLines.erase(oldName);
4829 tsoots 484
 
6072 tsoots 485
        tmpLines.insert(newName, newLine);
486
        selection_[newName] = &tmpLines[newName];
487
 
8501 cbradney 488
        Q3ValueList<RemoveItem>::iterator it;
6072 tsoots 489
        for (it = deleted_.begin(); it != deleted_.end(); ++it)
490
        {
491
                if ((*it).second == oldName)
492
                {
493
                        oldName = (*it).first;
494
                        deleted_.remove(it);
495
                        break;
496
                }
497
        }
498
 
499
        deleted_.append(RemoveItem(oldName, newName));
4829 tsoots 500
}
501
 
6025 tsoots 502
void SMLineStyle::languageChange()
503
{
504
 
505
}
506
 
8453 tsoots 507
void SMLineStyle::unitChange()
508
{
509
 
510
}
511
 
6066 tsoots 512
void SMLineStyle::setupConnections()
513
{
514
        connect(widget_->addButton, SIGNAL(clicked()), this, SLOT(slotAddLine()));
515
        connect(widget_->removeButton, SIGNAL(clicked()), this, SLOT(slotDeleteLine()));
516
        connect(widget_->endCombo, SIGNAL(activated(int)), this, SLOT(slotSetEnd(int)));
517
        connect(widget_->joinCombo, SIGNAL(activated(int)), this, SLOT(slotSetJoin(int)));
518
        connect(widget_->colorCombo, SIGNAL(activated(const QString&)), this, SLOT(slotColor(const QString&)));
519
        connect(widget_->dashCombo, SIGNAL(activated(int)), this, SLOT(slotLineStyle(int)));
520
        connect(widget_->shadeBox, SIGNAL(valueChanged(int)), this, SLOT(slotShade(int)));
9673 fschmid 521
        connect(widget_->lineWidth, SIGNAL(valueChanged(double)), this, SLOT(slotLineWidth()));
6066 tsoots 522
}
523
 
524
void SMLineStyle::removeConnections()
525
{
526
        disconnect(widget_->addButton, SIGNAL(clicked()), this, SLOT(slotAddLine()));
527
        disconnect(widget_->removeButton, SIGNAL(clicked()), this, SLOT(slotDeleteLine()));
528
        disconnect(widget_->endCombo, SIGNAL(activated(int)), this, SLOT(slotSetEnd(int)));
529
        disconnect(widget_->joinCombo, SIGNAL(activated(int)), this, SLOT(slotSetJoin(int)));
530
        disconnect(widget_->colorCombo, SIGNAL(activated(const QString&)), this, SLOT(slotColor(const QString&)));
531
        disconnect(widget_->dashCombo, SIGNAL(activated(int)), this, SLOT(slotLineStyle(int)));
532
        disconnect(widget_->shadeBox, SIGNAL(valueChanged(int)), this, SLOT(slotShade(int)));
9673 fschmid 533
        disconnect(widget_->lineWidth, SIGNAL(valueChanged(double)), this, SLOT(slotLineWidth()));
6066 tsoots 534
}
535
 
536
void SMLineStyle::slotLineStyle(int i)
537
{
8583 cbradney 538
        Qt::PenStyle c = Qt::SolidLine;
6066 tsoots 539
        switch (i)
540
        {
541
                case 0:
8522 cbradney 542
                        c = Qt::SolidLine;
6066 tsoots 543
                        break;
544
                case 1:
8522 cbradney 545
                        c = Qt::DashLine;
6066 tsoots 546
                        break;
547
                case 2:
8522 cbradney 548
                        c = Qt::DotLine;
6066 tsoots 549
                        break;
550
                case 3:
8522 cbradney 551
                        c = Qt::DashDotLine;
6066 tsoots 552
                        break;
553
                case 4:
8522 cbradney 554
                        c = Qt::DashDotDotLine;
6066 tsoots 555
                        break;
556
        }
557
 
558
        Q_ASSERT(currentLine_ >= 0);
559
        if (currentLine_ < 0)
560
                return;
561
 
562
        QMap<QString, multiLine*>::iterator it;
563
        for (it = selection_.begin(); it != selection_.end(); ++it)
564
        {
565
                multiLine *tmp = it.data();
566
                (*tmp)[currentLine_].Dash = static_cast<int>(c);
567
        }
568
 
569
        updateSList();
570
        updatePreview();
571
 
572
        if (!selectionIsDirty_)
573
        {
574
                selectionIsDirty_ = true;
575
                emit selectionDirty();
576
        }
577
}
578
 
579
void SMLineStyle::slotSetEnd(int i)
580
{
8583 cbradney 581
        Qt::PenCapStyle c = Qt::FlatCap;
6066 tsoots 582
        switch (i)
583
        {
584
                case 0:
8522 cbradney 585
                        c = Qt::FlatCap;
6066 tsoots 586
                        break;
587
                case 1:
8583 cbradney 588
                        c = Qt::SquareCap;
6066 tsoots 589
                        break;
590
                case 2:
8522 cbradney 591
                        c = Qt::RoundCap;
6066 tsoots 592
                        break;
593
        }
594
 
595
        QMap<QString, multiLine*>::iterator it;
596
        for (it = selection_.begin(); it != selection_.end(); ++it)
597
        {
598
                multiLine *tmp = it.data();
599
                (*tmp)[currentLine_].LineEnd = static_cast<int>(c);
600
        }
601
 
602
        updateSList();
603
        updatePreview();
604
 
605
        if (!selectionIsDirty_)
606
        {
607
                selectionIsDirty_ = true;
608
                emit selectionDirty();
609
        }
610
}
611
 
612
void SMLineStyle::slotSetJoin(int i)
613
{
7019 tsoots 614
        Q_ASSERT(currentLine_ >= 0);
615
        if (currentLine_ < 0)
616
                return;
617
 
8583 cbradney 618
        Qt::PenJoinStyle c = Qt::MiterJoin;
6066 tsoots 619
        switch (i)
620
        {
621
                case 0:
8522 cbradney 622
                        c = Qt::MiterJoin;
6066 tsoots 623
                        break;
624
                case 1:
8522 cbradney 625
                        c = Qt::BevelJoin;
6066 tsoots 626
                        break;
627
                case 2:
8522 cbradney 628
                        c = Qt::RoundJoin;
6066 tsoots 629
                        break;
630
        }
631
 
632
        QMap<QString, multiLine*>::iterator it;
633
        for (it = selection_.begin(); it != selection_.end(); ++it)
634
        {
635
                multiLine *tmp = it.data();
7019 tsoots 636
                (*tmp)[currentLine_].LineJoin = static_cast<int>(c);
6066 tsoots 637
        }
638
 
639
        updateSList();
640
        updatePreview();
641
 
642
        if (!selectionIsDirty_)
643
        {
644
                selectionIsDirty_ = true;
645
                emit selectionDirty();
646
        }
647
}
648
 
649
void SMLineStyle::slotColor(const QString &s)
650
{
651
        QMap<QString, multiLine*>::iterator it;
652
        for (it = selection_.begin(); it != selection_.end(); ++it)
653
        {
654
                multiLine *tmp = it.data();
655
                (*tmp)[currentLine_].Color = s;
656
        }
657
 
658
        updateSList();
659
        updatePreview();
660
 
661
        if (!selectionIsDirty_)
662
        {
663
                selectionIsDirty_ = true;
664
                emit selectionDirty();
665
        }
666
}
667
 
668
void SMLineStyle::slotShade(int i)
669
{
670
        QMap<QString, multiLine*>::iterator it;
671
        for (it = selection_.begin(); it != selection_.end(); ++it)
672
        {
673
                multiLine *tmp = it.data();
674
                (*tmp)[currentLine_].Shade = i;
675
        }
676
 
677
        updateSList();
678
        updatePreview();
679
 
680
        if (!selectionIsDirty_)
681
        {
682
                selectionIsDirty_ = true;
683
                emit selectionDirty();
684
        }
685
}
686
 
687
void SMLineStyle::slotLineWidth()
688
{
689
        QMap<QString, multiLine*>::iterator it;
690
        for (it = selection_.begin(); it != selection_.end(); ++it)
691
        {
692
                multiLine *tmp = it.data();
693
                (*tmp)[currentLine_].Width = widget_->lineWidth->value();
694
        }
695
 
696
        updatePreview();
697
        resort();
698
 
699
        if (!selectionIsDirty_)
700
        {
701
                selectionIsDirty_ = true;
702
                emit selectionDirty();
703
        }
704
}
705
 
706
void SMLineStyle::slotAddLine()
707
{
8965 avox 708
        if (!doc_ || selection_.count() != 1)
6072 tsoots 709
                return;
710
 
6066 tsoots 711
        multiLine *tmpLine = selection_.begin().data();
712
        struct SingleLine sl;
713
        sl.Color = (*tmpLine)[currentLine_].Color;
714
        sl.Shade = (*tmpLine)[currentLine_].Shade;
715
        sl.Dash = (*tmpLine)[currentLine_].Dash;
716
        sl.LineEnd = (*tmpLine)[currentLine_].LineEnd;
717
        sl.LineJoin = (*tmpLine)[currentLine_].LineJoin;
718
        sl.Width = (*tmpLine)[currentLine_].Width;
719
        int cc = 0;
720
        bool fo = false;
721
        for (multiLine::iterator it2 = (*tmpLine).begin(); it2 != (*tmpLine).end(); ++it2)
722
        {
723
                if (sl.Width < (*it2).Width)
724
                {
725
                        (*tmpLine).insert(it2, sl);
726
                        fo = true;
727
                        break;
728
                }
729
                cc++;
730
        }
731
        if (!fo)
732
                (*tmpLine).push_back(sl);
733
        currentLine_ = cc;
734
        rebuildList();
735
        widget_->showStyle(*tmpLine, doc_->PageColors, cc);
736
        updatePreview();
737
 
738
        if (!selectionIsDirty_)
739
        {
740
                selectionIsDirty_ = true;
741
                emit selectionDirty();
742
        }
743
}
744
 
745
void SMLineStyle::rebuildList()
746
{
747
        QString tmp, tmp2;
748
        widget_->lineStyles->clear();
749
        QPixmap * pm2;
750
        multiLine *tmpLine = selection_.begin().data();
751
        for (multiLine::iterator it = (*tmpLine).begin(); it != (*tmpLine).end(); ++it)
752
        {
753
                pm2 = getWidePixmap(calcFarbe((*it).Color, (*it).Shade));
754
                tmp2 = " "+tmp.setNum((*it).Width)+ tr(" pt")+" ";
8501 cbradney 755
                switch (static_cast<Qt::PenStyle>((*it).Dash))
6066 tsoots 756
                {
8522 cbradney 757
                        case Qt::SolidLine:
6066 tsoots 758
                                tmp2 += tr("Solid Line");
759
                                break;
8522 cbradney 760
                        case Qt::DashLine:
6066 tsoots 761
                                tmp2 += tr("Dashed Line");
762
                                break;
8522 cbradney 763
                        case Qt::DotLine:
6066 tsoots 764
                                tmp2 += tr("Dotted Line");
765
                                break;
8522 cbradney 766
                        case Qt::DashDotLine:
6066 tsoots 767
                                tmp2 += tr("Dash Dot Line");
768
                                break;
8522 cbradney 769
                        case Qt::DashDotDotLine:
6066 tsoots 770
                                tmp2 += tr("Dash Dot Dot Line");
771
                                break;
772
                        default:
773
                                tmp2 += tr("Solid Line");
774
                                break;
775
                }
776
                tmp2 += " ";
777
                widget_->lineStyles->insertItem(*pm2, tmp2);
778
        }
779
}
780
 
781
void SMLineStyle::slotDeleteLine()
782
{
8965 avox 783
        if (!doc_ || selection_.count() != 1)
6072 tsoots 784
                return;
785
 
6066 tsoots 786
        multiLine *tmpLine = selection_.begin().data();
787
 
788
        if ((*tmpLine).size() == 1)
789
                return;
790
 
791
        int cc = 0;
792
        for (multiLine::iterator it3 = (*tmpLine).begin(); it3 != (*tmpLine).end(); ++it3)
793
        {
794
                if (cc == currentLine_)
795
                {
796
                        (*tmpLine).erase(it3);
797
                        break;
798
                }
799
                cc++;
800
        }
801
 
802
        currentLine_ = 0;
803
        rebuildList();
804
        widget_->showStyle(*tmpLine, doc_->PageColors);
805
        updatePreview();
806
 
807
        if (!selectionIsDirty_)
808
        {
809
                selectionIsDirty_ = true;
810
                emit selectionDirty();
811
        }
812
}
813
 
814
void SMLineStyle::updateSList()
815
{
816
        if (selection_.count() < 1)
817
                return;
818
 
819
        Q_ASSERT(currentLine_ >= 0);
820
        if  (currentLine_ < 0)
821
                return;
822
 
823
 
824
        QString tmp, tmp2;
825
        QPixmap * pm;
826
        multiLine *tmpLine = selection_.begin().data();
827
 
828
        pm = getWidePixmap(calcFarbe((*tmpLine)[currentLine_].Color, (*tmpLine)[currentLine_].Shade));
829
        tmp2 = " "+tmp.setNum((*tmpLine)[currentLine_].Width)+ tr(" pt ");
8501 cbradney 830
        switch (static_cast<Qt::PenStyle>((*tmpLine)[currentLine_].Dash))
6066 tsoots 831
        {
8522 cbradney 832
                case Qt::SolidLine:
6066 tsoots 833
                        tmp2 += tr("Solid Line");
834
                        break;
8522 cbradney 835
                case Qt::DashLine:
6066 tsoots 836
                        tmp2 += tr("Dashed Line");
837
                        break;
8522 cbradney 838
                case Qt::DotLine:
6066 tsoots 839
                        tmp2 += tr("Dotted Line");
840
                        break;
8522 cbradney 841
                case Qt::DashDotLine:
6066 tsoots 842
                        tmp2 += tr("Dash Dot Line");
843
                        break;
8522 cbradney 844
                case Qt::DashDotDotLine:
6066 tsoots 845
                        tmp2 += tr("Dash Dot Dot Line");
846
                        break;
847
                default:
848
                        tmp2 += tr("Solid Line");
849
                        break;
850
        }
851
        tmp2 += " ";
852
        if (widget_->lineStyles->count() == 1)  // to avoid Bug in Qt-3.1.2
853
        {
854
                widget_->lineStyles->clear();
855
                widget_->lineStyles->insertItem(*pm, tmp2);
856
        }
857
        else
858
                widget_->lineStyles->changeItem(*pm, tmp2, currentLine_);
859
}
860
 
861
void SMLineStyle::updatePreview()
862
{
8965 avox 863
    if (selection_.count() < 1)
864
                return;
865
 
6066 tsoots 866
        QPixmap pm = QPixmap(200, 37);
8583 cbradney 867
        pm.fill(Qt::white);
6066 tsoots 868
        QPainter p;
869
        p.begin(&pm);
870
        multiLine *tmpLine = selection_.begin().data();
871
 
872
        for (int it = (*tmpLine).size()-1; it > -1; it--)
873
        {
874
                p.setPen(QPen(calcFarbe((*tmpLine)[it].Color, (*tmpLine)[it].Shade),
8562 jghali 875
                                 qMax(static_cast<int>((*tmpLine)[it].Width), 1),
8501 cbradney 876
                                 static_cast<Qt::PenStyle>((*tmpLine)[it].Dash),
877
                                 static_cast<Qt::PenCapStyle>((*tmpLine)[it].LineEnd),
878
                                 static_cast<Qt::PenJoinStyle>((*tmpLine)[it].LineJoin)));
6066 tsoots 879
                p.drawLine(17, 18, 183, 18);
880
        }
881
        p.end();
882
        widget_->previewLabel->setPixmap(pm);
883
}
884
 
885
QColor SMLineStyle::calcFarbe(const QString &name, int shade)
886
{
887
        QColor tmpf;
6072 tsoots 888
        if (!doc_)
889
                return tmpf;
7478 jghali 890
        const ScColor& color = doc_->PageColors[name];
891
        tmpf = ScColorEngine::getDisplayColor(color, doc_, shade);
6066 tsoots 892
        return tmpf;
893
}
894
 
895
void SMLineStyle::slotCurrentLineChanged(int i)
896
{
897
        currentLine_ = i;
898
}
899
 
900
void SMLineStyle::resort()
901
{
8965 avox 902
        if (!doc_ || selection_.count() != 1)
6072 tsoots 903
                return;
904
 
6066 tsoots 905
        int cc = 0;
906
        struct SingleLine sl;
907
        multiLine *tmpLine = selection_.begin().data();
908
 
909
        sl.Color = (*tmpLine)[currentLine_].Color;
910
        sl.Shade = (*tmpLine)[currentLine_].Shade;
911
        sl.Dash = (*tmpLine)[currentLine_].Dash;
912
        sl.LineEnd = (*tmpLine)[currentLine_].LineEnd;
913
        sl.LineJoin = (*tmpLine)[currentLine_].LineJoin;
914
        sl.Width = (*tmpLine)[currentLine_].Width;
915
        multiLine::iterator it3;
916
        for (it3 = (*tmpLine).begin(); it3 != (*tmpLine).end(); ++it3)
917
        {
918
                if (cc == currentLine_)
919
                {
920
                        (*tmpLine).erase(it3);
921
                        break;
922
                }
923
                cc++;
924
        }
925
        cc = 0;
926
        bool fo = false;
927
        for (multiLine::iterator it2 = (*tmpLine).begin(); it2 != (*tmpLine).end(); ++it2)
928
        {
929
                if (sl.Width < (*it2).Width)
930
                {
931
                        (*tmpLine).insert(it2, sl);
932
                        fo = true;
933
                        break;
934
                }
935
                cc++;
936
        }
937
        if (!fo)
938
                (*tmpLine).push_back(sl);
939
        currentLine_ = cc;
940
        rebuildList();
941
        widget_->showStyle(*tmpLine, doc_->PageColors, cc);
942
        updatePreview();
943
}
944
 
4829 tsoots 945
SMLineStyle::~SMLineStyle()
946
{
947
        delete widget_;
948
        delete twidget_;
949
        widget_ = 0;
950
        twidget_ = 0;
951
}