Subversion Repositories Scribus

Rev

Rev 5646 | Rev 7400 | 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
*/
3 paul 7
#include "tree.h"
8
#include "tree.moc"
9
#include <qheader.h>
10
#include <qlistview.h>
11
#include <qlayout.h>
12
#include <qvariant.h>
13
#include <qtooltip.h>
14
#include <qimage.h>
15
#include <qpixmap.h>
265 Franz 16
#include <qmessagebox.h>
1460 cbradney 17
 
2952 cbradney 18
#include "commonstrings.h"
3670 cbradney 19
#include "page.h"
173 Franz 20
#include "scribus.h"
1460 cbradney 21
 
3 paul 22
extern QPixmap loadIcon(QString nam);
23
 
5287 cbradney 24
Tree::Tree( QWidget* parent) : ScrPaletteBase( parent, "Tree", false, 0 )
3 paul 25
{
1448 cbradney 26
        resize( 220, 240 );
265 Franz 27
        setMinimumSize( QSize( 220, 240 ) );
28
        setMaximumSize( QSize( 800, 600 ) );
1448 cbradney 29
        setIcon(loadIcon("AppIcon.png"));
30
 
1395 fschmid 31
        reportDisplay = new QListView( this, "ListView1" );
3 paul 32
 
1395 fschmid 33
        reportDisplay->setGeometry( QRect( 0, 0, 220, 240 ) );
34
        reportDisplay->setMinimumSize( QSize( 220, 240 ) );
35
        reportDisplay->setRootIsDecorated( true );
2194 cbradney 36
        idElemCol=reportDisplay->addColumn("Element"); //Use width from initial untranslated string, translation is set with languageChange()
1395 fschmid 37
        reportDisplay->header()->setClickEnabled( false, reportDisplay->header()->count() - 1 );
38
        reportDisplay->header()->setResizeEnabled( false, reportDisplay->header()->count() - 1 );
1491 fschmid 39
        reportDisplay->setSorting(-1);
1427 fschmid 40
/*      reportDisplay->addColumn( tr("Type"));
1395 fschmid 41
        reportDisplay->header()->setClickEnabled( false, reportDisplay->header()->count() - 1 );
42
        reportDisplay->header()->setResizeEnabled( false, reportDisplay->header()->count() - 1 );
43
        reportDisplay->addColumn( tr("Information"));
44
        reportDisplay->header()->setClickEnabled( false, reportDisplay->header()->count() - 1 );
45
        reportDisplay->header()->setResizeEnabled( false, reportDisplay->header()->count() - 1 );
46
        reportDisplay->setSorting(-1);
1427 fschmid 47
        reportDisplay->setSelectionMode(QListView::Single); */
1395 fschmid 48
//      reportDisplay->setDefaultRenameAction(QListView::Accept);
5646 cbradney 49
        unsetDoc();
1427 fschmid 50
        imageIcon = loadIcon("Bild.xpm");
51
        lineIcon = loadIcon("Stift.xpm");
52
        textIcon = loadIcon("Text.xpm");
53
        polylineIcon = loadIcon("beziertool.png");
54
        polygonIcon = loadIcon("spline.png");
55
        groupIcon = loadIcon("u_group.png");
56
        selectionTriggered = false;
1491 fschmid 57
        freeObjects = 0;
2194 cbradney 58
        languageChange();
265 Franz 59
        // signals and slots connections
1395 fschmid 60
        connect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
1427 fschmid 61
//      connect(reportDisplay, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int)));
62
//      connect(reportDisplay, SIGNAL(rightButtonClicked(QListViewItem *, const QPoint &, int)), this, SLOT(slotRightClick(QListViewItem*, const QPoint &, int)));
3 paul 63
}
64
 
5287 cbradney 65
 
66
void Tree::setMainWindow(ScribusMainWindow *mw)
67
{
68
        m_MainWindow=mw;
69
        if (m_MainWindow==NULL)
70
                clearPalette();
71
}
72
 
3691 cbradney 73
void Tree::setDoc(ScribusDoc *newDoc)
74
{
5287 cbradney 75
        if (m_MainWindow==NULL)
76
                currDoc=NULL;
77
        else
78
                currDoc=newDoc;
3695 cbradney 79
        if (currDoc==NULL)
80
                clearPalette();
3691 cbradney 81
}
82
 
83
void Tree::unsetDoc()
84
{
85
        currDoc=NULL;
86
        clearPalette();
87
}
88
 
1525 cbradney 89
/*void Tree::keyPressEvent(QKeyEvent *k)
356 Franz 90
{
1448 cbradney 91
        QDialog::keyPressEvent(k);
356 Franz 92
}
1525 cbradney 93
*/
3240 fschmid 94
void Tree::slotRightClick(QListViewItem* , const QPoint &, int)
265 Franz 95
{
1395 fschmid 96
/*      if (ite == NULL)
265 Franz 97
                return;
5287 cbradney 98
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
265 Franz 99
                return;
2093 cbradney 100
        if (vie->Doc->masterPageMode)
265 Franz 101
                return;
102
        if (Seiten.containsRef(ite))
103
                return;
104
        for (uint e = 0; e < PageObj.count(); ++e)
105
        {
106
                if (PageObj.at(e)->Elemente.containsRef(ite))
107
                {
108
                        ite->startRename(0);
109
                        break;
110
                }
1395 fschmid 111
        } */
265 Franz 112
}
113
 
