Subversion Repositories Scribus

Rev

Rev 21265 | Rev 21587 | 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
*/
10200 cbradney 7
 
16901 fschmid 8
#include <QBuffer>
10859 cbradney 9
#include <QEvent>
8708 fschmid 10
#include <QHeaderView>
10200 cbradney 11
#include <QHelpEvent>
12
#include <QImage>
8501 cbradney 13
#include <QLabel>
10200 cbradney 14
#include <QLayout>
8708 fschmid 15
#include <QList>
10200 cbradney 16
#include <QMenu>
17
#include <QMessageBox>
8501 cbradney 18
#include <QResizeEvent>
10200 cbradney 19
#include <QToolTip>
20
#include <QVariant>
9514 fschmid 21
#include <QWidgetAction>
16899 fschmid 22
#include <QSignalMapper>
12378 fschmid 23
#include <QShortcut>
16916 fschmid 24
#include <QDebug>
1460 cbradney 25
 
10200 cbradney 26
#include "actionmanager.h"
19067 craig 27
#include "appmodes.h"
11264 fschmid 28
#include "canvasmode.h"
2952 cbradney 29
#include "commonstrings.h"
11405 cbradney 30
#include "contextmenu.h"
20185 craig 31
#include "iconmanager.h"
19067 craig 32
#include "layers.h"
10862 cbradney 33
#include "outlinepalette.h"
16736 jghali 34
#include "propertiespalette.h"
16729 fschmid 35
#include "scpage.h"
173 Franz 36
#include "scribus.h"
19080 craig 37
#include "scribusdoc.h"
19093 craig 38
#include "scribusview.h"
8241 fschmid 39
#include "selection.h"
40
#include "undomanager.h"
16901 fschmid 41
#include "units.h"
10200 cbradney 42
#include "util.h"
10862 cbradney 43
#include "util_color.h"
10212 cbradney 44
#include "util_formats.h"
1460 cbradney 45
 
10862 cbradney 46
 
10066 cbradney 47
OutlineTreeItem::OutlineTreeItem(OutlineTreeItem* parent, OutlineTreeItem* after) : QTreeWidgetItem(parent, after)
8217 fschmid 48
{
49
        PageObject = NULL;
50
        PageItemObject = NULL;
16899 fschmid 51
        DocObject = NULL;
8217 fschmid 52
        type = -1;
16899 fschmid 53
        LayerID = -1;
8217 fschmid 54
}
55
 
10066 cbradney 56
OutlineTreeItem::OutlineTreeItem(QTreeWidget* parent, OutlineTreeItem* after) : QTreeWidgetItem(parent, after)
8217 fschmid 57
{
58
        PageObject = NULL;
59
        PageItemObject = NULL;
16899 fschmid 60
        DocObject = NULL;
8217 fschmid 61
        type = -1;
16899 fschmid 62
        LayerID = -1;
8217 fschmid 63
}
64
 
10862 cbradney 65
OutlineWidget::OutlineWidget(QWidget* parent) : QTreeWidget(parent)
9598 fschmid 66
{
16916 fschmid 67
        setDragDropMode(QAbstractItemView::InternalMove);
9598 fschmid 68
}
69
 
14405 jghali 70
void OutlineWidget::selectItems(QList<QTreeWidgetItem*> items)
71
{
72
        QItemSelection itemSelection;
73
        for (int i = 0; i < items.count(); ++i)
74
        {
75
                QModelIndex index = this->indexFromItem(items.at(i));
76
                if (index.isValid())
77
                {
78
                        itemSelection.select(index, index);
79
                }
80
        }
81
        selectionModel()->select(itemSelection, QItemSelectionModel::Select);
82
}
83
 
16916 fschmid 84
void OutlineWidget::dropEvent(QDropEvent *e)
85
{
86
        bool haveLayers = false;
87
        QModelIndex id;
88
        QTreeWidgetItem* it = NULL;
89
        QList<QModelIndex> idxs = selectedIndexes();
90
        if (!idxs.isEmpty())
91
                id = idxs.at(0);
92
        if (id.isValid())
93
                it = itemFromIndex(id);
16987 fschmid 94
        OutlineTreeItem *itemPar = (OutlineTreeItem*)it->parent();
95
        while (itemPar->type != 2)
16916 fschmid 96
        {
16987 fschmid 97
                if (itemPar->type == 5)
98
                        haveLayers = true;
99
                itemPar = (OutlineTreeItem*)itemPar->parent();
16916 fschmid 100
        }
19320 jghali 101
 
16916 fschmid 102
        QTreeWidget::dropEvent(e);
19320 jghali 103
        if (it == NULL)
104
                return;
105
 
20817 jghali 106
        OutlineTreeItem *item = (OutlineTreeItem*) it;
19320 jghali 107
        OutlineTreeItem *itemPl = (OutlineTreeItem*)it->parent();
108
        OutlineTreeItem *itemPg;
109
        if (itemPl->type == 5)
16916 fschmid 110
        {
19320 jghali 111
                itemPg = (OutlineTreeItem*)it->parent()->parent();
112
        }
113
        else if (itemPl->type == 2)
114
        {
115
                itemPg = (OutlineTreeItem*)it->parent();
116
                if (haveLayers)
16916 fschmid 117
                {
19320 jghali 118
                        itemPl = (OutlineTreeItem*)itemPg->child(0);
119
                        itemPg->removeChild(it);
120
                        itemPl->addChild(it);
121
                }
122
        }
123
        else
124
        {
125
                itemPg = (OutlineTreeItem*)it->parent();
126
                while (itemPg->type != 2)
127
                {
128
                        itemPg = (OutlineTreeItem*)itemPg->parent();
129
                }
130
        }
131
        if (itemPl->indexOfChild(it) != itemPl->childCount() - 1)
132
        {
133
                OutlineTreeItem *itemBe = (OutlineTreeItem*)itemPl->child(itemPl->indexOfChild(it) + 1);
134
                if ((itemBe->type == 1) || (itemBe->type == 3) || (itemBe->type == 4))
135
                {
136
                        if (item->PageItemObject->isGroupChild())
137
                                item->DocObject->removeFromGroup(item->PageItemObject);
138
                        else
139
                                item->DocObject->Items->removeOne(item->PageItemObject);
140
                        if (itemBe->PageItemObject->isGroupChild())
16916 fschmid 141
                        {
19320 jghali 142
                                PageItem* group = itemBe->PageItemObject->Parent;
143
                                int d = group->groupItemList.indexOf(itemBe->PageItemObject);
144
                                double xx = item->PageItemObject->xPos() - itemPar->PageObject->xOffset() + itemPg->PageObject->xOffset();
145
                                double yy = item->PageItemObject->yPos() - itemPar->PageObject->yOffset() + itemPg->PageObject->yOffset();
146
                                item->PageItemObject->setXYPos(xx, yy);
147
                                item->DocObject->addToGroup(group, item->PageItemObject);
148
                                group->groupItemList.insert(d, item->PageItemObject);
149
                                item->PageItemObject->setLayer(group->LayerID);
16916 fschmid 150
                        }
19320 jghali 151
                        else
16916 fschmid 152
                        {
19320 jghali 153
                                int d = item->DocObject->Items->indexOf(itemBe->PageItemObject);
154
                                item->DocObject->Items->insert(d+1, item->PageItemObject);
155
                                if (itemPl->type == 5)
156
                                        item->PageItemObject->setLayer(itemPl->LayerID);
157
                                double xx = item->PageItemObject->xPos() - itemPar->PageObject->xOffset() + itemPg->PageObject->xOffset();
158
                                double yy = item->PageItemObject->yPos() - itemPar->PageObject->yOffset() + itemPg->PageObject->yOffset();
159
                                item->PageItemObject->setXYPos(xx, yy);
16916 fschmid 160
                        }
19320 jghali 161
                        item->PageItemObject->setRedrawBounding();
162
                        item->DocObject->setModified(true);
163
                        item->DocObject->scMW()->showLayer();
164
                        item->DocObject->scMW()->closeActiveWindowMasterPageEditor();
165
                        if (item->PageItemObject->isGroup())
166
                        {
167
                                item->DocObject->GroupOnPage(item->PageItemObject);
168
                                item->DocObject->scMW()->selectItemsFromOutlines(item->PageItemObject, false);
169
                        }
16987 fschmid 170
                        else
16916 fschmid 171
                        {
19320 jghali 172
                                item->PageItemObject->OwnPage = item->DocObject->OnPage(item->PageItemObject);
173
                                item->DocObject->scMW()->selectItemsFromOutlines(item->PageItemObject, true);
16987 fschmid 174
                        }
19320 jghali 175
                        QList<QTreeWidgetItem*> selList;
176
                        selList.append(it);
177
                        selectItems(selList);
178
                }
179
        }
180
        else
181
        {
182
//              itemPl->insertChild(0, itemPl->takeChild(itemPl->indexOfChild(it)));
183
                if ((itemPl->type == 2) || (itemPl->type == 5))
184
                {
185
                        if (item->PageItemObject->isGroupChild())
16987 fschmid 186
                        {
19320 jghali 187
                                item->DocObject->removeFromGroup(item->PageItemObject);
188
                                item->DocObject->Items->append(item->PageItemObject);
16916 fschmid 189
                        }
19320 jghali 190
                        if (itemPl->type == 5)
191
                                item->PageItemObject->setLayer(itemPl->LayerID);
192
                        double xx = item->PageItemObject->xPos() - itemPar->PageObject->xOffset() + itemPg->PageObject->xOffset();
193
                        double yy = item->PageItemObject->yPos() - itemPar->PageObject->yOffset() + itemPg->PageObject->yOffset();
194
                        item->PageItemObject->setXYPos(xx, yy);
195
                }
196
                else
197
                {
198
                        OutlineTreeItem *itemBe = (OutlineTreeItem*)it->parent();
199
                        if ((itemBe->type == 1) || (itemBe->type == 3) || (itemBe->type == 4))
16916 fschmid 200
                        {
19320 jghali 201
                                if (item->PageItemObject->isGroupChild())
202
                                        item->DocObject->removeFromGroup(item->PageItemObject);
16987 fschmid 203
                                else
19320 jghali 204
                                        item->DocObject->Items->removeOne(item->PageItemObject);
205
                                PageItem* group = itemBe->PageItemObject;
206
                                double xx = item->PageItemObject->xPos() - itemPar->PageObject->xOffset() + itemPg->PageObject->xOffset();
207
                                double yy = item->PageItemObject->yPos() - itemPar->PageObject->yOffset() + itemPg->PageObject->yOffset();
208
                                item->PageItemObject->setXYPos(xx, yy);
209
                                item->DocObject->addToGroup(group, item->PageItemObject);
210
                                group->groupItemList.append(item->PageItemObject);
211
                                item->PageItemObject->setLayer(group->LayerID);
16916 fschmid 212
                        }
213
                }
19320 jghali 214
                item->PageItemObject->setRedrawBounding();
215
                item->DocObject->setModified(true);
216
                item->DocObject->scMW()->showLayer();
217
                item->DocObject->scMW()->closeActiveWindowMasterPageEditor();
218
                if (item->PageItemObject->isGroup())
219
                {
220
                        item->DocObject->GroupOnPage(item->PageItemObject);
221
                        item->DocObject->scMW()->selectItemsFromOutlines(item->PageItemObject, false);
222
                }
223
                else
224
                {
225
                        item->PageItemObject->OwnPage = item->DocObject->OnPage(item->PageItemObject);
19817 craig 226
                        item->DocObject->scMW()->selectItemsFromOutlines(item->PageItemObject, true, 1);
19320 jghali 227
                }
228
                QList<QTreeWidgetItem*> selList;
229
                selList.append(it);
230
                selectItems(selList);
16916 fschmid 231
        }
232
}
233
 
