Subversion Repositories Scribus

Rev

Rev 21026 | Rev 22516 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
16546 jghali 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
 
8
#include "propertiespalette_line.h"
9
 
17539 jghali 10
#if defined(_MSC_VER) && !defined(_USE_MATH_DEFINES)
16546 jghali 11
#define _USE_MATH_DEFINES
12
#endif
13
#include <cmath>
21304 jghali 14
#include <QSignalBlocker>
20185 craig 15
 
16546 jghali 16
#include "arrowchooser.h"
17
#include "commonstrings.h"
18
#include "dasheditor.h"
20185 craig 19
#include "iconmanager.h"
16546 jghali 20
#include "pageitem.h"
21
#include "pageitem_textframe.h"
22
#include "sccolorengine.h"
23
#include "sccombobox.h"
20185 craig 24
#include "scraction.h"
16546 jghali 25
#include "scribuscore.h"
26
#include "selection.h"
20185 craig 27
#include "ui/propertiespalette_utils.h"
28
#include "undomanager.h"
16546 jghali 29
#include "units.h"
30
#include "util.h"
31
#include "util_math.h"
32
 
20185 craig 33
 
16546 jghali 34
//using namespace std;
35
 
36
PropertiesPalette_Line::PropertiesPalette_Line( QWidget* parent) : QWidget(parent)
37
{
38
        m_ScMW = 0;
39
        m_doc  = 0;
40
        m_haveDoc  = false;
41
        m_haveItem = false;
20780 jghali 42
        m_item     = NULL;
16546 jghali 43
        m_lineMode = false;
44
        m_unitRatio = 1.0;
20780 jghali 45
        m_unitIndex = 0;
16546 jghali 46
 
47
        setupUi(this);
17383 fschmid 48
        setSizePolicy( QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
16546 jghali 49
 
50
        lineType->addItem( tr("Custom"));
51
 
52
        lineModeLabel->setBuddy(lineMode);
53
        lineTypeLabel->setBuddy(lineType);
54
 
55
        startArrowLabel->setBuddy(startArrow);
56
        endArrowLabel->setBuddy(endArrow);
57
 
19054 fschmid 58
        startArrowScale->setMaximum( 1000 );
16546 jghali 59
        startArrowScale->setMinimum( 1 );
17420 fschmid 60
        startArrowScale->setDecimals(0);
16546 jghali 61
 
19054 fschmid 62
        endArrowScale->setMaximum( 1000 );
16546 jghali 63
        endArrowScale->setMinimum( 1 );
17420 fschmid 64
        endArrowScale->setDecimals(0);
16546 jghali 65
 
66
        lineWidthLabel->setBuddy(lineWidth);
67
        lineJoinLabel->setBuddy(lineJoinStyle);
68
        lineEndLabel->setBuddy(lineEndStyle);
69
 
70
        lineStyles->setItemDelegate(new LineFormatItemDelegate);
71
        lineStyles->addItem( "No Style" );
72
 
73
        languageChange();
74
 
75
        connect(lineWidth     , SIGNAL(valueChanged(double)), this, SLOT(handleLineWidth()));
76
        connect(lineType    , SIGNAL(activated(int))      , this, SLOT(handleLineStyle()));
77
        connect(lineJoinStyle, SIGNAL(activated(int))      , this, SLOT(handleLineJoin()));
78
        connect(lineEndStyle , SIGNAL(activated(int))      , this, SLOT(handleLineEnd()));
79
        connect(lineMode  , SIGNAL(activated(int))      , this, SLOT(handleLineMode()));
80
        connect(dashEditor, SIGNAL(dashChanged())       , this, SLOT(handleDashChange()));
81
        connect(startArrow, SIGNAL(activated(int))      , this, SLOT(handleStartArrow(int )));
82
        connect(endArrow  , SIGNAL(activated(int))      , this, SLOT(handleEndArrow(int )));
17420 fschmid 83
        connect(startArrowScale, SIGNAL(valueChanged(double)), this, SLOT(handleStartArrowScale(double )));
84
        connect(endArrowScale  , SIGNAL(valueChanged(double)), this, SLOT(handleEndArrowScale(double )));
16546 jghali 85
        connect(lineStyles, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(handleLineStyle(QListWidgetItem*)));
86
}
87
 
88
void PropertiesPalette_Line::changeEvent(QEvent *e)
89
{
90
        if (e->type() == QEvent::LanguageChange)
91
        {
92
                languageChange();
93
                return;
94
        }
95
        QWidget::changeEvent(e);
96
}
97
 
98
PageItem* PropertiesPalette_Line::currentItemFromSelection()
99
{
100
        PageItem *currentItem = NULL;
101
 
102
        if (m_doc)
103
        {
104
                if (m_doc->m_Selection->count() > 1)
105
                {
106
                        currentItem = m_doc->m_Selection->itemAt(0);
107
                }
108
                else if (m_doc->m_Selection->count() == 1)
109
                {
110
                        currentItem = m_doc->m_Selection->itemAt(0);
111
                }
112
        }
113
 
114
        return currentItem;
115
}
116
 
117
void PropertiesPalette_Line::setMainWindow(ScribusMainWindow *mw)
118
{
119
        m_ScMW = mw;
120
 
121
        connect(m_ScMW, SIGNAL(UpdateRequest(int)), this  , SLOT(handleUpdateRequest(int)));
122
}
123
 
124
void PropertiesPalette_Line::setDoc(ScribusDoc *d)
125
{
126
        if((d == (ScribusDoc*) m_doc) || (m_ScMW && m_ScMW->scriptIsRunning()))
127
                return;
128
 
129
        if (m_doc)
130
        {
131
                disconnect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
132
                disconnect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
133
        }
134
 
135
        m_doc  = d;
136
        m_item = NULL;
137
        m_unitRatio   = m_doc->unitRatio();
138
        m_unitIndex   = m_doc->unitIndex();
139
 
140
        m_haveDoc  = true;
141
        m_haveItem = false;
142
 
143
        lineWidth->setMaximum( 300 );
144
        lineWidth->setMinimum( 0 );
145
 
146
        updateLineStyles(m_doc);
147
        startArrow->rebuildList(&m_doc->arrowStyles());
148
        endArrow->rebuildList(&m_doc->arrowStyles());
149
 
150
        connect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
151
        connect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
152
}
153
 
154
void PropertiesPalette_Line::unsetDoc()
155
{
156
        if (m_doc)
157
        {
158
                disconnect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
159
                disconnect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
160
        }
161
 
162
        m_haveDoc  = false;
163
        m_haveItem = false;
164
        m_doc   = NULL;
165
        m_item  = NULL;
166
 
167
        updateLineStyles(0);
168
 
169
        setEnabled(false);
170
}
171
 
172
void PropertiesPalette_Line::unsetItem()
173
{
174
        m_haveItem = false;
175
        m_item     = NULL;
176
        dashEditor->hide();
177
        handleSelectionChanged();
178
}
179
 
180
void PropertiesPalette_Line::handleSelectionChanged()
181
{
182
        if (!m_haveDoc || !m_ScMW || m_ScMW->scriptIsRunning())
183
                return;
184
 
185
        PageItem* currItem = currentItemFromSelection();
186
        if (m_doc->m_Selection->count() > 1)
187
        {
18138 fschmid 188
                setEnabled(true);
16546 jghali 189
        }
190
        else
191
        {
192
                int itemType = currItem ? (int) currItem->itemType() : -1;
193
                m_haveItem = (itemType != -1);
194
 
195
                lineMode->setEnabled(false);
196
                switch (itemType)
197
                {
198
                case -1:
199
                        setEnabled(false);
200
                        break;
201
                case PageItem::ImageFrame:
202
                case PageItem::LatexFrame:
203
                case PageItem::OSGFrame:
204
                        setEnabled(currItem->asOSGFrame() == NULL);
20768 jghali 205
                        break;
16546 jghali 206
                case PageItem::Line:
207
                        setEnabled(true);
208
                        lineMode->setEnabled(true);
209
                        break;
210
                case PageItem::Arc:
211
                case PageItem::ItemType1:
212
                case PageItem::ItemType3:
213
                case PageItem::Polygon:
214
                case PageItem::PolyLine:
215
                case PageItem::PathText:
216
                case PageItem::RegularPolygon:
217
                case PageItem::TextFrame:
218
                        setEnabled(true);
219
                        break;
220
                case PageItem::Symbol:
221
                        setEnabled(false);
222
                        break;
223
                }
224
        }
225
        if (currItem)
226
        {
227
                setCurrentItem(currItem);
228
        }
229
        updateGeometry();
18480 jghali 230
        //repaint();
16546 jghali 231
}
232
 
233
void PropertiesPalette_Line::handleUpdateRequest(int updateFlags)
234
{
235
        if (updateFlags & reqArrowStylesUpdate)
236
                updateArrowStyles();
237
        if (updateFlags & reqLineStylesUpdate)
238
                updateLineStyles();
239
}
240
 
241
void PropertiesPalette_Line::setCurrentItem(PageItem *item)
242
{
243
        if (!m_ScMW || m_ScMW->scriptIsRunning())
244
                return;
21026 craig 245
        //CB We shouldn't really need to process this if our item is the same one
16546 jghali 246
        //maybe we do if the item has been changed by scripter.. but that should probably
247
        //set some status if so.
21026 craig 248
        //FIXME: This won't work until when a canvas deselect happens, m_item must be NULL.
16546 jghali 249
        //if (m_item == i)
250
        //      return;
251
 
252
        if (!m_doc)
253
                setDoc(item->doc());
254
 
255
        m_haveItem = false;
256
        m_item = item;
257
 
258
        lineStyles->blockSignals(true);
259
        startArrow->blockSignals(true);
260
        endArrow->blockSignals(true);
261
        startArrowScale->blockSignals(true);
262
        endArrowScale->blockSignals(true);
263
        lineMode->blockSignals(true);
264
 
265
        if ((m_item->asLine()) || (m_item->asPolyLine()) || (m_item->asSpiral()))
266
        {
267
                startArrow->setEnabled(true);
268
                endArrow->setEnabled(true);
269
                startArrow->setCurrentIndex(m_item->startArrowIndex());
270
                endArrow->setCurrentIndex(m_item->endArrowIndex());
271
                startArrowScale->setEnabled(true);
272
                endArrowScale->setEnabled(true);
273
                endArrowScale->setValue(m_item->endArrowScale());
274
                startArrowScale->setValue(m_item->startArrowScale());
275
        }
276
        else
277
        {
278
                startArrow->setEnabled(false);
279
                endArrow->setEnabled(false);
280
                startArrowScale->setEnabled(false);
281
                endArrowScale->setEnabled(false);
282
        }
283
 
284
        if (lineStyles->currentItem())
285
                lineStyles->currentItem()->setSelected(false);
286
 
287
        bool setter = false;
288
        if (m_item->NamedLStyle.isEmpty())
289
        {
290
                setter = true;
291
                QListWidgetItem *itemStl = NULL;
292
                itemStl = lineStyles->item(0);
293
                if (itemStl != NULL)
294
                        itemStl->setSelected(true);
295
        }
296
        else
297
        {
298
                QList<QListWidgetItem*> results (lineStyles->findItems(m_item->NamedLStyle, Qt::MatchFixedString|Qt::MatchCaseSensitive));
299
                if (results.count() > 0)
300
                        results[0]->setSelected(true);
301
                setter = false;
302
        }
303
 
304
        lineType->setEnabled(setter);
305
        lineWidth->setEnabled(setter);
306
        lineJoinStyle->setEnabled(setter);
307
        lineEndStyle->setEnabled(setter);
308
 
309
        if (m_item->dashes().count() == 0)
310
                dashEditor->hide();
311
        else
312
        {
313
                lineType->setCurrentIndex(37);
314
                dashEditor->setDashValues(m_item->dashes(), qMax(m_item->lineWidth(), 0.001), m_item->dashOffset());
315
                dashEditor->show();
316
        }
317
 
318
        if (m_lineMode)
319
                lineMode->setCurrentIndex(1);
320
        else
321
                lineMode->setCurrentIndex(0);
322
 
323
        lineStyles->blockSignals(false);
324
        startArrow->blockSignals(false);
325
        endArrow->blockSignals(false);
326
        startArrowScale->blockSignals(false);
327
        endArrowScale->blockSignals(false);
328
        lineMode->blockSignals(false);
329
 
17418 fschmid 330
        setter = false;
16546 jghali 331
 
332
        if ((m_item->isGroup()) && (!m_item->isSingleSel))
333
        {
334
                setEnabled(false);
335
        }
336
 
337
        m_haveItem = true;
338
 
18795 jghali 339
        showLineWidth(m_item->lineWidth());
340
        showLineValues(m_item->lineStyle(), m_item->lineEnd(), m_item->lineJoin());
16546 jghali 341
 
342
        if (m_item->asOSGFrame())
343
        {
344
                setEnabled(false);
345
        }
346
        if (m_item->asSymbolFrame())
347
        {
348
                setEnabled(false);
349
        }
350
}
351
 
352
void PropertiesPalette_Line::updateArrowStyles()
353
{
354
        updateArrowStyles(m_doc);
355
}
356
 
357
void PropertiesPalette_Line::updateArrowStyles(ScribusDoc *doc)
358
{
359
        if (doc)
360
        {
361
                startArrow->rebuildList(&doc->arrowStyles());
362
                endArrow->rebuildList(&doc->arrowStyles());
363
        }
364
}
365
 
366
void PropertiesPalette_Line::updateLineStyles()
367
{
368
        updateLineStyles(m_doc);
369
}
370
 
371
void PropertiesPalette_Line::updateLineStyles(ScribusDoc *dd)
372
{
373
        if (!m_ScMW || m_ScMW->scriptIsRunning())
374
                return;
375
 
376
        lineStyles->blockSignals(true);
377
        lineStyles->clear();
378
        if (dd != 0)
379
        {
17400 fschmid 380
                QHash<QString,multiLine>::Iterator it;
16546 jghali 381
                for (it = dd->MLineStyles.begin(); it != dd->MLineStyles.end(); ++it)
382
                        lineStyles->addItem( new LineFormatItem(dd, it.value(), it.key()) );
383
                lineStyles->sortItems();
384
                lineStyles->insertItem( 0, tr("No Style"));
385
                if (lineStyles->currentItem())
386
                        lineStyles->currentItem()->setSelected(false);
387
        }
388
        lineStyles->blockSignals(false);
389
}
390
 
18795 jghali 391
void PropertiesPalette_Line::showLineWidth(double s)
16546 jghali 392
{
393
        if (!m_ScMW || m_ScMW->scriptIsRunning())
394
                return;
395
        lineWidth->showValue(s * m_unitRatio);
396
        if (m_haveItem)
397
        {
398
                if (m_item->dashes().count() != 0)
399
                {
400
                        dashEditor->blockSignals(true);
401
                        if (m_item->lineWidth() != 0.0)
402
                        {
403
                                dashEditor->setDashValues(m_item->dashes(), m_item->lineWidth(), m_item->dashOffset());
404
                                dashEditor->setEnabled(true);
405
                        }
406
                        else
407
                                dashEditor->setEnabled(false);
408
                        dashEditor->blockSignals(false);
409
                }
410
        }
411
}
412
 
18795 jghali 413
void PropertiesPalette_Line::showLineValues(Qt::PenStyle p, Qt::PenCapStyle pc, Qt::PenJoinStyle pj)
16546 jghali 414
{
415
        if (!m_ScMW || m_ScMW->scriptIsRunning())
416
                return;
417
 
418
        lineType->blockSignals(true);
419
        dashEditor->blockSignals(true);
420
        if (m_haveItem)
421
        {
422
                if (m_item->dashes().count() != 0)
423
                {
424
                        lineType->setCurrentIndex(37);
425
                        dashEditor->setDashValues(m_item->dashes(), qMax(m_item->lineWidth(), 0.001), m_item->dashOffset());
426
                }
427
                else
428
                        lineType->setCurrentIndex(static_cast<int>(p) - 1);
429
        }
430
        else
431
                lineType->setCurrentIndex(static_cast<int>(p) - 1);
432
        dashEditor->blockSignals(false);
433
        lineType->blockSignals(false);
434
 
435
        lineEndStyle->blockSignals(true);
436
        switch (pc)
437
        {
438
        case Qt::FlatCap:
439
                lineEndStyle->setCurrentIndex(0);
440
                break;
441
        case Qt::SquareCap:
442
                lineEndStyle->setCurrentIndex(1);
443
                break;
444
        case Qt::RoundCap:
445
                lineEndStyle->setCurrentIndex(2);
446
                break;
447
        default:
448
                lineEndStyle->setCurrentIndex(0);
449
                break;
450
        }
451
        lineEndStyle->blockSignals(false);
452
 
453
        lineJoinStyle->blockSignals(true);
454
        switch (pj)
455
        {
456
        case Qt::MiterJoin:
457
                lineJoinStyle->setCurrentIndex(0);
458
                break;
459
        case Qt::BevelJoin:
460
                lineJoinStyle->setCurrentIndex(1);
461
                break;
462
        case Qt::RoundJoin:
463
                lineJoinStyle->setCurrentIndex(2);
464
                break;
465
        default:
466
                lineJoinStyle->setCurrentIndex(0);
467
                break;
468
        }
469
        lineJoinStyle->blockSignals(false);
470
}
471
 
472
void PropertiesPalette_Line::handleLineWidth()
473
{
474
        if (!m_ScMW || m_ScMW->scriptIsRunning())
475
                return;
476
        if ((m_haveDoc) && (m_haveItem))
477
        {
478
                double oldL = m_item->lineWidth();
479
                m_doc->itemSelection_SetLineWidth(lineWidth->value() / m_unitRatio);
480
                if (m_item->dashes().count() != 0)
481
                {
482
                        if ((oldL != 0.0) && (m_item->lineWidth() != 0.0))
483
                        {
484
                                for (int a = 0; a < m_item->DashValues.count(); a++)
485
                                {
486
                                        m_item->DashValues[a] = m_item->DashValues[a] / oldL * m_item->lineWidth();
487
                                }
488
                                m_item->setDashOffset(m_item->dashOffset() / oldL * m_item->lineWidth());
489
                        }
490
                        if (m_item->lineWidth() != 0.0)
491
                        {
492
                                dashEditor->setDashValues(m_item->dashes(), m_item->lineWidth(), m_item->dashOffset());
493
                                dashEditor->setEnabled((m_item->lineWidth() != 0.0));
494
                        }
495
                        else
496
                                dashEditor->setEnabled(false);
497
                }
17057 fschmid 498
                m_doc->invalidateAll();
17038 fschmid 499
                m_doc->regionsChanged()->update(QRect());
16546 jghali 500
        }
501
}
502
 
503
void PropertiesPalette_Line::handleLineStyle()
504
{
505
        if (!m_ScMW || m_ScMW->scriptIsRunning())
506
                return;
507
        if ((m_haveDoc) && (m_haveItem))
508
        {
509
                if (lineType->currentIndex() == 37)
510
                {
511
                        if (m_item->dashes().count() == 0)
512
                        {
513
                                if ((m_item->lineStyle() == 0) || (m_item->lineStyle() == 1))
514
                                {
515
                                        m_item->DashValues.append(4.0 * qMax(m_item->lineWidth(), 1.0));
516
                                        m_item->DashValues.append(2.0 * qMax(m_item->lineWidth(), 1.0));
517
                                }
518
                                else
519
                                        getDashArray(m_item->lineStyle(), qMax(m_item->lineWidth(), 1.0), m_item->DashValues);
520
                        }
521
                        if (m_item->lineWidth() != 0.0)
522
                                dashEditor->setDashValues(m_item->dashes(), m_item->lineWidth(), m_item->dashOffset());
523
                        else
524
                        {
525
                                dashEditor->setEnabled(false);
526
                                dashEditor->setDashValues(m_item->dashes(), 1.0, m_item->dashOffset());
527
                        }
528
                        dashEditor->show();
529
                        m_item->update();
530
                }
531
                else
532
                {
533
                        m_item->DashValues.clear();
534
                        dashEditor->hide();
535
                        m_doc->itemSelection_SetLineArt(static_cast<Qt::PenStyle>(lineType->currentIndex()+1));
536
                }
537
        }
538
}
539
 
540
void PropertiesPalette_Line::handleLineJoin()
541
{
542
        if (!m_ScMW || m_ScMW->scriptIsRunning())
543
                return;
544
        if ((m_haveDoc) && (m_haveItem))
545
        {
546
                Qt::PenJoinStyle c = Qt::MiterJoin;
547
                switch (lineJoinStyle->currentIndex())
548
                {
549
                case 0:
550
                        c = Qt::MiterJoin;
551
                        break;
552
                case 1:
553
                        c = Qt::BevelJoin;
554
                        break;
555
                case 2:
556
                        c = Qt::RoundJoin;
557
                        break;
558
                }
559
                m_doc->itemSelection_SetLineJoin(c);
560
        }
561
}
562
 
563
void PropertiesPalette_Line::handleLineEnd()
564
{
565
        if (!m_ScMW || m_ScMW->scriptIsRunning())
566
                return;
567
        if ((m_haveDoc) && (m_haveItem))
568
        {
569
                Qt::PenCapStyle c = Qt::FlatCap;
570
                switch (lineEndStyle->currentIndex())
571
                {
572
                case 0:
573
                        c = Qt::FlatCap;
574
                        break;
575
                case 1:
576
                        c = Qt::SquareCap;
577
                        break;
578
                case 2:
579
                        c = Qt::RoundCap;
580
                        break;
581
                }
582
                m_doc->itemSelection_SetLineEnd(c);
583
        }
584
}
585
 
586
void PropertiesPalette_Line::handleLineMode()
587
{
588
        if (!m_ScMW || m_ScMW->scriptIsRunning())
589
                return;
590
        m_lineMode = (lineMode->currentIndex() == 1);
591
        emit lineModeChanged(lineMode->currentIndex());
592
}
593
 
594
void PropertiesPalette_Line::handleStartArrow(int id)
595
{
596
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
597
                return;
598
        m_doc->itemSelection_ApplyArrowHead(id,-1);
599
}
600
 
601
void PropertiesPalette_Line::handleEndArrow(int id)
602
{
603
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
604
                return;
605
        m_doc->itemSelection_ApplyArrowHead(-1, id);
606
}
607
 
17420 fschmid 608
void PropertiesPalette_Line::handleStartArrowScale(double sc)
16546 jghali 609
{
610
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
611
                return;
17420 fschmid 612
        m_doc->itemSelection_ApplyArrowScale(static_cast<int>(sc), -1, NULL);
16546 jghali 613
}
614
 
17420 fschmid 615
void PropertiesPalette_Line::handleEndArrowScale(double sc)
16546 jghali 616
{
617
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
618
                return;
17420 fschmid 619
        m_doc->itemSelection_ApplyArrowScale(-1, static_cast<int>(sc), NULL);
16546 jghali 620
}
621
 
622
void PropertiesPalette_Line::handleDashChange()
623
{
624
        if (!m_ScMW || m_ScMW->scriptIsRunning())
625
                return;
626
        if ((m_haveDoc) && (m_haveItem))
627
        {
628
                if (m_item->lineWidth() != 0.0)
629
                {
630
                        m_item->setDashes(dashEditor->getDashValues(m_item->lineWidth()));
631
                        m_item->setDashOffset(dashEditor->Offset->value() * m_item->lineWidth());
632
                }
633
                m_item->update();
634
        }
635
}
636
 
637
void PropertiesPalette_Line::handleLineStyle(QListWidgetItem *widgetItem)
638
{
639
        if (!m_doc || !m_ScMW || m_ScMW->scriptIsRunning() || !widgetItem)
640
                return;
641
        bool setter = (widgetItem->listWidget()->currentRow() == 0);
642
        m_doc->itemSelection_SetNamedLineStyle(setter ? QString("") : widgetItem->text());
643
        lineType->setEnabled(setter);
644
        lineWidth->setEnabled(setter);
645
        lineJoinStyle->setEnabled(setter);
646
        lineEndStyle->setEnabled(setter);
647
}
648
 
649
void PropertiesPalette_Line::languageChange()
650
{
21304 jghali 651
        QSignalBlocker lineTypeBlocker(lineType);
16546 jghali 652
        int oldLineStyle = lineType->currentIndex();
653
        lineType->clear();
654
        lineType->updateList();
655
        lineType->addItem( tr("Custom"));
656
        lineType->setCurrentIndex(oldLineStyle);
21304 jghali 657
 
658
        QSignalBlocker lineModeBlocker(lineMode);
20435 jghali 659
        int oldLineMode = lineMode->currentIndex();
16546 jghali 660
        lineMode->clear();
661
        lineMode->addItem( tr("Left Point"));
662
        lineMode->addItem( tr("End Points"));
663
        lineMode->setCurrentIndex(oldLineMode);
21304 jghali 664
 
16546 jghali 665
        lineModeLabel->setText( tr("&Basepoint:"));
666
        lineTypeLabel->setText( tr("T&ype of Line:"));
667
        startArrowLabel->setText( tr("Start Arrow:"));
668
        endArrowLabel->setText( tr("End Arrow:"));
669
        startArrowScaleLabel->setText( tr("Scaling:"));
670
        endArrowScaleLabel->setText( tr("Scaling:"));
671
        if (m_haveDoc)
672
        {
21304 jghali 673
                QSignalBlocker startArrowBlocker(startArrow);
16546 jghali 674
                int arrowItem = startArrow->currentIndex();
675
                startArrow->rebuildList(&m_doc->arrowStyles());
676
                startArrow->setCurrentIndex(arrowItem);
21304 jghali 677
                QSignalBlocker endArrowBlocker(endArrow);
16546 jghali 678
                arrowItem = endArrow->currentIndex();
679
                endArrow->rebuildList(&m_doc->arrowStyles());
680
                endArrow->setCurrentIndex(arrowItem);
681
        }
682
        lineWidthLabel->setText( tr("Line &Width:"));
683
        lineJoinLabel->setText( tr("Ed&ges:"));
684
 
21304 jghali 685
        QSignalBlocker lineJoinStyleBlocker(lineJoinStyle);
686
        int oldLJoinStyle = lineJoinStyle->currentIndex();
16546 jghali 687
        lineJoinStyle->clear();
20185 craig 688
        IconManager* im=IconManager::instance();
689
        lineJoinStyle->addItem(im->loadIcon("16/stroke-join-miter.png"), tr("Miter Join"));
690
        lineJoinStyle->addItem(im->loadIcon("16/stroke-join-bevel.png"), tr("Bevel Join"));
691
        lineJoinStyle->addItem(im->loadIcon("16/stroke-join-round.png"), tr("Round Join"));
16546 jghali 692
        lineJoinStyle->setCurrentIndex(oldLJoinStyle);
693
 
21304 jghali 694
        QSignalBlocker lineEndStyleBlocker(lineEndStyle);
695
        int oldLEndStyle = lineEndStyle->currentIndex();
16546 jghali 696
        lineEndStyle->clear();
20185 craig 697
        lineEndStyle->addItem(im->loadIcon("16/stroke-cap-butt.png"), tr("Flat Cap"));
698
        lineEndStyle->addItem(im->loadIcon("16/stroke-cap-square.png"), tr("Square Cap"));
699
        lineEndStyle->addItem(im->loadIcon("16/stroke-cap-round.png"), tr("Round Cap"));
16546 jghali 700
        lineEndStyle->setCurrentIndex(oldLEndStyle);
701
        lineEndLabel->setText( tr("&Endings:"));
702
 
703
        QString pctSuffix = tr(" %");
704
        startArrowScale->setSuffix(pctSuffix);
705
        endArrowScale->setSuffix(pctSuffix);
706
 
707
        QString ptSuffix = tr(" pt");
708
        QString suffix = (m_doc) ? unitGetSuffixFromIndex(m_doc->unitIndex()) : ptSuffix;
709
 
710
        lineWidth->setSuffix(suffix);
711
        lineWidth->setSpecialValueText( tr("Hairline"));
712
 
713
        if(lineStyles->count() > 0)
714
                lineStyles->item(0)->setText( tr("No Style") );
715
 
716
        lineMode->setToolTip( tr("Change settings for left or end points"));
717
        lineType->setToolTip( tr("Pattern of line"));
718
        lineWidth->setToolTip( tr("Thickness of line"));
719
        lineJoinStyle->setToolTip( tr("Type of line joins"));
720
        lineEndStyle->setToolTip( tr("Type of line end"));
721
        lineStyles->setToolTip( tr("Line style of current object"));
722
        startArrow->setToolTip( tr("Arrow head style for start of line"));
723
        endArrow->setToolTip( tr("Arrow head style for end of line"));
724
        startArrowScale->setToolTip( tr("Arrow head scale for start of line"));
725
        endArrowScale->setToolTip( tr("Arrow head scale for end of line"));
726
}
727
 
728
void PropertiesPalette_Line::unitChange()
729
{
730
        if (!m_doc)
731
                return;
732
 
733
        m_unitRatio = m_doc->unitRatio();
734
        m_unitIndex = m_doc->unitIndex();
735
 
736
        lineWidth->blockSignals(true);
737
        lineWidth->setNewUnit( m_unitIndex );
738
        lineWidth->blockSignals(false);
739
}