3240 fschmid 114
void Tree::slotDoRename(QListViewItem* , int )
265 Franz 115
{
5287 cbradney 116
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
265 Franz 117
                return;
2093 cbradney 118
        if (vie->Doc->masterPageMode)
265 Franz 119
                return;
120
        disconnect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int)));
121
        int sref, oref;
122
        for (uint e = 0; e < PageObj.count(); ++e)
123
        {
124
                if (PageObj.at(e)->Elemente.containsRef(ite))
125
                {
126
                        oref = PageObj.at(e)->Elemente.findRef(ite);
127
                        if (oref != -1)
128
                        {
129
                                sref = Seiten.findRef(ite->parent());
130
                                if (sref != -1)
131
                                {
132
                                        QString NameOld = vie->Pages.at(sref)->Items.at(oref)->AnName;
133
                                        QString NameNew = ite->text(col);
268 Franz 134
                                        if (NameOld == NameNew)
135
                                                break;
269 Franz 136
                                        if (NameNew == "")
137
                                        {
138
                                                ite->setText(col, NameOld);
139
                                                break;
140
                                        }
265 Franz 141
                                        bool found = false;
142
                                        for (uint a = 0; a < vie->Pages.count(); ++a)
143
                                        {
144
                                                for (uint b = 0; b < vie->Pages.at(a)->Items.count(); ++b)
145
                                                {
146
                                                        if (NameNew == vie->Pages.at(a)->Items.at(b)->AnName)
147
                                                        {
148
                                                                found = true;
149
                                                                break;
150
                                                        }
151
                                                }
152
                                                if (found)
153
                                                        break;
154
                                        }
155
                                        if (found)
156
                                        {
3510 cbradney 157
                                                QMessageBox::warning(this, CommonStrings::trWarning, tr("Name \"%1\" isn't unique.\nPlease choose another.").arg(NameNew), CommonStrings::tr_OK);
265 Franz 158
                                                ite->setText(col, NameOld);
159
                                        }
160
                                        else
161
                                        {
162
                                                vie->Pages.at(sref)->Items.at(oref)->AnName = NameNew;
163
                                                vie->Pages.at(sref)->Items.at(oref)->AutoName = false;
5287 cbradney 164
                                                m_MainWindow->slotDocCh(false);
165
                                                m_MainWindow->HaveNewSel(vie->Pages.at(sref)->Items.at(oref)->PType);
265 Franz 166
                                                break;
167
                                        }
168
                                }
169
                        }
170
                }
171
        }
456 fschmid 172
        connect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int))); */
265 Franz 173
}
174
 
1427 fschmid 175
QListViewItem* Tree::getListItem(uint SNr, int Nr)
176
{
177
        QListViewItem *retVal = 0;
3724 cbradney 178
        if (currDoc->masterPageMode())
1427 fschmid 179
        {
180
                if (Nr == -1)
5685 cbradney 181
                        retVal = masterPageMapRev[currDoc->MasterPages.at(SNr)->pageName()];
1427 fschmid 182
                else
183
                {
4954 cbradney 184
                        if (currDoc->MasterItems.at(Nr)!=0)
1427 fschmid 185
                        {
4954 cbradney 186
                                if (currDoc->MasterItems.at(Nr)->Groups.count() == 0)
2093 cbradney 187
                                        retVal = masterPageItemMapRev[Nr];
1427 fschmid 188
                                else
4954 cbradney 189
                                {
190
                                        if (currDoc->MasterItems.at(Nr)->isSingleSel)
191
                                                retVal = masterPageItemMapRev[Nr];
192
                                        else
193
                                                retVal = masterPageGroupMapRev[Nr];
194
                                }
1427 fschmid 195
                        }
4954 cbradney 196
                        else
197
                                retVal = pageMapRev[SNr];
1427 fschmid 198
                }
199
        }
200
        else
201
        {
202
                if (Nr == -1)
203
                        retVal = pageMapRev[SNr];
204
                else
205
                {
3953 cbradney 206
                        //CB watch for these assert messages, we sometimes get here when we shouldnt.
207
                        Q_ASSERT(currDoc->DocItems.at(Nr)!=0);
208
                        if (currDoc->DocItems.at(Nr)==0)
209
                                retVal = pageMapRev[SNr];
1427 fschmid 210
                        else
211
                        {
3953 cbradney 212
                                if (currDoc->DocItems.at(Nr)->Groups.count() == 0)
1427 fschmid 213
                                        retVal = itemMapRev[Nr];
214
                                else
3953 cbradney 215
                                {
216
                                        if (currDoc->DocItems.at(Nr)->isSingleSel)
217
                                                retVal = itemMapRev[Nr];
218
                                        else
219
                                                retVal = groupMapRev[Nr];
220
                                }
1427 fschmid 221
                        }
222
                }
223
        }
224
        return retVal;
225
}
226
 