19277 craig 234
void OutlineWidget::keyPressEvent(QKeyEvent *e)
235
{
236
        if (e->key() == Qt::Key_Backspace || e->key() == Qt::Key_Delete)
237
        {
238
                foreach (QTreeWidgetItem * twItem, selectedItems())
239
                {
240
                        if (twItem != 0)
241
                        {
242
                                OutlineTreeItem *item = (OutlineTreeItem*)twItem;
243
                                if (item)
244
                                {
245
                                        switch (item->type)
246
                                        {
247
                                                case 1: //PageItem on master page
248
                                                        {
249
                                                                PageItem* pageItem = item->PageItemObject;
19278 craig 250
                                                                if (!pageItem->isGroupChild())
19280 craig 251
                                                                        item->DocObject->itemSelection_DeleteItem();
19277 craig 252
                                                        }
253
                                                        break;
254
                                                case 3: //PageItem on normal page
255
                                                        {
256
                                                                PageItem* pageItem = item->PageItemObject;
19278 craig 257
                                                                if (!pageItem->isGroupChild())
19280 craig 258
                                                                        item->DocObject->itemSelection_DeleteItem();
19277 craig 259
                                                        }
260
                                                        break;
261
                                                default:
262
                                                        {
263
                                                                //qDebug()<<item->type;
264
                                                        }
265
                                                        break;
266
                                        }
267
                                }
268
                        }
269
                }
270
        }
271
}
272
 
10862 cbradney 273
bool OutlineWidget::viewportEvent(QEvent *event)
9598 fschmid 274
{
275
        if (event->type() == QEvent::ToolTip)
276
        {
277
                QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);
278
                QTreeWidgetItem* it = itemAt(helpEvent->pos());
279
                if (it != 0)
280
                {
10066 cbradney 281
                        OutlineTreeItem *item = (OutlineTreeItem*)it;
9598 fschmid 282
                        if (item != NULL)
283
                        {
11587 cbradney 284
                                QString tipText("");
16899 fschmid 285
                                if (item->type == 5)
286
                                {
287
                                        tipText += "<b>" + tr("Layer is:") + "</b><br><br>";
288
                                        if (item->DocObject->activeLayer() == item->LayerID)
289
                                                tipText += tr("active") + "<br>";
290
                                        if (item->DocObject->layerVisible(item->LayerID))
291
                                                tipText += tr("visible") + "<br>";
292
                                        else
293
                                                tipText += tr("invisible") + "<br>";
294
                                        if (item->DocObject->layerPrintable(item->LayerID))
295
                                                tipText += tr("printing");
296
                                        else
297
                                                tipText += tr("non printing");
298
                                        if (item->DocObject->layerLocked(item->LayerID))
299
                                                tipText += "<br>" + tr("locked");
300
                                }
301
                                else if ((item->type == 1) || (item->type == 3) || (item->type == 4))
9598 fschmid 302
                                {
16916 fschmid 303
                                        PageItem *pgItem = item->PageItemObject;
304
                                        QPainter p;
305
                                        QImage pm = QImage(80, 80, QImage::Format_ARGB32_Premultiplied);
20185 craig 306
                                        QBrush b(QColor(205,205,205), IconManager::instance()->loadPixmap("testfill.png"));
16916 fschmid 307
                                        p.begin(&pm);
308
                                        p.fillRect(QRectF(0, 0, 80, 80), b);
16901 fschmid 309
                                        QImage thumb = pgItem->DrawObj_toImage(80);
16916 fschmid 310
                                        p.drawImage((80 - thumb.width()) / 2, (80 - thumb.height()) / 2, thumb);
311
                                        p.end();
16901 fschmid 312
                                        QBuffer buffer;
313
                                        buffer.open(QIODevice::WriteOnly);
16916 fschmid 314
                                        pm.save(&buffer, "PNG");
16901 fschmid 315
                                        QByteArray ba = buffer.buffer().toBase64();
316
                                        buffer.close();
16916 fschmid 317
                                        tipText = "<p align=\"center\"><img src=\"data:image/png;base64," + QString(ba) + "\"></p><p>";
9598 fschmid 318
                                        switch (pgItem->itemType())
319
                                        {
320
                                                case PageItem::ImageFrame:
11264 fschmid 321
                                                        if (pgItem->asLatexFrame())
16901 fschmid 322
                                                                tipText += CommonStrings::itemType_LatexFrame;
13839 fschmid 323
#ifdef HAVE_OSG
324
                                                        else if (pgItem->asOSGFrame())
16901 fschmid 325
                                                                tipText += CommonStrings::itemType_OSGFrame;
13839 fschmid 326
#endif
11264 fschmid 327
                                                        else
16901 fschmid 328
                                                                tipText += CommonStrings::itemType_ImageFrame;
9598 fschmid 329
                                                        break;
330
                                                case PageItem::TextFrame:
331
                                                        switch (pgItem->annotation().Type())
332
                                                        {
17911 fschmid 333
                                                                case Annotation::Button:
16901 fschmid 334
                                                                        tipText += CommonStrings::itemSubType_PDF_PushButton;
9598 fschmid 335
                                                                        break;
17911 fschmid 336
                                                                case Annotation::Textfield:
16901 fschmid 337
                                                                        tipText += CommonStrings::itemSubType_PDF_TextField;
9598 fschmid 338
                                                                        break;
17911 fschmid 339
                                                                case Annotation::Checkbox:
16901 fschmid 340
                                                                        tipText += CommonStrings::itemSubType_PDF_CheckBox;
9598 fschmid 341
                                                                        break;
17911 fschmid 342
                                                                case Annotation::Combobox:
16901 fschmid 343
                                                                        tipText += CommonStrings::itemSubType_PDF_ComboBox;
9598 fschmid 344
                                                                        break;
17911 fschmid 345
                                                                case Annotation::Listbox:
16901 fschmid 346
                                                                        tipText += CommonStrings::itemSubType_PDF_ListBox;
9598 fschmid 347
                                                                        break;
17911 fschmid 348
                                                                case Annotation::Text:
16901 fschmid 349
                                                                        tipText += CommonStrings::itemSubType_PDF_TextAnnotation;
9598 fschmid 350
                                                                        break;
17911 fschmid 351
                                                                case Annotation::Link:
16901 fschmid 352
                                                                        tipText += CommonStrings::itemSubType_PDF_LinkAnnotation;
17963 fschmid 353
                                                                        break;
354
                                                                case Annotation::RadioButton:
355
                                                                        tipText += CommonStrings::itemSubType_PDF_RadioButton;
9598 fschmid 356
                                                                        break;
357
                                                                default:
16901 fschmid 358
                                                                        tipText += CommonStrings::itemType_TextFrame;
9598 fschmid 359
                                                                        break;
360
                                                        }
361
                                                        break;
362
                                                case PageItem::Line:
16901 fschmid 363
                                                        tipText += CommonStrings::itemType_Line;
9598 fschmid 364
                                                        break;
16215 fschmid 365
                                                case PageItem::Arc:
16901 fschmid 366
                                                        tipText += CommonStrings::itemType_Arc;
16899 fschmid 367
                                                        break;
9598 fschmid 368
                                                case PageItem::Polygon:
16901 fschmid 369
                                                        tipText += CommonStrings::itemType_Polygon;
16899 fschmid 370
                                                        break;
16191 fschmid 371
                                                case PageItem::RegularPolygon:
16901 fschmid 372
                                                        tipText += CommonStrings::itemType_RegularPolygon;
9598 fschmid 373
                                                        break;
374
                                                case PageItem::PolyLine:
16901 fschmid 375
                                                        tipText += CommonStrings::itemType_Polyline;
16899 fschmid 376
                                                        break;
16311 fschmid 377
                                                case PageItem::Spiral:
16901 fschmid 378
                                                        tipText += CommonStrings::itemType_Spiral;
9598 fschmid 379
                                                        break;
380
                                                case PageItem::PathText:
16901 fschmid 381
                                                        tipText += CommonStrings::itemType_PathText;
9598 fschmid 382
                                                        break;
15060 fschmid 383
                                                case PageItem::Symbol:
16901 fschmid 384
                                                        tipText += CommonStrings::itemType_Symbol;
15060 fschmid 385
                                                        break;
16899 fschmid 386
                                                case PageItem::Group:
16901 fschmid 387
                                                        tipText += CommonStrings::itemType_Group;
16899 fschmid 388
                                                        break;
389
                                                case PageItem::Table:
16901 fschmid 390
                                                        tipText += CommonStrings::itemType_Table;
16899 fschmid 391
                                                        break;
9598 fschmid 392
                                                default:
393
                                                        break;
16899 fschmid 394
                                        }
16901 fschmid 395
                                        tipText +="<br>" + tr("X-Pos:") + " ";
396
                                        if (pgItem->OwnPage != -1)
20508 fschmid 397
                                                tipText += value2String(pgItem->xPos() - item->PageObject->xOffset(), pgItem->doc()->unitIndex(), true, true);
16901 fschmid 398
                                        else
20508 fschmid 399
                                                tipText += value2String(pgItem->xPos(), pgItem->doc()->unitIndex(), true, true);
16901 fschmid 400
                                        tipText +="<br>" + tr("Y-Pos:") + " ";
401
                                        if (pgItem->OwnPage != -1)
20508 fschmid 402
                                                tipText += value2String(pgItem->yPos() - item->PageObject->yOffset(), pgItem->doc()->unitIndex(), true, true);
16901 fschmid 403
                                        else
20508 fschmid 404
                                                tipText += value2String(pgItem->yPos(), pgItem->doc()->unitIndex(), true, true);
16901 fschmid 405
                                        tipText += "</p>";
9598 fschmid 406
                                }
16899 fschmid 407
                                QToolTip::showText(helpEvent->globalPos(), tipText, this);
408
                                return true;
9598 fschmid 409
                        }
410
                }
411
        }