90 Franz 227
void Tree::slotShowSelect(uint SNr, int Nr)
228
{
5287 cbradney 229
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 230
                return;
3695 cbradney 231
        if (currDoc==NULL)
232
                return;
3691 cbradney 233
        if (currDoc->isLoading())
105 Franz 234
                return;
1427 fschmid 235
        if (selectionTriggered)
236
                return;
237
        disconnect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
238
        reportDisplay->clearSelection();
239
        reportDisplay->setSelected(getListItem(SNr, Nr), true);
240
        connect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
90 Franz 241
}
242
 
3240 fschmid 243
void Tree::slotRemoveElement(uint , uint )
88 Franz 244
{
5287 cbradney 245
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 246
                return;
2093 cbradney 247
        if ((vie->Doc->masterPageMode) || (vie->Doc->loading))
119 Franz 248
                return;
88 Franz 249
        if (PageObj.count() != 0)
265 Franz 250
        {
251
                if (PageObj.at(SNr)->Elemente.count() != 0)
88 Franz 252
                {
253
                        delete PageObj.at(SNr)->Elemente.at(Nr);
254
                        PageObj.at(SNr)->Elemente.take(Nr);
255
                }
1395 fschmid 256
        } */
88 Franz 257
}
3 paul 258
 
88 Franz 259
void Tree::slotUpdateElement(uint SNr, uint Nr)
260
{
5287 cbradney 261
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 262
                return;
1427 fschmid 263
        QListViewItem *item = getListItem(SNr, Nr);
1471 tsoots 264
        if (!item)
265
        {
266
                qDebug("Tree::slotUpdateElement(%i,%i): NULL item from getListItem(...)",SNr,Nr);
267
                return;
268
        }
1427 fschmid 269
        PageItem* pgItem;
3724 cbradney 270
        if (currDoc->masterPageMode())
3691 cbradney 271
                pgItem = currDoc->MasterItems.at(Nr);
1427 fschmid 272
        else
3691 cbradney 273
                pgItem = currDoc->DocItems.at(Nr);
1427 fschmid 274
        if ((pgItem->Groups.count() != 0) && (!pgItem->isSingleSel))
275
                return;
1460 cbradney 276
        setItemIcon(item, pgItem->itemType());
1427 fschmid 277
/*      QString cc, xp, yp, fon, GroupTxt;
2093 cbradney 278
        if ((vie->Doc->masterPageMode) || (vie->Doc->loading))
97 Franz 279
                return;
91 Franz 280
        if (SNr > Seiten.count()-1)
281
                return;
282
        if ( Nr > PageObj.at(SNr)->Elemente.count()-1)
283
                return;
265 Franz 284
        disconnect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int)));
295 Franz 285
        disconnect(ListView1, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
1395 fschmid 286
        PageObj.at(SNr)->Elemente.at(Nr)->setText(0, vie->Pages.at(SNr)->Items.at(Nr)->AnName);
88 Franz 287
        xp = tr("X:")+" "+cc.setNum(vie->Pages.at(SNr)->Items.at(Nr)->Xpos);
288
        yp = tr("Y:")+" "+cc.setNum(vie->Pages.at(SNr)->Items.at(Nr)->Ypos);
265 Franz 289
        fon = tr("Font:")+" "+vie->Pages.at(SNr)->Items.at(Nr)->IFont;
291 Franz 290
        if (vie->Pages.at(SNr)->Items.at(Nr)->Groups.count() != 0)
291
        {
292
                GroupTxt = tr("Group ")+cc.setNum(vie->Pages.at(SNr)->Items.at(Nr)->Groups.top())+" ";
293
                xp.prepend(GroupTxt);
294
        }
265 Franz 295
        switch (vie->Pages.at(SNr)->Items.at(Nr)->PType)
296
        {
297
        case 2:
298
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("Image"));
299
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp+" "+vie->Pages.at(SNr)->Items.at(Nr)->Pfile);
300
                break;
301
        case 4:
302
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("Text"));
303
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp+" "+fon);
304
                break;
305
        case 5:
306
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("Line"));
307
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp);
308
                break;
309
        case 6:
310
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("Polygon"));
311
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp);
312
                break;
313
        case 7:
314
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("Polyline"));
315
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp);
316
                break;
317
        case 8:
318
                PageObj.at(SNr)->Elemente.at(Nr)->setText(1, tr("PathText"));
319
                PageObj.at(SNr)->Elemente.at(Nr)->setText(2, xp+" "+yp+" "+fon);
320
                break;
1395 fschmid 321
        }
265 Franz 322
        connect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int)));
1395 fschmid 323
        connect(ListView1, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*))); */
88 Franz 324
}
325
 
1427 fschmid 326
void Tree::setItemIcon(QListViewItem *item, int typ)
327
{
328
        switch (typ)
329
        {
1460 cbradney 330
        case PageItem::ImageFrame:
1427 fschmid 331
                item->setPixmap( 0, imageIcon );
332
                break;
1460 cbradney 333
        case PageItem::TextFrame:
1427 fschmid 334
                item->setPixmap( 0, textIcon );
335
                break;
1460 cbradney 336
        case PageItem::Line:
1427 fschmid 337
                item->setPixmap( 0, lineIcon );
338
                break;
1460 cbradney 339
        case PageItem::Polygon:
1427 fschmid 340
                item->setPixmap( 0, polygonIcon );
341
                break;
1460 cbradney 342
        case PageItem::PolyLine:
1427 fschmid 343
                item->setPixmap( 0, polylineIcon );
344
                break;
1460 cbradney 345
        case PageItem::PathText:
1427 fschmid 346
                item->setPixmap( 0, textIcon );
347
                break;
348
        default:
349
                break;
350
        }
351
}
352
 
1491 fschmid 353
void Tree::slotAddElement(PageItem *item)
88 Franz 354
{
5287 cbradney 355
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 356
                return;
3691 cbradney 357
        if (currDoc->isLoading())
97 Franz 358
                return;
1491 fschmid 359
        disconnect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
360
        QListViewItem * object;
2877 cbradney 361
        if (!item->OnMasterPage.isEmpty())
1491 fschmid 362
        {
2093 cbradney 363
                QListViewItem * page = masterPageMapRev[item->OnMasterPage];
1491 fschmid 364
                object = new QListViewItem( page, 0 );
2093 cbradney 365
                masterPageItemMap.insert(object, item->ItemNr);
366
                masterPageItemMapRev.insert(item->ItemNr, object);
1491 fschmid 367
        }
368
        else
369
        {
370
                if (item->OwnPage != -1)
371
                {
372
                        QListViewItem * page = pageMapRev[item->OwnPage];
373
                        object = new QListViewItem( page, 0 );
374
                        itemMap.insert(object, item->ItemNr);
375
                        itemMapRev.insert(item->ItemNr, object);
376
                }
377
                else
378
                {
379
                        QListViewItem * page = freeObjects;
380
                        if (freeObjects == 0)
381
                        {
382
                                page = new QListViewItem( rootObject, 0 );
383
                                page->setText(0, tr("Free Objects"));
384
                                freeObjects = page;
385
                        }
386
                        object = new QListViewItem( page, 0 );
387
                        itemMap.insert(object, item->ItemNr);
388
                        itemMapRev.insert(item->ItemNr, object);
389
                }
390
        }
391
        object->setText(0, item->itemName());
392
        setItemIcon(object, item->itemType());
393
        reportDisplay->clearSelection();
394
        reportDisplay->setSelected(object, true);
395
        connect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
88 Franz 396
}
397
 
3240 fschmid 398
void Tree::slotMoveElement(uint , uint , uint )
88 Franz 399
{
5287 cbradney 400
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 401
                return;
2093 cbradney 402
        if ((vie->Doc->masterPageMode) || (vie->Doc->loading))
97 Franz 403
                return;
88 Franz 404
        QListViewItem* tmp = PageObj.at(SNr)->Elemente.take(NrOld);
1395 fschmid 405
        PageObj.at(SNr)->Elemente.insert(NrNew, tmp); */
88 Franz 406
}
407
 
3240 fschmid 408
void Tree::slotAddPage(uint )
88 Franz 409
{
5287 cbradney 410
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 411
                return;
88 Franz 412
        QString cc;
91 Franz 413
        if (ListView1->childCount() == 0)
414
                return;
88 Franz 415
        Seiten.insert(Nr, new QListViewItem(ListView1->firstChild(), "Seiten"));
416
        Seiten.current()->setText(0, tr("Page")+" "+cc.setNum(Nr+1));
417
        PageObj.insert(Nr, new Elem);
1395 fschmid 418
        rebuildPageD(); */
88 Franz 419
}
420
 
3240 fschmid 421
void Tree::slotDelPage(uint )
88 Franz 422
{
5287 cbradney 423
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 424
                return;
2093 cbradney 425
        if (vie->Doc->masterPageMode)
97 Franz 426
                return;
88 Franz 427
        if (Seiten.count() != 0)
265 Franz 428
        {
88 Franz 429
                delete Seiten.at(Nr);
430
                Seiten.take(Nr);
431
                PageObj.take(Nr);
432
                rebuildPageD();
1395 fschmid 433
        } */
88 Franz 434
}
435
 
436
void Tree::rebuildPageD()
437
{
5287 cbradney 438
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 439
                return;
175 Franz 440
        QString cc,tmpstr;
441
        uint pagenumwidth;
265 Franz 442
 
175 Franz 443
        tmpstr.setNum( Seiten.count() );
444
        pagenumwidth=tmpstr.length();
88 Franz 445
        for (uint e = 0; e < Seiten.count(); ++e)
265 Franz 446
        {
447
                tmpstr.setNum(e+1);
448
                cc = tmpstr.rightJustify (pagenumwidth, '0');
449
                Seiten.at(e)->setText(0, tr("Page")+" "+cc);
1395 fschmid 450
        } */
88 Franz 451
}
452
 
3240 fschmid 453
void Tree::reopenTree(QValueList<int> )
91 Franz 454
{
5287 cbradney 455
/*      if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 456
                return;
91 Franz 457
        if (op.count() == 0)
458
                return;
459
        if (op[0] == 1)
460
                ListView1->setOpen(ListView1->firstChild(), true);
461
        for (uint e = 1; e < op.count(); ++e)
265 Franz 462
        {
463
                ListView1->setOpen(Seiten.at(op[e]), true);
1395 fschmid 464
        } */
91 Franz 465
}
466
 