412
        return QTreeWidget::viewportEvent(event);
413
}
414
 
16579 fschmid 415
OutlinePalette::OutlinePalette( QWidget* parent) : ScDockPalette( parent, "Tree", 0)
3 paul 416
{
12378 fschmid 417
//      resize( 220, 240 );
265 Franz 418
        setMinimumSize( QSize( 220, 240 ) );
16579 fschmid 419
        setObjectName(QString::fromLocal8Bit("Tree"));
420
        setSizePolicy( QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
421
        containerWidget = new QWidget(this);
12378 fschmid 422
 
423
        filterEdit = new QLineEdit;
20270 craig 424
        filterEdit->setToolTip( tr("Enter a keyword or regular expression to filter the outline") );
16869 fschmid 425
//      QShortcut* filterShortcut = new QShortcut( QKeySequence( tr( "Ctrl+F", "Filter the Outline using a keyword" ) ), this );
12378 fschmid 426
        filterLabel = new QLabel( tr("Filter:") );
427
        filterLabel->setBuddy( filterEdit );
1448 cbradney 428
 
10862 cbradney 429
        reportDisplay = new OutlineWidget( this );
3 paul 430
 
12378 fschmid 431
//      reportDisplay->setGeometry( QRect( 0, 0, 220, 240 ) );
432
//      reportDisplay->setMinimumSize( QSize( 220, 240 ) );
1395 fschmid 433
        reportDisplay->setRootIsDecorated( true );
8708 fschmid 434
        reportDisplay->setColumnCount(1);
435
        reportDisplay->setHeaderLabel( tr("Element"));
18194 fschmid 436
        reportDisplay->header()->setSectionsClickable(false );
437
        reportDisplay->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
8708 fschmid 438
        reportDisplay->setSortingEnabled(false);
11264 fschmid 439
        reportDisplay->setSelectionMode(QAbstractItemView::ExtendedSelection);
9057 fschmid 440
        reportDisplay->setContextMenuPolicy(Qt::CustomContextMenu);
12378 fschmid 441
 
442
        QGridLayout* layout = new QGridLayout;
443
        layout->addWidget( filterLabel, 0, 0 );
444
        layout->addWidget( filterEdit, 0, 1 );
445
        layout->addWidget( reportDisplay, 1, 0, 1, 2 );
446
        layout->setContentsMargins( 3, 3, 3, 3);
16579 fschmid 447
        containerWidget->setLayout( layout );
448
        setWidget( containerWidget );
12378 fschmid 449
 
5646 cbradney 450
        unsetDoc();
20185 craig 451
        IconManager* im = IconManager::instance();
452
        imageIcon = im->loadPixmap("22/insert-image.png");
453
        latexIcon = im->loadPixmap("22/insert-latex.png");
454
        lineIcon = im->loadPixmap("Stift.xpm");
455
        textIcon = im->loadPixmap("22/insert-text-frame.png");
456
        polylineIcon = im->loadPixmap("22/draw-path.png");
457
        polygonIcon = im->loadPixmap("22/draw-polygon.png");
458
        tableIcon = im->loadPixmap("22/insert-table.png");
459
        groupIcon = im->loadPixmap("u_group.png");
460
        buttonIcon = im->loadPixmap("22/insert-button.png");
461
        radiobuttonIcon = im->loadPixmap("22/radiobutton.png");
462
        textFieldIcon = im->loadPixmap("22/text-field.png");
463
        checkBoxIcon = im->loadPixmap("22/checkbox.png");
464
        comboBoxIcon = im->loadPixmap("22/combobox.png");
465
        listBoxIcon = im->loadPixmap("22/list-box.png");
466
        annotTextIcon = im->loadPixmap("22/pdf-annotations.png");
467
        annotLinkIcon = im->loadPixmap("goto.png");
468
        annot3DIcon = im->loadPixmap("22/annot3d.png");
1427 fschmid 469
        selectionTriggered = false;
10211 jghali 470
        m_MainWindow  = NULL;
471
        freeObjects   = NULL;
472
        rootObject    = NULL;
473
        currentObject = NULL;
2194 cbradney 474
        languageChange();
265 Franz 475
        // signals and slots connections
9057 fschmid 476
        connect(reportDisplay, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(slotRightClick(QPoint)));
11264 fschmid 477
        connect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
478
        connect(reportDisplay, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotDoRename(QTreeWidgetItem*, int)));
12378 fschmid 479
        connect(filterEdit, SIGNAL(textChanged(const QString&)), this, SLOT(filterTree(const QString&)));
16869 fschmid 480
//      connect(filterShortcut, SIGNAL(activated()), filterEdit, SLOT(setFocus()));
16999 fschmid 481
        connect(reportDisplay, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(slotDoubleClick(QTreeWidgetItem*, int)));
3 paul 482
}
483
 
10862 cbradney 484
void OutlinePalette::setMainWindow(ScribusMainWindow *mw)
5287 cbradney 485
{
486
        m_MainWindow=mw;
487
        if (m_MainWindow==NULL)
488
                clearPalette();
489
}
490
 
10862 cbradney 491
void OutlinePalette::setDoc(ScribusDoc *newDoc)
3691 cbradney 492
{
5287 cbradney 493
        if (m_MainWindow==NULL)
494
                currDoc=NULL;
495
        else
496
                currDoc=newDoc;
3695 cbradney 497
        if (currDoc==NULL)
498
                clearPalette();
3691 cbradney 499
}
500
 
10862 cbradney 501
void OutlinePalette::unsetDoc()
3691 cbradney 502
{
503
        currDoc=NULL;
504
        clearPalette();
505
}
506
 
10862 cbradney 507
void OutlinePalette::setPaletteShown(bool visible)
8221 fschmid 508
{
16579 fschmid 509
        ScDockPalette::setPaletteShown(visible);
8221 fschmid 510
        if ((visible) && (currDoc != NULL))
511
                BuildTree();
512
}
513
 