467
QValueList<int> Tree::buildReopenVals()
468
{
469
        QValueList<int> op;
470
        op.clear();
1395 fschmid 471
/*      if (ListView1->childCount() == 0)
91 Franz 472
                return op;
473
        if (ListView1->firstChild()->isOpen())
474
                op.append(1);
475
        else
476
                op.append(0);
477
        for (uint e = 0; e < Seiten.count(); ++e)
265 Franz 478
        {
91 Franz 479
                if (ListView1->isOpen(Seiten.at(e)))
265 Franz 480
                        op.append(e);
1395 fschmid 481
        } */
91 Franz 482
        return op;
483
}
484
 
3 paul 485
void Tree::slotSelect(QListViewItem* ite)
486
{
5287 cbradney 487
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 488
                return;
1427 fschmid 489
        selectionTriggered = true;
1395 fschmid 490
        if (itemMap.contains(ite))
491
        {
5287 cbradney 492
                m_MainWindow->closeActiveWindowMasterPageEditor();
3691 cbradney 493
                if (currDoc->DocItems.at(itemMap[ite])->Groups.count() == 0)
494
                        emit selectElement(currDoc->DocItems.at(itemMap[ite])->OwnPage, itemMap[ite], false);
1427 fschmid 495
                else
3691 cbradney 496
                        emit selectElement(currDoc->DocItems.at(itemMap[ite])->OwnPage, itemMap[ite], true);
1427 fschmid 497
                selectionTriggered = false;
97 Franz 498
                return;
1395 fschmid 499
        }
1414 fschmid 500
        if (groupMap.contains(ite))
501
        {
5287 cbradney 502
                m_MainWindow->closeActiveWindowMasterPageEditor();
3691 cbradney 503
                emit selectElement(currDoc->DocItems.at(groupMap[ite])->OwnPage, groupMap[ite], false);
1427 fschmid 504
                selectionTriggered = false;
1414 fschmid 505
                return;
506
        }
1395 fschmid 507
        if (pageMap.contains(ite))
265 Franz 508
        {
5287 cbradney 509
                m_MainWindow->closeActiveWindowMasterPageEditor();
1395 fschmid 510
                emit selectPage(pageMap[ite]);
1427 fschmid 511
                selectionTriggered = false;
88 Franz 512
                return;
265 Franz 513
        }
2093 cbradney 514
        if (masterPageMap.contains(ite))
265 Franz 515
        {
2093 cbradney 516
                emit selectMasterPage(masterPageMap[ite]);
1427 fschmid 517
                selectionTriggered = false;
1395 fschmid 518
                return;
265 Franz 519
        }
2093 cbradney 520
        if (masterPageItemMap.contains(ite))
1395 fschmid 521
        {
3724 cbradney 522
                if (!currDoc->masterPageMode())
3691 cbradney 523
                        emit selectMasterPage(currDoc->MasterItems.at(masterPageItemMap[ite])->OnMasterPage);
524
                if (currDoc->MasterItems.at(masterPageItemMap[ite])->Groups.count() == 0)
2093 cbradney 525
                        emit selectElement(-1, masterPageItemMap[ite], false);
1427 fschmid 526
                else
2093 cbradney 527
                        emit selectElement(-1, masterPageItemMap[ite], true);
1427 fschmid 528
                selectionTriggered = false;
1395 fschmid 529
                return;
530
        }
2093 cbradney 531
        if (masterPageGroupMap.contains(ite))
1414 fschmid 532
        {
3724 cbradney 533
                if (!currDoc->masterPageMode())
3691 cbradney 534
                        emit selectMasterPage(currDoc->MasterItems.at(masterPageGroupMap[ite])->OnMasterPage);
2093 cbradney 535
                emit selectElement(-1, masterPageGroupMap[ite], false);
1427 fschmid 536
                selectionTriggered = false;
1414 fschmid 537
                return;
538
        }
1427 fschmid 539
        selectionTriggered = false;
3 paul 540
}
541
 
1525 cbradney 542
/*
1448 cbradney 543
void Tree::closeEvent(QCloseEvent *ce)
544
{
545
        emit Schliessen();
546
        ce->accept();
547
}
548
 
549
void Tree::reject()
550
{
551
        emit Schliessen();
552
        QDialog::reject();
553
}
1525 cbradney 554
*/
3 paul 555
void Tree::resizeEvent(QResizeEvent *r)
556
{
1395 fschmid 557
        reportDisplay->resize(r->size());
3 paul 558
}
559
 