10862 cbradney 514
void OutlinePalette::slotRightClick(QPoint point)
356 Franz 515
{
14754 jghali 516
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
9057 fschmid 517
                return;
518
        QTreeWidgetItem *ite = reportDisplay->itemAt(point);
8233 fschmid 519
        if (ite == NULL)
265 Franz 520
                return;
11264 fschmid 521
        if (!ite->isSelected())
522
                slotMultiSelect();
17909 fschmid 523
        if (currDoc->drawAsPreview)
524
                return;
10066 cbradney 525
        OutlineTreeItem *item = (OutlineTreeItem*)ite;
11405 cbradney 526
 
8233 fschmid 527
        if (item != NULL)
265 Franz 528
        {
8242 fschmid 529
                if ((item->type == 0) || (item->type == 2))
11405 cbradney 530
                        createContextMenu(NULL, point.x(), point.y());
531
                else if ((item->type == 1) || (item->type == 3) || (item->type == 4))
8241 fschmid 532
                {
11405 cbradney 533
                        PageItem *currItem = item->PageItemObject;
534
                        if (currItem!=NULL)
535
                        {
536
                                currentObject = ite;
537
                                createContextMenu(currItem, point.x(), point.y());
538
                        }
539
                }
16899 fschmid 540
                else if (item->type == 5)
541
                {
542
                        QMenu *pmenu = new QMenu();
543
                        QAction *actVis;
544
                        QAction *actPrint;
545
                        QAction *actLock;
546
                        if (item->DocObject->activeLayer() != item->LayerID)
547
                        {
548
                                QAction *actActive;
549
                                QSignalMapper *signalMapper = new QSignalMapper(this);
550
                                actActive = pmenu->addAction( tr("Active"));
551
                                actActive->setCheckable(true);
552
                                actActive->setChecked(false);
553
                                signalMapper->setMapping(actActive, item->LayerID);
554
                                connect(actActive, SIGNAL(triggered()), signalMapper, SLOT(map()));
555
                                connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(setActiveLayer(int)));
556
                        }
557
                        QSignalMapper *signalMapper2 = new QSignalMapper(this);
558
                        actVis = pmenu->addAction( tr("Visible"));
559
                        actVis->setCheckable(true);
560
                        actVis->setChecked(item->DocObject->layerVisible(item->LayerID));
561
                        signalMapper2->setMapping(actVis, item->LayerID);
562
                        connect(actVis, SIGNAL(triggered()), signalMapper2, SLOT(map()));
563
                        connect(signalMapper2, SIGNAL(mapped(int)), this, SLOT(setLayerVisible(int)));
564
 
565
                        QSignalMapper *signalMapper3 = new QSignalMapper(this);
566
                        actPrint = pmenu->addAction( tr("Printing"));
567
                        actPrint->setCheckable(true);
568
                        actPrint->setChecked(item->DocObject->layerPrintable(item->LayerID));
569
                        signalMapper3->setMapping(actPrint, item->LayerID);
570
                        connect(actPrint, SIGNAL(triggered()), signalMapper3, SLOT(map()));
571
                        connect(signalMapper3, SIGNAL(mapped(int)), this, SLOT(setLayerPrintable(int)));
572
 
573
                        QSignalMapper *signalMapper4 = new QSignalMapper(this);
574
                        actLock = pmenu->addAction( tr("Locked"));
575
                        actLock->setCheckable(true);
576
                        actLock->setChecked(item->DocObject->layerLocked(item->LayerID));
577
                        signalMapper4->setMapping(actLock, item->LayerID);
578
                        connect(actLock, SIGNAL(triggered()), signalMapper4, SLOT(map()));
579
                        connect(signalMapper4, SIGNAL(mapped(int)), this, SLOT(setLayerLocked(int)));
18181 fschmid 580
        //              qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
16899 fschmid 581
                        pmenu->exec(QCursor::pos());
582
                        delete pmenu;
583
                }
11405 cbradney 584
        }
265 Franz 585
}
586
 
16899 fschmid 587
void OutlinePalette::setActiveLayer(int layerID)
588
{
589
        currDoc->setActiveLayer(layerID);
590
        currDoc->scMW()->changeLayer(currDoc->activeLayer());
591
}
592
 
593
void OutlinePalette::setLayerVisible(int layerID)
594
{
595
        currDoc->setLayerVisible(layerID, !currDoc->layerVisible(layerID));
596
        currDoc->scMW()->showLayer();
597
        currDoc->scMW()->layerPalette->rebuildList();
18124 fschmid 598
        currDoc->scMW()->layerPalette->markActiveLayer();
16899 fschmid 599
}
600
 
601
void OutlinePalette::setLayerLocked(int layerID)
602
{
603
        currDoc->setLayerLocked(layerID, !currDoc->layerLocked(layerID));
604
        currDoc->scMW()->layerPalette->rebuildList();
18124 fschmid 605
        currDoc->scMW()->layerPalette->markActiveLayer();
16899 fschmid 606
}
607
 
608
void OutlinePalette::setLayerPrintable(int layerID)
609
{
610
        currDoc->setLayerPrintable(layerID, !currDoc->layerPrintable(layerID));
611
        currDoc->scMW()->layerPalette->rebuildList();
18124 fschmid 612
        currDoc->scMW()->layerPalette->markActiveLayer();
16899 fschmid 613
}
614
 
10862 cbradney 615
void OutlinePalette::slotRenameItem()
8241 fschmid 616
{
11264 fschmid 617
        activateWindow();
618
        reportDisplay->setFocus();
619
        reportDisplay->editItem(currentObject);
8241 fschmid 620
}
621
 
10862 cbradney 622
void OutlinePalette::slotDoRename(QTreeWidgetItem *ite , int col)
265 Franz 623
{
14754 jghali 624
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
265 Franz 625
                return;
11264 fschmid 626
        disconnect(reportDisplay, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotDoRename(QTreeWidgetItem*, int)));
10066 cbradney 627
        OutlineTreeItem *item = (OutlineTreeItem*)ite;
8233 fschmid 628
        if (item != NULL)
265 Franz 629
        {
8233 fschmid 630
                if ((item->type == 1) || (item->type == 3) || (item->type == 4))
265 Franz 631
                {
8233 fschmid 632
                        QString NameOld = item->PageItemObject->itemName();
633
                        QString NameNew = ite->text(col);
634
                        if (NameOld != NameNew)
265 Franz 635
                        {
8233 fschmid 636
                                if (NameNew == "")
637
                                        ite->setText(col, NameOld);
638
                                else
265 Franz 639
                                {
640
                                        bool found = false;
16156 fschmid 641
                                        QList<PageItem*> allItems;
642
                                        for (int a = 0; a < currDoc->Items->count(); ++a)
265 Franz 643
                                        {
16156 fschmid 644
                                                PageItem *currItem = currDoc->Items->at(a);
645
                                                if (currItem->isGroup())
646
                                                        allItems = currItem->getItemList();
647
                                                else
648
                                                        allItems.append(currItem);
649
                                                for (int ii = 0; ii < allItems.count(); ii++)
265 Franz 650
                                                {
16156 fschmid 651
                                                        PageItem* ite = allItems.at(ii);
652
                                                        if ((NameNew == ite->itemName()) && (ite != item->PageItemObject))
653
                                                        {
654
                                                                found = true;
655
                                                                break;
656
                                                        }
265 Franz 657
                                                }
16156 fschmid 658
                                                allItems.clear();
265 Franz 659
                                        }
660
                                        if (found)
661
                                        {
19605 jghali 662
                                                ScMessageBox::warning(this, CommonStrings::trWarning, "<qt>"+ tr("Name \"%1\" isn't unique.<br/>Please choose another.").arg(NameNew)+"</qt>");
265 Franz 663
                                                ite->setText(col, NameOld);
664
                                        }
665
                                        else
666
                                        {
8233 fschmid 667
                                                item->PageItemObject->setItemName(NameNew);
16546 jghali 668
                                                m_MainWindow->propertiesPalette->setCurrentItem(item->PageItemObject);
8233 fschmid 669
                                                currDoc->setModified(true);
265 Franz 670
                                        }
671
                                }
672
                        }
673
                }
12378 fschmid 674
                filterTree();
265 Franz 675
        }
11264 fschmid 676
        connect(reportDisplay, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotDoRename(QTreeWidgetItem*, int)));
265 Franz 677
}
678
 