3691 cbradney 560
void Tree::BuildTree()
3 paul 561
{
5287 cbradney 562
        if (!m_MainWindow || m_MainWindow->ScriptRunning)
173 Franz 563
                return;
1395 fschmid 564
        disconnect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
3691 cbradney 565
        clearPalette();
566
        Q_ASSERT(currDoc!=NULL);
567
        if (currDoc==NULL)
568
                return;
569
 
1414 fschmid 570
        QPtrList<PageItem> subGroupList;
1395 fschmid 571
        QListViewItem * item = new QListViewItem( reportDisplay, 0 );
1491 fschmid 572
        rootObject = item;
3691 cbradney 573
        item->setText( 0, currDoc->DocName.section( '/', -1 ) );
1395 fschmid 574
        QListViewItem * pagep = 0;
1491 fschmid 575
        freeObjects = 0;
1414 fschmid 576
        PageItem* pgItem;
577
        QString tmp;
3691 cbradney 578
        for (uint b = 0; b < currDoc->MasterItems.count(); ++b)
1414 fschmid 579
        {
3691 cbradney 580
                currDoc->MasterItems.at(b)->Dirty = false;
1414 fschmid 581
        }
3691 cbradney 582
        for (int a = 0; a < static_cast<int>(currDoc->MasterPages.count()); ++a)
1395 fschmid 583
        {
584
                QListViewItem * page = new QListViewItem( item, pagep );
5685 cbradney 585
                QString pageNam = currDoc->MasterPages.at(a)->pageName();
2093 cbradney 586
                masterPageMap.insert(page, pageNam);
587
                masterPageMapRev.insert(pageNam, page);
1395 fschmid 588
                pagep = page;
3691 cbradney 589
                for (uint b = 0; b < currDoc->MasterItems.count(); ++b)
1395 fschmid 590
                {
3691 cbradney 591
                        pgItem = currDoc->MasterItems.at(b);
1414 fschmid 592
                        if ((pgItem->OwnPage == a) || (pgItem->OnMasterPage == pageNam))
1395 fschmid 593
                        {
1414 fschmid 594
                                if (pgItem->Groups.count() == 0)
595
                                {
596
                                        QListViewItem * object = new QListViewItem( page, 0 );
2093 cbradney 597
                                        masterPageItemMap.insert(object, pgItem->ItemNr);
598
                                        masterPageItemMapRev.insert(pgItem->ItemNr, object);
1414 fschmid 599
                                        object->setText(0, pgItem->itemName());
1460 cbradney 600
                                        setItemIcon(object, pgItem->itemType());
1427 fschmid 601
                                        pgItem->Dirty = true;
1414 fschmid 602
                                }
603
                                else
604
                                {
1427 fschmid 605
                                        QListViewItem * object = new QListViewItem( page, 0 );
606
                                        object->setText(0, tr("Group ")+tmp.setNum(pgItem->Groups.top()));
607
                                        object->setPixmap( 0, groupIcon );
608
                                        subGroupList.clear();
3691 cbradney 609
                                        for (uint ga = 0; ga < currDoc->MasterItems.count(); ++ga)
1427 fschmid 610
                                        {
3691 cbradney 611
                                                PageItem* pgItem2 = currDoc->MasterItems.at(ga);
1427 fschmid 612
                                                if ((pgItem2->Groups.count() != 0) && (pgItem2->Groups.top() == pgItem->Groups.top()))
613
                                                        subGroupList.append(pgItem2);
614
                                        }
615
                                        parseSubGroup(1, object, &subGroupList, true);
2093 cbradney 616
                                        masterPageGroupMap.insert(object, pgItem->ItemNr);
617
                                        masterPageGroupMapRev.insert(pgItem->ItemNr, object);
1414 fschmid 618
                                }
1395 fschmid 619
                        }
620
                }
5685 cbradney 621
                page->setText(0, currDoc->MasterPages.at(a)->pageName());
1395 fschmid 622
        }
3691 cbradney 623
        for (uint b = 0; b < currDoc->DocItems.count(); ++b)
1414 fschmid 624
        {
3691 cbradney 625
                currDoc->DocItems.at(b)->Dirty = false;
1414 fschmid 626
        }
3691 cbradney 627
        for (int a = 0; a < static_cast<int>(currDoc->DocPages.count()); ++a)
1395 fschmid 628
        {
629
                QListViewItem * page = new QListViewItem( item, pagep );
630
                pageMap.insert(page, a);
1427 fschmid 631
                pageMapRev.insert(a, page);
1395 fschmid 632
                pagep = page;
3691 cbradney 633
                for (uint b = 0; b < currDoc->DocItems.count(); ++b)
1395 fschmid 634
                {
3691 cbradney 635
                        pgItem = currDoc->DocItems.at(b);
1414 fschmid 636
                        if ((pgItem->OwnPage == a) && (!pgItem->Dirty))
1395 fschmid 637
                        {
1414 fschmid 638
                                if (pgItem->Groups.count() == 0)
639
                                {
1427 fschmid 640
                                        QListViewItem * object = new QListViewItem( page, 0 );
641
                                        object->setText(0, pgItem->itemName());
1460 cbradney 642
                                        setItemIcon(object, pgItem->itemType());
1427 fschmid 643
                                        itemMap.insert(object, pgItem->ItemNr);
644
                                        itemMapRev.insert(pgItem->ItemNr, object);
645
                                        pgItem->Dirty = true;
1414 fschmid 646
                                }
647
                                else
648
                                {
1427 fschmid 649
                                        QListViewItem * object = new QListViewItem( page, 0 );
650
                                        object->setText(0, tr("Group ")+tmp.setNum(pgItem->Groups.top()));
651
                                        object->setPixmap( 0, groupIcon );
652
                                        subGroupList.clear();
3691 cbradney 653
                                        for (uint ga = 0; ga < currDoc->DocItems.count(); ++ga)
1427 fschmid 654
                                        {
3691 cbradney 655
                                                PageItem* pgItem2 = currDoc->DocItems.at(ga);
1427 fschmid 656
                                                if ((pgItem2->Groups.count() != 0) && (pgItem2->Groups.top() == pgItem->Groups.top()))
657
                                                        subGroupList.append(pgItem2);
658
                                        }
659
                                        parseSubGroup(1, object, &subGroupList, false);
660
                                        groupMap.insert(object, pgItem->ItemNr);
661
                                        groupMapRev.insert(pgItem->ItemNr, object);
1414 fschmid 662
                                }
1395 fschmid 663
                        }
664
                }
665
                page->setText(0, tr("Page ")+tmp.setNum(a+1));
666
        }
667
        bool hasfreeItems = false;
3691 cbradney 668
        for (uint b = 0; b < currDoc->DocItems.count(); ++b)
1395 fschmid 669
        {
3691 cbradney 670
                if (currDoc->DocItems.at(b)->OwnPage == -1)
1395 fschmid 671
                {
672
                        hasfreeItems = true;
673
                        break;
674
                }
675
        }
676
        if (hasfreeItems)
677
        {
678
                QListViewItem * page = new QListViewItem( item, pagep );
679
                pagep = page;
1491 fschmid 680
                freeObjects = page;
3691 cbradney 681
                for (uint b = 0; b < currDoc->DocItems.count(); ++b)
1395 fschmid 682
                {
3691 cbradney 683
                        pgItem = currDoc->DocItems.at(b);
1414 fschmid 684
                        if ((pgItem->OwnPage == -1) && (!pgItem->Dirty))
1395 fschmid 685
                        {
1414 fschmid 686
                                if (pgItem->Groups.count() == 0)
687
                                {
688
                                        QListViewItem * object = new QListViewItem( page, 0 );
689
                                        object->setText(0, pgItem->itemName());
1460 cbradney 690
                                        setItemIcon(object, pgItem->itemType());
1427 fschmid 691
                                        pgItem->Dirty = true;
1414 fschmid 692
                                        itemMap.insert(object, pgItem->ItemNr);
1427 fschmid 693
                                        itemMapRev.insert(pgItem->ItemNr, object);
1414 fschmid 694
                                }
695
                                else
696
                                {
1427 fschmid 697
                                        QListViewItem * object = new QListViewItem( page, 0 );
698
                                        object->setText(0, tr("Group ")+tmp.setNum(pgItem->Groups.top()));
699
                                        object->setPixmap( 0, groupIcon );
700
                                        subGroupList.clear();
3691 cbradney 701
                                        for (uint ga = 0; ga < currDoc->DocItems.count(); ++ga)
1427 fschmid 702
                                        {
3691 cbradney 703
                                                PageItem* pgItem2 = currDoc->DocItems.at(ga);
1427 fschmid 704
                                                if ((pgItem2->Groups.count() != 0) && (pgItem2->Groups.top() == pgItem->Groups.top()))
705
                                                        subGroupList.append(pgItem2);
706
                                        }
707
                                        parseSubGroup(1, object, &subGroupList, false);
708
                                        groupMap.insert(object, pgItem->ItemNr);
709
                                        groupMapRev.insert(pgItem->ItemNr, object);
1414 fschmid 710
                                }
1395 fschmid 711
                        }
712
                }
713
                page->setText(0, tr("Free Objects"));
714
        }
3691 cbradney 715
        for (uint b = 0; b < currDoc->DocItems.count(); ++b)
1414 fschmid 716
        {
5362 avox 717
                currDoc->DocItems.at(b)->invalid = true;
1414 fschmid 718
        }
3691 cbradney 719
        for (uint b = 0; b < currDoc->MasterItems.count(); ++b)
1414 fschmid 720
        {
5362 avox 721
                currDoc->MasterItems.at(b)->invalid = true;
1414 fschmid 722
        }
1395 fschmid 723
        connect(reportDisplay, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(slotSelect(QListViewItem*)));
1414 fschmid 724
}
725
 