16916 fschmid 679
QTreeWidgetItem* OutlinePalette::getListItem(int SNr, PageItem *Nr)
1427 fschmid 680
{
10066 cbradney 681
        OutlineTreeItem *item = 0;
8708 fschmid 682
        QTreeWidgetItem *retVal = 0;
3724 cbradney 683
        if (currDoc->masterPageMode())
1427 fschmid 684
        {
16916 fschmid 685
                if (Nr == NULL)
8217 fschmid 686
                {
8708 fschmid 687
                        QTreeWidgetItemIterator it( reportDisplay );
688
                        while ( (*it) )
8217 fschmid 689
                        {
10066 cbradney 690
                                item = (OutlineTreeItem*)(*it);
8217 fschmid 691
                                if ((item->type == 0) && (item->PageObject->pageNr() == SNr))
692
                                {
8708 fschmid 693
                                        retVal = (*it);
8217 fschmid 694
                                        break;
695
                                }
696
                                ++it;
697
                        }
698
                }
1427 fschmid 699
                else
700
                {
8708 fschmid 701
                        QTreeWidgetItemIterator it( reportDisplay );
702
                        while ( (*it) )
1427 fschmid 703
                        {
10066 cbradney 704
                                item = (OutlineTreeItem*)(*it);
16916 fschmid 705
                                if ((item->type == 1) && (item->PageItemObject == Nr))
4954 cbradney 706
                                {
8708 fschmid 707
                                        retVal = (*it);
8217 fschmid 708
                                        break;
4954 cbradney 709
                                }
8217 fschmid 710
                                ++it;
1427 fschmid 711
                        }
712
                }
713
        }
714
        else
715
        {
16916 fschmid 716
                if (Nr == NULL)
8217 fschmid 717
                {
8708 fschmid 718
                        QTreeWidgetItemIterator it( reportDisplay );
719
                        while ( (*it) )
8217 fschmid 720
                        {
10066 cbradney 721
                                item = (OutlineTreeItem*)(*it);
8217 fschmid 722
                                if ((item->type == 2) && (item->PageObject->pageNr() == SNr))
723
                                {
8708 fschmid 724
                                        retVal = (*it);
8217 fschmid 725
                                        break;
726
                                }
727
                                ++it;
728
                        }
729
                }
1427 fschmid 730
                else
731
                {
8708 fschmid 732
                        QTreeWidgetItemIterator it( reportDisplay );
733
                        while ( (*it) )
1427 fschmid 734
                        {
10066 cbradney 735
                                item = (OutlineTreeItem*)(*it);
16916 fschmid 736
                                if (((item->type == 3) || (item->type == 4)) && (item->PageItemObject == Nr))
3953 cbradney 737
                                {
8708 fschmid 738
                                        retVal = (*it);
8217 fschmid 739
                                        break;
3953 cbradney 740
                                }
8217 fschmid 741
                                ++it;
1427 fschmid 742
                        }
743
                }
744
        }
745
        return retVal;
746
}
747
 
16916 fschmid 748
void OutlinePalette::slotShowSelect(uint SNr, PageItem *Nr)
90 Franz 749
{
14754 jghali 750
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
173 Franz 751
                return;
3695 cbradney 752
        if (currDoc==NULL)
753
                return;
3691 cbradney 754
        if (currDoc->isLoading())
105 Franz 755
                return;
1427 fschmid 756
        if (selectionTriggered)
757
                return;
11264 fschmid 758
        disconnect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
1427 fschmid 759
        reportDisplay->clearSelection();
11264 fschmid 760
        if (currDoc->m_Selection->count() > 0)
761
        {
14405 jghali 762
                QList<QTreeWidgetItem*> itemSelection;
11264 fschmid 763
                uint docSelectionCount = currDoc->m_Selection->count();
764
                for (uint a = 0; a < docSelectionCount; a++)
765
                {
766
                        PageItem *item = currDoc->m_Selection->itemAt(a);
16916 fschmid 767
                        QTreeWidgetItem *retVal = getListItem(item->OwnPage, item);
17270 jghali 768
                        if (retVal != 0 && !retVal->isHidden())
14405 jghali 769
                                itemSelection.append(retVal);
11264 fschmid 770
                }
14405 jghali 771
                reportDisplay->selectItems(itemSelection);
11264 fschmid 772
        }
773
        else
774
        {
775
                QTreeWidgetItem *retVal = getListItem(SNr, Nr);
17270 jghali 776
                if (retVal != 0 && !retVal->isHidden())
11264 fschmid 777
                        retVal->setSelected(true);
778
        }
779
        QList<QTreeWidgetItem *> items = reportDisplay->selectedItems();
780
        if (items.count() > 0)
781
                reportDisplay->scrollToItem(items[0], QAbstractItemView::EnsureVisible);
782
        connect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
90 Franz 783
}
784
 
10862 cbradney 785
void OutlinePalette::setItemIcon(QTreeWidgetItem *item, PageItem *pgItem)
1427 fschmid 786
{
8240 fschmid 787
        switch (pgItem->itemType())
1427 fschmid 788
        {
1460 cbradney 789
        case PageItem::ImageFrame:
11264 fschmid 790
                if (pgItem->asLatexFrame())
791
                        item->setIcon( 0, latexIcon );
13839 fschmid 792
#ifdef HAVE_OSG
793
                else if (pgItem->asOSGFrame())
794
                        item->setIcon( 0, annot3DIcon );
795
#endif
11264 fschmid 796
                else
797
                        item->setIcon( 0, imageIcon );
1427 fschmid 798
                break;
1460 cbradney 799
        case PageItem::TextFrame:
8240 fschmid 800
                switch (pgItem->annotation().Type())
801
                {
17911 fschmid 802
                        case Annotation::Button:
8708 fschmid 803
                                item->setIcon( 0, buttonIcon );
8240 fschmid 804
                                break;
17952 fschmid 805
                        case Annotation::RadioButton:
806
                                item->setIcon( 0, radiobuttonIcon );
807
                                break;
17911 fschmid 808
                        case Annotation::Textfield:
8708 fschmid 809
                                item->setIcon( 0, textFieldIcon );
8240 fschmid 810
                                break;
17911 fschmid 811
                        case Annotation::Checkbox:
8708 fschmid 812
                                item->setIcon( 0, checkBoxIcon );
8240 fschmid 813
                                break;
17911 fschmid 814
                        case Annotation::Combobox:
8708 fschmid 815
                                item->setIcon( 0, comboBoxIcon );
8240 fschmid 816
                                break;
17911 fschmid 817
                        case Annotation::Listbox:
8708 fschmid 818
                                item->setIcon( 0, listBoxIcon );
8240 fschmid 819
                                break;
17911 fschmid 820
                        case Annotation::Text:
8708 fschmid 821
                                item->setIcon( 0, annotTextIcon );
8240 fschmid 822
                                break;
17911 fschmid 823
                        case Annotation::Link:
8708 fschmid 824
                                item->setIcon( 0, annotLinkIcon );
8240 fschmid 825
                                break;
826
                        default:
8708 fschmid 827
                                item->setIcon( 0, textIcon );
8240 fschmid 828
                                break;
829
                }
1427 fschmid 830
                break;
1460 cbradney 831
        case PageItem::Line:
8708 fschmid 832
                item->setIcon( 0, lineIcon );
1427 fschmid 833
                break;
16215 fschmid 834
        case PageItem::Arc:
1460 cbradney 835
        case PageItem::Polygon:
16191 fschmid 836
        case PageItem::RegularPolygon:
8708 fschmid 837
                item->setIcon( 0, polygonIcon );
1427 fschmid 838
                break;
1460 cbradney 839
        case PageItem::PolyLine:
16311 fschmid 840
        case PageItem::Spiral:
8708 fschmid 841
                item->setIcon( 0, polylineIcon );
1427 fschmid 842
                break;
1460 cbradney 843
        case PageItem::PathText:
8708 fschmid 844
                item->setIcon( 0, textIcon );
1427 fschmid 845
                break;
15060 fschmid 846
        case PageItem::Symbol:
847
                item->setIcon( 0, polygonIcon );
848
                break;
16899 fschmid 849
        case PageItem::Table:
850
                item->setIcon( 0, tableIcon );
851
                break;
1427 fschmid 852
        default:
853
                break;
854
        }
855
}
856
 
10862 cbradney 857
void OutlinePalette::reopenTree()
91 Franz 858
{
14754 jghali 859
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
173 Franz 860
                return;
8220 fschmid 861
        if (currDoc->OpenNodes.count() == 0)
91 Franz 862
                return;
10066 cbradney 863
        OutlineTreeItem *item = 0;
8708 fschmid 864
        QTreeWidgetItemIterator it( reportDisplay );
865
        while ( (*it) )
265 Franz 866
        {
10066 cbradney 867
                item = (OutlineTreeItem*)(*it);
8546 cbradney 868
                for (int olc = 0; olc < currDoc->OpenNodes.count(); olc++)
8220 fschmid 869
                {
870
                        if (item->type == currDoc->OpenNodes[olc].type)
871
                        {
872
                                if ((item->type == -3) || (item->type == -2))
8708 fschmid 873
                                        reportDisplay->expandItem((*it));
8220 fschmid 874
                                else if ((item->type == 0) || (item->type == 2))
875
                                {
876
                                        if (item->PageObject == currDoc->OpenNodes[olc].page)
8708 fschmid 877
                                                reportDisplay->expandItem((*it));
8220 fschmid 878
                                }
879
                                else if ((item->type == 2) || (item->type == 3) || (item->type == 4))
880
                                {
881
                                        if (item->PageItemObject == currDoc->OpenNodes[olc].item)
8708 fschmid 882
                                                reportDisplay->expandItem((*it));
8220 fschmid 883
                                }
884
                        }
885
                }
886
                ++it;
887
        }
91 Franz 888
}
889
 
10862 cbradney 890
void OutlinePalette::buildReopenVals()
91 Franz 891
{
8220 fschmid 892
        ScribusDoc::OpenNodesList ol;
8708 fschmid 893
        if (reportDisplay->model()->rowCount() == 0)
8220 fschmid 894
                return;
895
        currDoc->OpenNodes.clear();
10066 cbradney 896
        OutlineTreeItem *item = 0;
8708 fschmid 897
        QTreeWidgetItemIterator it( reportDisplay );
898
        while ( (*it) )
265 Franz 899
        {
10066 cbradney 900
                item = (OutlineTreeItem*)(*it);
8708 fschmid 901
                if (item->isExpanded())
8220 fschmid 902
                {
903
                        ol.type = item->type;
904
                        ol.page = item->PageObject;
905
                        ol.item = item->PageItemObject;
906
                        currDoc->OpenNodes.append(ol);
907
                }
908
                ++it;
909
        }
91 Franz 910
}
911
 
11264 fschmid 912
void OutlinePalette::slotMultiSelect()
913
{
14754 jghali 914
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
11264 fschmid 915
                return;
916
        if (currDoc==NULL)
917
                return;
918
        disconnect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
919
        selectionTriggered = true;
920
        QList<QTreeWidgetItem *> items = reportDisplay->selectedItems();
921
        if (items.count() != 1)
922
        {
21265 fschmid 923
                if (currDoc->drawAsPreview)
924
                        return;
11264 fschmid 925
                if (currDoc->appMode == modeEditClip)
926
                        currDoc->view()->requestMode(submodeEndNodeEdit);
11729 jghali 927
                currDoc->m_Selection->delaySignalsOn();
11264 fschmid 928
                currDoc->view()->Deselect(true);
929
                for (int a = 0; a < items.count(); a++)
930
                {
931
                        QTreeWidgetItem* ite = items[a];
932
                        OutlineTreeItem *item = (OutlineTreeItem*)ite;
933
                        PageItem *pgItem = NULL;
934
                        switch (item->type)
935
                        {
936
                                case 0:
937
                                case 1:
938
                                case 2:
16899 fschmid 939
                                case 5:
11264 fschmid 940
                                        ite->setSelected(false);
941
                                        break;
942
                                case 3:
943
                                case 4:
944
                                        pgItem = item->PageItemObject;
945
                                        if (!pgItem->isSelected())
946
                                        {
947
                                                m_MainWindow->closeActiveWindowMasterPageEditor();
16943 fschmid 948
                                                currDoc->view()->SelectItem(pgItem, false, false);
11264 fschmid 949
                                        }
950
                                        break;
16899 fschmid 951
                                default:
952
                                        break;
11264 fschmid 953
                        }
954
                }
11729 jghali 955
                currDoc->m_Selection->delaySignalsOff();
11264 fschmid 956
                currDoc->view()->DrawNew();
957
        }
958
        else
959
                slotSelect(items[0], 0);
960
        selectionTriggered = false;
961
        connect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
962
}
963
 
16999 fschmid 964
void OutlinePalette::slotSelect(QTreeWidgetItem* ite, int)
3 paul 965
{
14754 jghali 966
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
173 Franz 967
                return;
1427 fschmid 968
        selectionTriggered = true;
10066 cbradney 969
        OutlineTreeItem *item = (OutlineTreeItem*)ite;
8233 fschmid 970
        uint pg = 0;
971
        PageItem *pgItem = NULL;
8217 fschmid 972
        switch (item->type)
1395 fschmid 973
        {
8217 fschmid 974
                case 0:
975
                        emit selectMasterPage(item->PageObject->pageName());
976
                        break;
977
                case 1:
978
                        if (!currDoc->masterPageMode())
979
                                emit selectMasterPage(item->PageItemObject->OnMasterPage);
16328 fschmid 980
                        pgItem = item->PageItemObject;
18124 fschmid 981
                        currDoc->setActiveLayer(pgItem->LayerID);
982
                        m_MainWindow->changeLayer(currDoc->activeLayer());
16105 fschmid 983
                        if (item->PageItemObject->isGroup())
16156 fschmid 984
                                emit selectElementByItem(pgItem, false);
8217 fschmid 985
                        else
16156 fschmid 986
                                emit selectElementByItem(pgItem, true);
8217 fschmid 987
                        break;
988
                case 2:
21265 fschmid 989
                        if (currDoc->drawAsPreview)
990
                                return;
16740 fschmid 991
                        if (!currDoc->symbolEditMode())
992
                        {
993
                                pg = item->PageObject->pageNr();
994
                                m_MainWindow->closeActiveWindowMasterPageEditor();
995
                                emit selectPage(pg);
996
                        }
8217 fschmid 997
                        break;
998
                case 3:
999
                case 4:
21265 fschmid 1000
                        if (currDoc->drawAsPreview)
1001
                                return;
8233 fschmid 1002
                        pgItem = item->PageItemObject;
8217 fschmid 1003
                        m_MainWindow->closeActiveWindowMasterPageEditor();
18124 fschmid 1004
                        currDoc->setActiveLayer(pgItem->LayerID);
1005
                        m_MainWindow->changeLayer(currDoc->activeLayer());
16105 fschmid 1006
                        if (pgItem->isGroup())
16156 fschmid 1007
                                emit selectElementByItem(pgItem, false);
8217 fschmid 1008
                        else
16156 fschmid 1009
                                emit selectElementByItem(pgItem, true);
8217 fschmid 1010
                        break;
19072 fschmid 1011
                case 5:
21265 fschmid 1012
                        if (currDoc->drawAsPreview)
1013
                                return;
19072 fschmid 1014
                        currDoc->setActiveLayer(item->LayerID);
1015
                        m_MainWindow->changeLayer(currDoc->activeLayer());
1016
                        break;
8217 fschmid 1017
                default:
1018
                        break;
1395 fschmid 1019
        }
1427 fschmid 1020
        selectionTriggered = false;
3 paul 1021
}
16105 fschmid 1022
 
16999 fschmid 1023
void OutlinePalette::slotDoubleClick(QTreeWidgetItem* ite, int)
1024
{
1025
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
1026
                return;
1027
        OutlineTreeItem *item = (OutlineTreeItem*)ite;
1028
        PageItem *pgItem = NULL;
1029
        switch (item->type)
1030
        {
1031
                case 1:
1032
                        if (!currDoc->masterPageMode())
1033
                                emit selectMasterPage(item->PageItemObject->OnMasterPage);
1034
                        pgItem = item->PageItemObject;
1035
                        emit editElementByItem(pgItem);
1036
                        break;
1037
                case 3:
1038
                case 4:
21265 fschmid 1039
                        if (currDoc->drawAsPreview)
1040
                                return;
16999 fschmid 1041
                        pgItem = item->PageItemObject;
1042
                        m_MainWindow->closeActiveWindowMasterPageEditor();
1043
                        emit editElementByItem(pgItem);
1044
                        break;
1045
                default:
1046
                        break;
1047
        }
1048
}
1049
 
10862 cbradney 1050
void OutlinePalette::BuildTree(bool storeVals)
3 paul 1051
{
14754 jghali 1052
        if (!m_MainWindow || m_MainWindow->scriptIsRunning())
173 Franz 1053
                return;
3691 cbradney 1054
        if (currDoc==NULL)
1055
                return;
8233 fschmid 1056
        if (selectionTriggered)
1057
                return;
11264 fschmid 1058
        disconnect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
1059
        disconnect(reportDisplay, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotDoRename(QTreeWidgetItem*, int)));
8220 fschmid 1060
        setUpdatesEnabled(false);
1061
        if (storeVals)
1062
                buildReopenVals();
1063
        clearPalette();
10066 cbradney 1064
        OutlineTreeItem * item = new OutlineTreeItem( reportDisplay, 0 );
1491 fschmid 1065
        rootObject = item;
3691 cbradney 1066
        item->setText( 0, currDoc->DocName.section( '/', -1 ) );
8220 fschmid 1067
        item->type = -2;
16916 fschmid 1068
        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
10066 cbradney 1069
        OutlineTreeItem * pagep = 0;
1491 fschmid 1070
        freeObjects = 0;
1414 fschmid 1071
        PageItem* pgItem;
1072
        QString tmp;
17410 fschmid 1073
        if (currDoc->symbolEditMode() || currDoc->inlineEditMode())
1395 fschmid 1074
        {
10066 cbradney 1075
                OutlineTreeItem *page = new OutlineTreeItem( item, pagep );
16740 fschmid 1076
                page->PageObject = currDoc->Pages->at(0);
1077
                page->type = 2;
16916 fschmid 1078
                page->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
1395 fschmid 1079
                pagep = page;
16740 fschmid 1080
                for (int b = 0; b < currDoc->Items->count(); ++b)
1395 fschmid 1081
                {
16740 fschmid 1082
                        pgItem = currDoc->Items->at(b);
1083
                        if (!pgItem->isGroup())
1395 fschmid 1084
                        {
16740 fschmid 1085
                                OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1086
                                object->PageItemObject = pgItem;
16916 fschmid 1087
                                object->PageObject = currDoc->DocPages.at(0);
1088
                                object->DocObject = currDoc;
16740 fschmid 1089
                                object->type = 3;
1090
                                object->setText(0, pgItem->itemName());
1091
                                setItemIcon(object, pgItem);
16999 fschmid 1092
                                object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
1395 fschmid 1093
                        }
16740 fschmid 1094
                        else
1095
                        {
1096
                                OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1097
                                object->PageItemObject = pgItem;
16916 fschmid 1098
                                object->PageObject = currDoc->DocPages.at(0);
1099
                                object->DocObject = currDoc;
16740 fschmid 1100
                                object->type = 3;
1101
                                object->setText(0, pgItem->itemName());
1102
                                object->setIcon( 0, groupIcon );
16999 fschmid 1103
                                object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
16901 fschmid 1104
                                parseSubGroup(object, &pgItem->groupItemList, 3, currDoc->Pages->at(0));
16740 fschmid 1105
                        }
1395 fschmid 1106
                }
17410 fschmid 1107
                if (currDoc->symbolEditMode())
1108
                        page->setText(0, currDoc->getEditedSymbol());
1109
                else
1110
                        page->setText(0, tr("Inline Frame"));
1395 fschmid 1111
        }