2093 cbradney 726
void Tree::parseSubGroup(int level, QListViewItem* object, QPtrList<PageItem> *subGroupList, bool onMasterPage)
1414 fschmid 727
{
728
        QPtrList<PageItem> *subGroup;
729
        PageItem *pgItem;
730
        QString tmp;
731
        for (uint b = 0; b < subGroupList->count(); ++b)
732
        {
733
                pgItem = subGroupList->at(b);
734
                if (!pgItem->Dirty)
735
                {
736
                        if (static_cast<int>(pgItem->Groups.count()) <= level)
737
                        {
1427 fschmid 738
                                QListViewItem *grp = new QListViewItem( object, 0 );
739
                                grp->setText(0, pgItem->itemName());
1460 cbradney 740
                                setItemIcon(grp, pgItem->itemType());
2093 cbradney 741
                                if (onMasterPage)
1427 fschmid 742
                                {
2093 cbradney 743
                                        masterPageItemMap.insert(grp, pgItem->ItemNr);
744
                                        masterPageItemMapRev.insert(pgItem->ItemNr, grp);
1427 fschmid 745
                                }
746
                                else
747
                                {
748
                                        itemMap.insert(grp, pgItem->ItemNr);
749
                                        itemMapRev.insert(pgItem->ItemNr, grp);
750
                                }
751
                                pgItem->Dirty = true;
1414 fschmid 752
                        }
753
                        else
754
                        {
1427 fschmid 755
                                QListViewItem *grp = new QListViewItem( object, 0 );
756
                                grp->setText(0, tr("Group ")+tmp.setNum(*pgItem->Groups.at(pgItem->Groups.count()-level-1)));
757
                                grp->setPixmap( 0, groupIcon );
758
                                subGroup = new QPtrList<PageItem>;
759
                                subGroup->clear();
760
                                for (uint ga = 0; ga < subGroupList->count(); ++ga)
761
                                {
762
                                        PageItem* pgItem2 = subGroupList->at(ga);
763
                                        if ((static_cast<int>(pgItem2->Groups.count()) > level) &&
764
                                                (*(pgItem2->Groups.at(pgItem2->Groups.count()-level-1)) == (*pgItem->Groups.at(pgItem->Groups.count()-level-1))))
765
                                                subGroup->append(pgItem2);
766
                                }
2093 cbradney 767
                                parseSubGroup(level+1, grp, subGroup, onMasterPage);
1427 fschmid 768
                                delete subGroup;
2093 cbradney 769
                                if (onMasterPage)
1427 fschmid 770
                                {
2093 cbradney 771
                                        masterPageGroupMap.insert(grp, pgItem->ItemNr);
772
                                        masterPageGroupMapRev.insert(pgItem->ItemNr, grp);
1427 fschmid 773
                                }
774
                                else
775
                                {
776
                                        groupMap.insert(grp, pgItem->ItemNr);
777
                                        groupMapRev.insert(pgItem->ItemNr, grp);
778
                                }
1414 fschmid 779
                        }
780
                }
781
        }
782
}
783
 
784
 
1395 fschmid 785
/*
786
 
1414 fschmid 787
                        for (uint ga=0; ga<Doc->Items.count(); ++ga)
788
                        {
789
                                if (Doc->Items.at(ga)->Groups.count() != 0)
790
                                {
791
                                        if (Doc->Items.at(ga)->Groups.top() == b->Groups.top())
792
                                        {
793
                                                if (Doc->Items.at(ga)->ItemNr != b->ItemNr)
794
                                                {
795
                                                        if (SelItem.find(Doc->Items.at(ga)) == -1)
796
                                                                SelItem.append(Doc->Items.at(ga));
797
                                                }
798
                                                Doc->Items.at(ga)->Select = true;
799
                                                Doc->Items.at(ga)->FrameOnly = true;
800
                                                Doc->Items.at(ga)->paintObj();
801
                                        }
802
                                }
803
                        }
265 Franz 804
        disconnect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int)));
175 Franz 805
        uint a, b, pagenumwidth;
806
        QString cc, tmpstr;
88 Franz 807
        PageObj.clear();
3 paul 808
        Seiten.clear();
809
        ListView1->clear();
88 Franz 810
        vie = view;
3 paul 811
        QListViewItem * item = new QListViewItem( ListView1, 0 );
248 Franz 812
        item->setText( 0, view->Doc->DocName);
456 fschmid 813
        tmpstr.setNum (view->Doc->Pages.count() );
175 Franz 814
        pagenumwidth = tmpstr.length();
456 fschmid 815
        for (a = 0; a < view->Doc->Pages.count(); ++a)
265 Franz 816
        {
817
                tmpstr.setNum(a+1);
818
                cc = tmpstr.rightJustify (pagenumwidth, '0');
819
                Seiten.append(new QListViewItem(item, "Seiten"));
820
                Seiten.current()->setText(0, tr("Page")+" "+cc);
88 Franz 821
                PageObj.append(new Elem);
456 fschmid 822
                for (b = 0; b < view->Doc->Items.count(); b++)
265 Franz 823
                {
456 fschmid 824
                        PageObj.current()->Elemente.append(new QListViewItem(Seiten.current(), "Items"));
825
                        slotUpdateElement(a, b);
826
                        PageObj.at(a)->Elemente.at(b)->setRenameEnabled(0, true);
265 Franz 827
                }
828
        }
1395 fschmid 829
        connect(ListView1, SIGNAL(itemRenamed(QListViewItem*, int)), this, SLOT(slotDoRename(QListViewItem*, int))); */
1414 fschmid 830
 
2194 cbradney 831
void Tree::languageChange()
832
{
2397 cbradney 833
        setCaption( tr("Outline"));
2194 cbradney 834
        reportDisplay->setColumnText(idElemCol, tr("Element"));
2355 cbradney 835
}
3691 cbradney 836
 
837
void Tree::clearPalette()
838
{
839
        //GUI
840
        reportDisplay->clear();
841
        //Maps
842
        itemMap.clear();
843
        pageMap.clear();
844
        groupMap.clear();
845
        masterPageGroupMap.clear();
846
        masterPageMap.clear();
847
        masterPageItemMap.clear();
848
        itemMapRev.clear();
849
        pageMapRev.clear();
850
        groupMapRev.clear();
851
        masterPageGroupMapRev.clear();
852
        masterPageMapRev.clear();
853
        masterPageItemMapRev.clear();
854
}