16740 fschmid 1112
        else
1395 fschmid 1113
        {
16740 fschmid 1114
                for (int a = 0; a < static_cast<int>(currDoc->MasterPages.count()); ++a)
1395 fschmid 1115
                {
16740 fschmid 1116
                        OutlineTreeItem *page = new OutlineTreeItem( item, pagep );
1117
                        page->PageObject = currDoc->MasterPages.at(a);
1118
                        page->type = 0;
16916 fschmid 1119
                        page->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16740 fschmid 1120
                        QString pageNam = currDoc->MasterPages.at(a)->pageName();
1121
                        pagep = page;
1122
                        for (int b = 0; b < currDoc->MasterItems.count(); ++b)
1395 fschmid 1123
                        {
16740 fschmid 1124
                                pgItem = currDoc->MasterItems.at(b);
1125
                                if (((pgItem->OwnPage == a) || (pgItem->OnMasterPage == pageNam)))
1414 fschmid 1126
                                {
16740 fschmid 1127
                                        if (!pgItem->isGroup())
1128
                                        {
1129
                                                OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1130
                                                object->PageItemObject = pgItem;
16916 fschmid 1131
                                                object->PageObject = currDoc->MasterPages.at(a);
1132
                                                object->DocObject = currDoc;
16740 fschmid 1133
                                                object->type = 1;
1134
                                                object->setText(0, pgItem->itemName());
1135
                                                setItemIcon(object, pgItem);
16999 fschmid 1136
                                                object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16740 fschmid 1137
                                        }
1138
                                        else
1139
                                        {
1140
                                                OutlineTreeItem * object = new OutlineTreeItem( page, 0 );
1141
                                                object->PageItemObject = pgItem;
16916 fschmid 1142
                                                object->PageObject = currDoc->MasterPages.at(a);
1143
                                                object->DocObject = currDoc;
16740 fschmid 1144
                                                object->type = 1;
1145
                                                object->setText(0, pgItem->itemName());
1146
                                                object->setIcon( 0, groupIcon );
16999 fschmid 1147
                                                object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16901 fschmid 1148
                                                parseSubGroup(object, &pgItem->groupItemList, 1, currDoc->MasterPages.at(a));
16740 fschmid 1149
                                        }
1414 fschmid 1150
                                }
16740 fschmid 1151
                        }
1152
                        page->setText(0, currDoc->MasterPages.at(a)->pageName());
1153
                }
16899 fschmid 1154
                bool hasfreeItems = false;
16740 fschmid 1155
                for (int a = 0; a < static_cast<int>(currDoc->DocPages.count()); ++a)
1156
                {
1157
                        OutlineTreeItem *page = new OutlineTreeItem( item, pagep );
1158
                        page->PageObject = currDoc->DocPages.at(a);
1159
                        page->type = 2;
16916 fschmid 1160
                        page->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
16740 fschmid 1161
                        pagep = page;
16899 fschmid 1162
                        int layerCount = currDoc->layerCount();
1163
                        if (layerCount > 1)
16740 fschmid 1164
                        {
16899 fschmid 1165
                                QList<PageItem*> pgItems;
1166
                                for (int b = 0; b < currDoc->DocItems.count(); ++b)
1414 fschmid 1167
                                {
16899 fschmid 1168
                                        pgItem = currDoc->DocItems.at(b);
1169
                                        if (pgItem->OwnPage == -1)
1170
                                                hasfreeItems = true;
1171
                                        if (pgItem->OwnPage == a)
1172
                                                pgItems.append(pgItem);
1173
                                }
1174
                                ScLayer layer;
1175
                                layer.ID = 0;
1176
                                for (int layerLevel = 0; layerLevel < layerCount; ++layerLevel)
1177
                                {
1178
                                        currDoc->Layers.levelToLayer(layer, layerLevel);
1179
                                        OutlineTreeItem *ObjLayer = new OutlineTreeItem( page, 0 );
1180
                                        ObjLayer->type = 5;
1181
                                        ObjLayer->LayerID = layer.ID;
1182
                                        ObjLayer->DocObject = currDoc;
16916 fschmid 1183
                                        ObjLayer->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
16899 fschmid 1184
                                        ObjLayer->setText(0, tr("Layer: \"") + layer.Name + "\"");
1185
                                        for (int it = 0; it < pgItems.count(); ++it)
16740 fschmid 1186
                                        {
16899 fschmid 1187
                                                pgItem = pgItems.at(it);
1188
                                                if (pgItem->LayerID != layer.ID)
1189
                                                        continue;
1190
                                                if (!pgItem->isGroup())
1191
                                                {
1192
                                                        OutlineTreeItem *object = new OutlineTreeItem( ObjLayer, 0 );
1193
                                                        object->PageItemObject = pgItem;
16901 fschmid 1194
                                                        object->PageObject = currDoc->DocPages.at(a);
1195
                                                        object->DocObject = currDoc;
16899 fschmid 1196
                                                        object->type = 3;
1197
                                                        object->setText(0, pgItem->itemName());
1198
                                                        setItemIcon(object, pgItem);
16999 fschmid 1199
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
16899 fschmid 1200
                                                }
1201
                                                else
1202
                                                {
1203
                                                        OutlineTreeItem *object = new OutlineTreeItem( ObjLayer, 0 );
1204
                                                        object->PageItemObject = pgItem;
16901 fschmid 1205
                                                        object->PageObject = currDoc->DocPages.at(a);
1206
                                                        object->DocObject = currDoc;
16899 fschmid 1207
                                                        object->type = 3;
1208
                                                        object->setText(0, pgItem->itemName());
1209
                                                        object->setIcon( 0, groupIcon );
16999 fschmid 1210
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
16901 fschmid 1211
                                                        parseSubGroup(object, &pgItem->groupItemList, 3, currDoc->DocPages.at(a));
16899 fschmid 1212
                                                }
16740 fschmid 1213
                                        }
16899 fschmid 1214
                                }
1215
                        }
1216
                        else
1217
                        {
1218
                                for (int b = 0; b < currDoc->DocItems.count(); ++b)
1219
                                {
1220
                                        pgItem = currDoc->DocItems.at(b);
1221
                                        if (pgItem->OwnPage == -1)
1222
                                                hasfreeItems = true;
1223
                                        if (pgItem->OwnPage == a)
16740 fschmid 1224
                                        {
16899 fschmid 1225
                                                if (!pgItem->isGroup())
1226
                                                {
1227
                                                        OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1228
                                                        object->PageItemObject = pgItem;
16901 fschmid 1229
                                                        object->PageObject = currDoc->DocPages.at(a);
1230
                                                        object->DocObject = currDoc;
16899 fschmid 1231
                                                        object->type = 3;
1232
                                                        object->setText(0, pgItem->itemName());
1233
                                                        setItemIcon(object, pgItem);
16999 fschmid 1234
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
16899 fschmid 1235
                                                }
1236
                                                else
1237
                                                {
1238
                                                        OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1239
                                                        object->PageItemObject = pgItem;
16901 fschmid 1240
                                                        object->PageObject = currDoc->DocPages.at(a);
1241
                                                        object->DocObject = currDoc;
16899 fschmid 1242
                                                        object->type = 3;
1243
                                                        object->setText(0, pgItem->itemName());
1244
                                                        object->setIcon( 0, groupIcon );
16999 fschmid 1245
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
16901 fschmid 1246
                                                        parseSubGroup(object, &pgItem->groupItemList, 3, currDoc->DocPages.at(a));
16899 fschmid 1247
                                                }
16740 fschmid 1248
                                        }
1414 fschmid 1249
                                }
1395 fschmid 1250
                        }
16740 fschmid 1251
                        page->setText(0, tr("Page ")+tmp.setNum(a+1));
1395 fschmid 1252
                }
16740 fschmid 1253
                if (hasfreeItems)
1395 fschmid 1254
                {
16740 fschmid 1255
                        OutlineTreeItem *page = new OutlineTreeItem( item, pagep );
1256
                        pagep = page;
1257
                        freeObjects = page;
1258
                        page->type = -3;
16916 fschmid 1259
                        page->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16899 fschmid 1260
                        int layerCount = currDoc->layerCount();
1261
                        if (layerCount > 1)
1395 fschmid 1262
                        {
16899 fschmid 1263
                                QList<PageItem*> pgItems;
1264
                                for (int b = 0; b < currDoc->DocItems.count(); ++b)
1414 fschmid 1265
                                {
16899 fschmid 1266
                                        pgItem = currDoc->DocItems.at(b);
1267
                                        if (pgItem->OwnPage == -1)
1268
                                                pgItems.append(pgItem);
1269
                                }
1270
                                ScLayer layer;
1271
                                layer.ID = 0;
1272
                                for (int layerLevel = 0; layerLevel < layerCount; ++layerLevel)
1273
                                {
1274
                                        currDoc->Layers.levelToLayer(layer, layerLevel);
1275
                                        OutlineTreeItem *ObjLayer = new OutlineTreeItem( page, 0 );
1276
                                        ObjLayer->type = 5;
1277
                                        ObjLayer->LayerID = layer.ID;
1278
                                        ObjLayer->DocObject = currDoc;
16916 fschmid 1279
                                        ObjLayer->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16899 fschmid 1280
                                        ObjLayer->setText(0, tr("Layer: \"") + layer.Name + "\"");
1281
                                        for (int it = 0; it < pgItems.count(); ++it)
16740 fschmid 1282
                                        {
16899 fschmid 1283
                                                pgItem = pgItems.at(it);
1284
                                                if (pgItem->LayerID != layer.ID)
1285
                                                        continue;
1286
                                                if (!pgItem->isGroup())
1287
                                                {
1288
                                                        OutlineTreeItem *object = new OutlineTreeItem( ObjLayer, 0 );
1289
                                                        object->PageItemObject = pgItem;
16901 fschmid 1290
                                                        object->PageObject = NULL;
1291
                                                        object->DocObject = currDoc;
16916 fschmid 1292
                                                        object->type = 4;
16899 fschmid 1293
                                                        object->setText(0, pgItem->itemName());
1294
                                                        setItemIcon(object, pgItem);
16999 fschmid 1295
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16899 fschmid 1296
                                                }
1297
                                                else
1298
                                                {
1299
                                                        OutlineTreeItem *object = new OutlineTreeItem( ObjLayer, 0 );
1300
                                                        object->PageItemObject = pgItem;
16901 fschmid 1301
                                                        object->PageObject = NULL;
1302
                                                        object->DocObject = currDoc;
16916 fschmid 1303
                                                        object->type = 4;
16899 fschmid 1304
                                                        object->setText(0, pgItem->itemName());
1305
                                                        object->setIcon( 0, groupIcon );
16999 fschmid 1306
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16901 fschmid 1307
                                                        parseSubGroup(object, &pgItem->groupItemList, 4, NULL);
16899 fschmid 1308
                                                }
16740 fschmid 1309
                                        }
16899 fschmid 1310
                                }
1311
                        }
1312
                        else
1313
                        {
1314
                                for (int b = 0; b < currDoc->DocItems.count(); ++b)
1315
                                {
1316
                                        pgItem = currDoc->DocItems.at(b);
1317
                                        if (pgItem->OwnPage == -1)
16740 fschmid 1318
                                        {
16899 fschmid 1319
                                                if (!pgItem->isGroup())
1320
                                                {
1321
                                                        OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1322
                                                        object->PageItemObject = pgItem;
16901 fschmid 1323
                                                        object->PageObject = NULL;
1324
                                                        object->DocObject = currDoc;
16899 fschmid 1325
                                                        object->type = 4;
1326
                                                        object->setText(0, pgItem->itemName());
1327
                                                        setItemIcon(object, pgItem);
16999 fschmid 1328
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16899 fschmid 1329
                                                }
1330
                                                else
1331
                                                {
1332
                                                        OutlineTreeItem *object = new OutlineTreeItem( page, 0 );
1333
                                                        object->PageItemObject = pgItem;
16901 fschmid 1334
                                                        object->PageObject = NULL;
1335
                                                        object->DocObject = currDoc;
16899 fschmid 1336
                                                        object->type = 4;
1337
                                                        object->setText(0, pgItem->itemName());
1338
                                                        object->setIcon( 0, groupIcon );
16999 fschmid 1339
                                                        object->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16901 fschmid 1340
                                                        parseSubGroup(object, &pgItem->groupItemList, 4, NULL);
16899 fschmid 1341
                                                }
16740 fschmid 1342
                                        }
1414 fschmid 1343
                                }
1395 fschmid 1344
                        }
16740 fschmid 1345
                        page->setText(0, tr("Free Objects"));
1395 fschmid 1346
                }
1347
        }
8220 fschmid 1348
        if (storeVals)
1349
                reopenTree();
16916 fschmid 1350
        reportDisplay->invisibleRootItem()->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
8220 fschmid 1351
        setUpdatesEnabled(true);
17270 jghali 1352
        filterTree();
11264 fschmid 1353
        if (currDoc->m_Selection->count() > 0)
16916 fschmid 1354
                slotShowSelect(0, NULL);
21375 jghali 1355
        update();
11264 fschmid 1356
        connect(reportDisplay, SIGNAL(itemSelectionChanged()), this, SLOT(slotMultiSelect()));
1357
        connect(reportDisplay, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(slotDoRename(QTreeWidgetItem*, int)));
1414 fschmid 1358
}
1359
 
12378 fschmid 1360
void OutlinePalette::filterTree(const QString& keyword)
1361
{
1362
        OutlineTreeItem *item = NULL;
1363
        QTreeWidgetItemIterator it( reportDisplay );
1364
        while ( (*it) )
1365
        {
1366
                item = dynamic_cast<OutlineTreeItem*>(*it);
1367
                if (item != NULL)
1368
                {
1369
                        if ((item->type == 1) || (item->type == 3) || (item->type == 4))
1370
                        {
12501 jghali 1371
                                if (item->PageItemObject->itemName().contains(QRegExp(keyword, Qt::CaseInsensitive)))
12378 fschmid 1372
                                        item->setHidden(false);
1373
                                else
1374
                                        item->setHidden(true);
1375
                        }
1376
                        else
1377
                                item->setHidden(false);
1378
                }
1379
                ++it;
1380
        }
1381
}
1382
 
1383
void OutlinePalette::filterTree()
1384
{
1385
        if ( !filterEdit->text().isEmpty() )
1386
                filterTree( filterEdit->text() );
1387
}
1388
 
16901 fschmid 1389
void OutlinePalette::parseSubGroup(OutlineTreeItem* object, QList<PageItem*> *subGroupList, int itemType, ScPage *a)
1414 fschmid 1390
{
1391
        PageItem *pgItem;
8708 fschmid 1392
        for (int b = 0; b < subGroupList->count(); ++b)
1414 fschmid 1393
        {
1394
                pgItem = subGroupList->at(b);
16105 fschmid 1395
                if (!pgItem->isGroup())
1414 fschmid 1396
                {
16105 fschmid 1397
                        OutlineTreeItem *grp = new OutlineTreeItem( object, 0 );
1398
                        grp->PageItemObject = pgItem;
16901 fschmid 1399
                        grp->PageObject = a;
1400
                        grp->DocObject = currDoc;
16105 fschmid 1401
                        grp->type = itemType;
1402
                        grp->setText(0, pgItem->itemName());
1403
                        setItemIcon(grp, pgItem);
16987 fschmid 1404
                        if (itemType == 3)
16999 fschmid 1405
                                grp->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
16987 fschmid 1406
                        else
16999 fschmid 1407
                                grp->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
1414 fschmid 1408
                }
16105 fschmid 1409
                else
1410
                {
1411
                        OutlineTreeItem *grp = new OutlineTreeItem( object, 0 );
1412
                        grp->PageItemObject = pgItem;
16901 fschmid 1413
                        grp->PageObject = a;
1414
                        grp->DocObject = currDoc;
16105 fschmid 1415
                        grp->type = itemType;
1416
                        grp->setText(0, pgItem->itemName());
1417
                        grp->setIcon( 0, groupIcon );
16987 fschmid 1418
                        if (itemType == 3)
16999 fschmid 1419
                                grp->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
16987 fschmid 1420
                        else
16999 fschmid 1421
                                grp->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
16901 fschmid 1422
                        parseSubGroup(grp, &pgItem->groupItemList, itemType, a);
16105 fschmid 1423
                }
1414 fschmid 1424
        }
1425
}
1426
 
10862 cbradney 1427
void OutlinePalette::changeEvent(QEvent *e)
10859 cbradney 1428
{
1429
        if (e->type() == QEvent::LanguageChange)
1430
                languageChange();
10903 cbradney 1431
        else
16579 fschmid 1432
                ScDockPalette::changeEvent(e);
10859 cbradney 1433
}
1434
 
10862 cbradney 1435
void OutlinePalette::languageChange()
2194 cbradney 1436
{
10495 cbradney 1437
        setWindowTitle( tr("Outline"));
8708 fschmid 1438
        reportDisplay->setHeaderLabel( tr("Element"));
12378 fschmid 1439
        filterLabel->setText( tr("Filter:") );
2355 cbradney 1440
}
3691 cbradney 1441
 
10862 cbradney 1442
void OutlinePalette::clearPalette()
3691 cbradney 1443
{
1444
        reportDisplay->clear();
1445
}
11405 cbradney 1446
 
1447
void OutlinePalette::createContextMenu(PageItem * currItem, double mx, double my)
1448
{
1449
        if (m_MainWindow==NULL || currDoc==NULL)
1450
                return;
1451
        ContextMenu* cmen=NULL;
18181 fschmid 1452
//      qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
11405 cbradney 1453
        if(currItem!=NULL)
1454
                cmen = new ContextMenu(*(currDoc->m_Selection), m_MainWindow, currDoc);
1455
        else
15041 fschmid 1456
                cmen = new ContextMenu(m_MainWindow, currDoc, currDoc->currentPage()->xOffset(), currDoc->currentPage()->yOffset());
11405 cbradney 1457
        if (cmen)
1458
                cmen->exec(QCursor::pos());
1459
        delete cmen;
1460
}