Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
13520 pierre 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
#include <QtGui>
8
#include <QMessageBox>
9
#include <iostream>
10
#include "picturebrowser.h"
11
 
12
#include "prefsfile.h"
13
#include "prefsmanager.h"
14
 
15
//provides loadIcon()
16
#include "util_icon.h"
17
 
18
PictureBrowser::PictureBrowser ( ScribusDoc* doc, QWidget *parent ) : QDialog ( parent )
19
{
20
        setupUi ( this );
21
 
22
//set Scribusdoc
23
        srcDoc = doc;
24
        ScMW = doc->scMW();
25
 
26
//load settings
27
        pbSettings.load();
28
 
29
 
30
        connect ( navigationBox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( navigate ( int ) ) );
31
        connect ( sortCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( sortChanged ( int ) ) );
32
        connect ( previewModeCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( previewModeChanged ( int ) ) );
33
        connect ( moreButton, SIGNAL ( clicked() ), this, SLOT ( moreButtonClicked() ) );
34
        connect ( resetSettingsButton, SIGNAL ( clicked() ), this, SLOT ( resetSettingsButtonClicked() ) );
35
        connect ( sortOrderButton, SIGNAL ( clicked() ), this, SLOT ( sortOrderButtonClicked() ) );
36
        connect ( actionsGoButton, SIGNAL ( clicked() ), this, SLOT ( actionsGoButtonClicked() ) );
37
 
38
        connect ( zoomPlusButton, SIGNAL ( clicked() ), this, SLOT ( zoomPlusButtonClicked() ) );
39
        connect ( zoomMinusButton, SIGNAL ( clicked() ), this, SLOT ( zoomMinusButtonClicked() ) );
40
 
41
//close button
42
        connect ( closeButton, SIGNAL ( clicked() ), this, SLOT ( accept() ) );
43
 
44
        connect ( tabWidget, SIGNAL ( currentChanged ( int ) ), this, SLOT ( tabWidgetCurrentChanged ( int ) ) );
45
 
46
//"goto page" button in documentbrowser
47
        connect ( gotoPageButton, SIGNAL ( clicked() ), this, SLOT ( gotoPageButtonClicked() ) );
48
 
49
        connect ( folderView, SIGNAL ( activated ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
50
        connect ( folderView, SIGNAL ( clicked ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
51
        connect ( folderView, SIGNAL ( doubleClicked ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
52
 
53
//changing page
54
        connect ( this, SIGNAL ( selectPage ( int ) ), ScCore->primaryMainWindow(), SLOT ( selectPagesFromOutlines ( int ) ) );
55
        connect ( this, SIGNAL ( selectMasterPage ( QString ) ), ScCore->primaryMainWindow(), SLOT ( manageMasterPages ( QString ) ) );
56
 
57
//always-on-top checkbox
58
        connect ( alwaysOnTopCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( alwaysOnTopCheckboxStateChanged() ) );
59
//save settings checkbox
60
        connect ( saveSettingsCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( saveSettingsCheckboxStateChanged() ) );
61
 
62
//folderbrowser:include subdirs
63
        connect ( subdirsCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( subdirsCheckboxStateChanged() ) );
64
 
65
        loadIcons();
66
 
67
        setSettings();
68
 
69
        navigationStack->setCurrentIndex ( 0 );
70
 
71
 
72
//maybe add QDir::Readable, although users might wonder where their folders are
73
        folderModel.setFilter ( QDir::AllDirs|QDir::Drives|QDir::NoDotAndDotDot|QDir::NoSymLinks/*|QDir::Hidden*/ );
74
        folderView->setModel ( &folderModel );
75
 
76
// this should give a little performance boost
77
        folderView->setUniformRowHeights ( true );
78
        folderView->setCurrentIndex ( folderModel.index ( QDir::currentPath() ) );
79
        folderView->scrollTo ( folderView->currentIndex(), QAbstractItemView::PositionAtTop );
80
        folderView->resizeColumnToContents ( 0 );
81
 
82
//this needs to be calculated later from height/width of QListView!
83
        previewIconsVisible = 8;
84
        folderBrowserIncludeSubdirs = false;
85
 
86
        imagesDisplayed = 0;
87
        imagesFiltered = 0;
88
        previewIconIndex = -1;
89
        insertCustomPosition = false;
90
        insertCustomSize = false;
91
        currentRow = 0;
92
 
93
//set up previewimages instance, fill with last shown images later
94
        pImages = new previewImages ( QStringList() );
95
 
96
//set threadpointer to 0
97
        fit = 0;
98
        crt = 0;
99
        cdbwt = 0;
100
        clrt = 0;
101
 
102
 
103
        pModel = new PreviewImagesModel ( this );
104
 
105
//create loadImagesThread instance, connect and run it
106
        lit = new loadImagesThread ( this, pModel );
107
        lit->start();
108
 
109
        connect ( imageViewArea, SIGNAL ( clicked ( const QModelIndex & ) ), this, SLOT ( previewIconClicked ( const QModelIndex & ) ) );
110
        connect ( imageViewArea, SIGNAL ( doubleClicked ( const QModelIndex & ) ), this, SLOT ( previewIconDoubleClicked ( const QModelIndex & ) ) );
111
        imageViewArea->setViewMode ( QListView::IconMode );
112
        imageViewArea->setIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
113
        imageViewArea->setGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
114
        imageViewArea->setUniformItemSizes ( true );
115
        imageViewArea->setContextMenuPolicy ( Qt::CustomContextMenu );
116
        imageViewArea->setSelectionMode ( QAbstractItemView::ExtendedSelection );
117
        imageViewArea->setMovement ( QListView::Snap );
118
        imageViewArea->setResizeMode ( QListView::Adjust );
119
        imageViewArea->setModel ( pModel );
120
 
121
//register item selections
122
        connect ( imageViewArea->selectionModel(), SIGNAL ( selectionChanged ( const QItemSelection &, const QItemSelection & ) ), this, SLOT ( previewImageSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) );
123
 
124
//documentbrowser setup
125
        connect ( documentWidget, SIGNAL ( itemActivated ( QTreeWidgetItem * , int ) ), this, SLOT ( documentChosen ( QTreeWidgetItem * , int ) ) );
126
        connect ( documentWidget, SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ), this, SLOT ( documentChosen ( QTreeWidgetItem * , int ) ) );
127
 
128
        documentWidget->setColumnCount ( 1 );
129
        documentWidget->setHeaderLabels ( QStringList ( "Pages" ) );
130
 
131
 
132
//collectionsbrowser setup
133
        connect ( collectionsWidget, SIGNAL ( itemActivated ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionChosen ( QTreeWidgetItem * , int ) ) );
134
        connect ( collectionsWidget, SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionChosen ( QTreeWidgetItem * , int ) ) );
135
        connect ( collectionsWidget, SIGNAL ( itemChanged ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionsWidgetItemEdited ( QTreeWidgetItem * , int ) ) );
136
        connect ( collectionsNewCategoryButton, SIGNAL ( clicked() ), this, SLOT ( collectionsNewCategoryButtonClicked() ) );
137
        connect ( collectionsNewButton, SIGNAL ( clicked() ), this, SLOT ( collectionsNewButtonClicked() ) );
138
        connect ( collectionsImportButton, SIGNAL ( clicked() ), this, SLOT ( collectionsImportButtonClicked() ) );
139
        connect ( collectionsExportButton, SIGNAL ( clicked() ), this, SLOT ( collectionsExportButtonClicked() ) );
140
        connect ( collectionsDeleteButton, SIGNAL ( clicked() ), this, SLOT ( collectionsDeleteButtonClicked() ) );
141
        connect ( collectionsRenameButton, SIGNAL ( clicked() ), this, SLOT ( collectionsRenameButtonClicked() ) );
142
 
143
        connect ( collectionsAddImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesButtonClicked() ) );
144
        connect ( collectionsRemoveImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsRemoveImagesButtonClicked() ) );
145
        connect ( collectionsTagImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsTagImagesButtonClicked() ) );
146
        connect ( collectionsAddImagesOkButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesOkButtonClicked() ) );
147
        connect ( collectionsAddImagesCancelButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesCancelButtonClicked() ) );
148
 
149
        connect ( collectionsSetTagsButton, SIGNAL ( clicked() ), this, SLOT ( collectionsSetTagsButtonClicked() ) );
150
        connect ( collectionsAddNewTagButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddNewTagButtonClicked() ) );
151
 
152
 
153
        collectionsWidget->setColumnCount ( 1 );
154
        collectionsWidget->setHeaderLabels ( QStringList ( "Name" ) );
155
 
13608 jghali 156
        cdbFile = ScPaths::instance().getPluginDataDir() + QString ( "collectionsdb.xml" );
13520 pierre 157
//emtpy initialization, maybe accessed before collection is actually loaded
158
        currCollection = new imageCollection;
159
        currCollection->name = "empty";
160
        currCollection->file = "empty";
161
 
162
        crt = new collectionReaderThread ( cdbFile, false );
163
        connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
164
        crt->start();
165
 
166
        connect ( insertPositionCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( insertPositionComboboxChanged ( int ) ) );
167
        connect ( insertSizeCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( insertSizeComboboxChanged ( int ) ) );
168
        connect ( insertImageButton, SIGNAL ( clicked() ), this, SLOT ( insertImageButtonClicked() ) );
169
        connect ( insertPagesCombobox, SIGNAL ( checkstateChanged ( int ) ), this, SLOT ( insertPagesComboboxCheckstateChanged ( int ) ) );
13658 cbradney 170
        insertPagesCombobox->addItem ( "Current Page", 1 );
13520 pierre 171
        insertPagesCombobox->addItem ( "All Pages", 0 );
172
 
173
        for ( int i = 0 ; i < ( int ) ( srcDoc->Pages->count() ) ; ++i )
174
        {
175
                insertPagesCombobox->addItem ( QString ( "Page %1" ).arg ( i+1 ), 0 );
176
        }
177
 
178
        insertFramesCombobox->addItem ( "All Frames", 0 );
179
        insertFramesCombobox->addItem ( "All Empty Frames", 0 );
180
 
181
 
182
        PageItem *pItem;
183
 
184
        for ( int i = 0; i < srcDoc->MasterItems.count(); ++i )
185
        {
186
                pItem = srcDoc->MasterItems.at ( i );
187
 
188
                if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( !pItem->asLatexFrame() ) )
189
                {
190
                        QString itemText;
191
 
192
                        if ( pItem->PictureIsAvailable )
193
                        {
194
                                itemText = QString ( "Frame %1" ).arg ( i+1 );
195
                        }
196
                        else
197
                        {
198
                                itemText = QString ( "Frame %1 (empty)" ).arg ( i+1 );
199
                        }
200
 
201
                        insertFramesCombobox->addItem ( itemText, 0 );
202
                }
203
        }
204
 
205
        for ( int i = 0; i < srcDoc->Items->count(); ++i )
206
        {
207
                pItem = srcDoc->Items->at ( i );
208
 
209
                if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( !pItem->asLatexFrame() ) )
210
                {
211
                        QString itemText;
212
 
213
                        if ( pItem->PictureIsAvailable )
214
                        {
215
                                itemText = QString ( "Frame %1" ).arg ( i+1 );
216
                        }
217
                        else
218
                        {
219
                                itemText = QString ( "Frame %1 (empty)" ).arg ( i+1 );
220
                        }
221
 
222
                        insertFramesCombobox->addItem ( itemText, 0 );
223
                }
224
        }
225
 
226
 
227
//set namefilters for global use
228
        nameFilters << "*.jpg" << "*.jpeg" << "*.gif" << "*.png" << "*.ps" << "*.psd" << "*.tif" << "*.tiff" << "*.xpm" << "*.eps" << "*.epsf" << "*.epsi" << "*.eps2" << "*.eps3" << "*.epi" << "*.epg";
229
 
230
 
231
//filter/search setup
232
        connect ( filterTargetCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( filterTargetComboboxChanged ( int ) ) );
233
        connect ( filterCriteriaCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( filterCriteriaComboboxChanged ( int ) ) );
234
        connect ( filterFilterButton, SIGNAL ( clicked() ), this, SLOT ( filterFilterButtonClicked() ) );
235
        connect ( filterClearButton, SIGNAL ( clicked() ), this, SLOT ( filterClearButtonClicked() ) );
236
        connect ( filterAddCriterionButton, SIGNAL ( clicked() ), this, SLOT ( filterAddCriterionButtonClicked() ) );
237
        connect ( filterSearchDirButton, SIGNAL ( clicked() ), this, SLOT ( filterSearchDirButtonClicked() ) );
238
 
239
        filters = new imageFilters;
240
 
241
 
13658 cbradney 242
        filterTypeCombobox->addItem ( "All Supported Formats", 1 );
13520 pierre 243
 
244
        for ( int i = 0 ; i < nameFilters.size() ; ++i )
245
        {
246
                filterTypeCombobox->addItem ( nameFilters.at ( i ), 1 );
247
        }
248
 
249
//fix: scrollperitem doesnt work
250
//imageViewArea->setLayoutMode(QListView::Batched);
251
//imageViewArea->setBatchSize(4);
252
//imageViewArea->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
253
//imageViewArea->setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);
254
}
255
 
256
 
257
PictureBrowser::~PictureBrowser()
258
{
259
}
260
 
261
 
262
void PictureBrowser::callLoadImageThread ( int row, int pId )
263
{
264
        previewImage *imageToLoad = pModel->modelItemsList.at ( row );
265
 
266
        emit loadImageJob ( row, imageToLoad->fileInformation.absoluteFilePath(), pbSettings.previewIconSize, pId );
267
}
268
 
269
 
270
void PictureBrowser::navigate ( int index )
271
{
272
        //this check shouldnt be necessary but you never know...
273
        if ( ( index >= 0 ) && ( index < 3 ) )
274
        {
275
                if ( index == 2 )
276
                {
277
                        updateDocumentbrowser();
278
                }
279
 
280
                navigationStack->setCurrentIndex ( index );
281
        }
282
}
283
 
284
 
285
void PictureBrowser::previewIconClicked ( const QModelIndex &index )
286
{
287
        int row = index.row();
288
 
289
        if ( row >= 0 )
290
        {
291
                previewIconIndex = row;
292
                updateInformationTab ( previewIconIndex );
293
        }
294
}
295
 
296
 
297
void PictureBrowser::previewIconDoubleClicked ( const QModelIndex &index )
298
{
299
        int row = index.row();
300
 
301
        if ( row >= 0 )
302
        {
303
                ScribusDoc *currentDoc ( ScMW->doc );
304
                Imagedialog *id ( new Imagedialog ( pImages->previewImagesList.at ( row )->fileInformation.absoluteFilePath(), currentDoc ,this ) );
305
 
306
                if ( id )
307
                {
308
                        id->setAttribute ( Qt::WA_DeleteOnClose );
309
                        id->show();
310
                        id->raise();
311
                        id->activateWindow();
312
                }
313
        }
314
}
315
 
316
 
317
void PictureBrowser::sortChanged ( int index )
318
{
319
        //this check shouldnt be necessary but you never know...
320
        if ( ( index >= 0 ) && ( index < 4 ) )
321
        {
322
                pbSettings.sortSetting = index;
323
 
324
                if ( saveSettingsCheckbox->isChecked() )
325
                {
326
                        pbSettings.save();
327
                }
328
 
329
                updateBrowser ( false, true, false );
330
        }
331
}
332
 
333
 
334
void PictureBrowser::previewModeChanged ( int index )
335
{
336
        if ( ( index >= 0 ) && ( index < 2 ) )
337
        {
338
                pbSettings.previewMode = index;
339
                imageViewArea->setGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
340
 
341
                if ( saveSettingsCheckbox->isChecked() )
342
                {
343
                        pbSettings.save();
344
                }
345
        }
346
}
347
 
348
 
349
// enlarge dialog to show more information/options
350
//FIXME: still quick and dirty, professional animation required
351
void PictureBrowser::moreButtonClicked()
352
{
353
        // dialog is not enlarged -> enlarge, change buttontext/icon
354
        if ( !pbSettings.showMore )
355
        {
356
                expandDialog ( true );
357
                pbSettings.showMore = true;
358
 
359
                if ( tabWidget->currentIndex() == 0 )
360
                {
361
                        updateInformationTab ( previewIconIndex );
362
                }
363
        }
364
        // dialog is enlarged, set back to original size, change buttontext/icon
365
        else
366
        {
367
                expandDialog ( false );
368
                pbSettings.showMore = false;
369
        }
370
 
371
        if ( saveSettingsCheckbox->isChecked() )
372
        {
373
                pbSettings.save();
374
        }
375
}
376
 
377
 
378
void PictureBrowser::resetSettingsButtonClicked()
379
{
380
        pbSettings.reset();
381
        setSettings();
382
}
383
 
384
 
385
void PictureBrowser::actionsGoButtonClicked()
386
{
387
        int index = actionsCombobox->currentIndex();
388
 
389
        if ( ( previewIconIndex < 0 ) || ( previewIconIndex > pImages->previewImagesList.size() ) )
390
        {
13658 cbradney 391
                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No Image(s) Selected" ) );
13520 pierre 392
                return;
393
        }
394
 
395
        if ( index == 0 )
396
        {
397
                previewImage *tmpImage;
398
 
399
                //image from pModel needed here
400
                tmpImage = pModel->modelItemsList.at ( previewIconIndex );
401
                InsertAFrameData iafData;
402
 
403
                iafData.frameType=PageItem::ImageFrame;
404
                iafData.source=tmpImage->fileInformation.absoluteFilePath();
405
                iafData.locationType = 0;
406
                iafData.pageList = QString ( "" );
407
                iafData.positionType = 0;
408
                iafData.sizeType = 0;
409
                iafData.x = 0;
410
                iafData.y = 0;
411
                iafData.width = 0;
412
                iafData.height = 0;
413
                //iafData.impsetup=m_ImportSetup;
414
                iafData.columnCount = 0;
415
                iafData.columnGap = 0;
416
                iafData.linkTextFrames = false;
417
                iafData.linkToExistingFrame = false;
418
                iafData.linkToExistingFramePtr=NULL;
419
 
420
                tmpImage->insertIntoDocument ( srcDoc, iafData );
421
        }
422
        else if ( index == 1 )
423
        {
424
                if ( !pbSettings.showMore )
425
                {
426
                        expandDialog ( true );
427
                }
428
 
429
                if ( tabWidget->currentIndex() != 3 )
430
                {
431
                        tabWidget->setCurrentIndex ( 3 );
432
                }
433
        }
434
        else if ( index == 2 )
435
        {
436
                navigationBox->setCurrentIndex ( 1 );
437
                collectionsStackedwidget->setCurrentIndex ( 1 );
438
                updateCollectionsWidget ( true );
439
                collectionsWidget->blockSignals ( true );
440
        }
441
}
442
 
443
 
444
void PictureBrowser::sortOrderButtonClicked()
445
{
446
        if ( !pbSettings.sortOrder )
447
        {
448
                pbSettings.sortOrder = true;
449
                sortOrderButton->setIcon ( *iconArrowUp );
450
        }
451
        else
452
        {
453
                pbSettings.sortOrder = false;
454
                sortOrderButton->setIcon ( *iconArrowDown );
455
        }
456
 
457
        if ( saveSettingsCheckbox->isChecked() )
458
        {
459
                pbSettings.save();
460
        }
461
 
462
        updateBrowser ( false, false, false );
463
}
464
 
465
 
466
void PictureBrowser::zoomPlusButtonClicked()
467
{
468
        if ( pbSettings.previewIconSize < 500 )
469
        {
470
                pbSettings.previewIconSize += 20;
471
 
472
                imageViewArea->setIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
473
                imageViewArea->setGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
474
 
475
                pModel->createDefaultIcon ( pbSettings.previewIconSize );
476
 
477
                if ( saveSettingsCheckbox->isChecked() )
478
                {
479
                        pbSettings.save();
480
                }
481
 
482
                updateBrowser ( false, false, true );
483
        }
484
}
485
 
486
 
487
void PictureBrowser::zoomMinusButtonClicked()
488
{
489
        if ( pbSettings.previewIconSize > 50 )
490
        {
491
                pbSettings.previewIconSize -= 20;
492
 
493
                imageViewArea->setIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
494
                imageViewArea->setGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
495
 
496
                pModel->createDefaultIcon ( pbSettings.previewIconSize );
497
 
498
                if ( saveSettingsCheckbox->isChecked() )
499
                {
500
                        pbSettings.save();
501
                }
502
 
503
                updateBrowser ( false, false, true );
504
        }
505
}
506
 
507
 
508
void PictureBrowser::tabWidgetCurrentChanged ( int index )
509
{
510
        if ( index == 0 )
511
        {
512
                updateInformationTab ( previewIconIndex );
513
        }
514
}
515
 
516
 
517
void PictureBrowser::gotoPageButtonClicked()
518
{
519
        QTreeWidgetItem *item = documentWidget->currentItem();
520
 
521
        if ( !item )
522
        {
523
                return;
524
        }
525
 
526
        int id = item->data ( 0, Qt::UserRole ).toInt();
527
 
528
        if ( id > 0 )
529
        {
530
                id--;
531
        }
532
 
533
        ScCore->primaryMainWindow()->closeActiveWindowMasterPageEditor();
534
        emit selectPage ( id );
535
}
536
 
537
 
538
void PictureBrowser::alwaysOnTopCheckboxStateChanged()
539
{
540
        pbSettings.alwaysOnTop = alwaysOnTopCheckbox->isChecked();
541
 
542
        if ( saveSettingsCheckbox->isChecked() )
543
        {
544
                pbSettings.save();
545
        }
546
 
547
        setAlwaysOnTop ( pbSettings.alwaysOnTop );
548
}
549
 
550
 
551
void PictureBrowser::saveSettingsCheckboxStateChanged()
552
{
553
        pbSettings.saveSettings = saveSettingsCheckbox->isChecked();
554
        pbSettings.save();
555
}
556
 
557
 
558
void PictureBrowser::subdirsCheckboxStateChanged()
559
{
560
        folderBrowserIncludeSubdirs = subdirsCheckbox->isChecked();
561
}
562
 
563
 
564
// processes chosen dirs in the folderbrowser
565
void PictureBrowser::dirChosen ( const QModelIndex &index )
566
{
567
        // as long as the folder doesnt change, only the first signal (click, doubleclick or activated) is processed
568
        if ( !tmpindex.isValid() || ( tmpindex != index ) )
569
        {
570
                tmpindex = index;
571
 
572
                currPath = folderModel.filePath ( index );
573
 
574
                if ( !fit )
575
                {
576
                        fit = new findImagesThread ( currPath, nameFilters, QDir::Name, folderBrowserIncludeSubdirs );
577
                        connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ) );
578
                        fit->start();
579
                }
580
                else
581
                {
582
                        fit->restart();
583
                }
584
        }
585
}
586
 
587
 
588
void PictureBrowser::documentChosen ( QTreeWidgetItem * item, int column )
589
{
590
        PageItem *pItem;
591
        QStringList imageFiles;
592
 
593
        int id = item->data ( 0, Qt::UserRole ).toInt();
594
 
595
 
596
        for ( int i = 0; i < srcDoc->MasterItems.count(); ++i )
597
        {
598
                pItem = srcDoc->MasterItems.at ( i );
599
 
600
                if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( pItem->PictureIsAvailable ) && ( !pItem->asLatexFrame() ) )
601
                {
602
                        if ( ( id == 0 ) || ( ( id-1 ) == pItem->OwnPage ) )
603
                        {
604
                                imageFiles.append ( pItem->Pfile );
605
                        }
606
                }
607
        }
608
 
609
        for ( int i = 0; i < srcDoc->Items->count(); ++i )
610
        {
611
                pItem = srcDoc->Items->at ( i );
612
 
613
                if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( pItem->PictureIsAvailable ) && ( !pItem->asLatexFrame() ) )
614
                {
615
                        if ( ( id == 0 ) || ( ( id-1 ) == pItem->OwnPage ) )
616
                        {
617
                                imageFiles.append ( pItem->Pfile );
618
                        }
619
                }
620
        }
621
 
622
//todo: check if item is selected: item->isSelected()
623
 
624
 
625
        pImages->createPreviewImagesList ( imageFiles );
626
 
627
        updateBrowser ( true, true, false );
628
}
629
 
630
 
631
void PictureBrowser::collectionChosen ( QTreeWidgetItem * item, int column )
632
{
633
        QString collectionFile = item->data ( 0, Qt::UserRole ).toString();
634
 
13658 cbradney 635
        if ( collectionFile == "Category" )
13520 pierre 636
        {
637
                return;
638
        }
639
 
640
        currCollectionFile = collectionFile;
641
 
642
        if ( !crt )
643
        {
644
                crt = new collectionReaderThread ( currCollectionFile, false );
645
                connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
646
                crt->start();
647
        }
648
        else
649
        {
650
                crt->restart();
651
        }
652
}
653
 
654
 
655
void PictureBrowser::collectionsWidgetItemEdited ( QTreeWidgetItem * item, int column )
656
{
657
        saveCollectionsDb();
658
}
659
 
660
 
661
void PictureBrowser::findImagesThreadFinished()
662
{
663
        if ( fit->restartThread )
664
        {
665
                delete fit;
666
 
667
                //maybe the state of folderBrowserIncludeSubdirs needs to be saved when canceling the old thread
668
                fit = new findImagesThread ( currPath, nameFilters, QDir::Name, folderBrowserIncludeSubdirs );
669
                connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ) );
670
                fit->start();
671
        }
672
        else
673
        {
674
                pImages->createPreviewImagesList ( fit->imageFiles );
675
 
676
                updateBrowser ( true, true, false );
677
 
678
                delete fit;
679
                fit = 0;
680
        }
681
}
682
 
683
 
684
void PictureBrowser::collectionReaderThreadFinished()
685
{
686
        if ( crt->restartThread )
687
        {
688
                bool import = crt->import;
689
                delete crt;
690
 
691
                crt = new collectionReaderThread ( currCollectionFile, import );
692
                connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
693
                crt->start();
694
 
695
                return;
696
        }
697
 
698
        switch ( crt->type )
699
        {
700
                case 0:
13658 cbradney 701
                        QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "File not found or file is not a collection file" ) );
13520 pierre 702
                        break;
703
 
704
                case 1:
705
                        collectionsDb += crt->collectionsSet;
706
 
707
                        updateCollectionsWidget ( false );
708
                        updateCollectionsAddImagesCombobox();
709
                        break;
710
 
711
                case 2:
712
                        if ( crt->import )
713
                        {
714
                                collectionsWidget->blockSignals ( true );
715
 
716
                                QTreeWidgetItem *currItem = collectionsWidget->currentItem();
717
 
718
                                if ( !currItem )
719
                                {
720
                                        currItem = collectionsWidget->topLevelItem ( 0 );
721
 
722
                                        if ( !currItem )
723
                                        {
13658 cbradney 724
                                                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to create a category first" ) );
13520 pierre 725
                                                return;
726
                                        }
727
                                }
728
 
729
                                QTreeWidgetItem *tmpItem;
730
 
731
                                if ( currItem->parent() )
732
                                {
733
                                        tmpItem = new QTreeWidgetItem ( currItem->parent(), QStringList ( crt->collection->name ) );
734
                                }
735
                                else
736
                                {
737
                                        tmpItem = new QTreeWidgetItem ( currItem, QStringList ( crt->collection->name ) );
738
                                }
739
 
740
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
741
                                tmpItem->setData ( 0, Qt::UserRole, crt->collection->file );
742
                                tmpItem->setIcon ( 0, *iconCollection );
743
                                collectionsWidget->blockSignals ( false );
744
 
745
                                collectionsWidget->setCurrentItem ( tmpItem );
746
                                saveCollectionsDb();
747
                        }
748
 
749
                        currCollection = crt->collection;
750
                        pImages->createPreviewImagesList ( currCollection );
751
 
752
                        //update view
753
                        updateBrowser ( true, true, false );
754
                        updateCollectionsAddImagesCombobox();
755
                        break;
756
 
757
                default:
758
                        break;
759
        }
760
 
761
        delete crt;
762
        crt = 0;
763
}
764
 
765
 
766
void PictureBrowser::collectionListReaderThreadFinished()
767
{
768
        /*      if(clrt->restartThread)
769
                {
770
                delete clrt;
771
 
772
                clrt = new collectionListReaderThread(collections);
773
                connect(clrt, SIGNAL(finished()), this, SLOT(collectionListReaderThreadFinished()));
774
                clrt->start();
775
                }
776
                else
777
                {
778
                pImages->createPreviewImagesList(clrt->imageFiles);
779
 
780
                updateBrowser(true, true, false);
781
 
782
                delete clrt;
783
                clrt = 0;
784
                }*/
785
}
786
 
787
 
788
void PictureBrowser::collectionReaderThreadListFinishedSave()
789
{
790
        collectionReaderThread *tmpCrt;
791
        collectionWriterThread *tmpCwt;
792
        imageCollection *tmpCollection;
793
 
794
        for ( int i = 0 ; i < crtList.size() ; ++i )
795
        {
796
                tmpCrt = crtList.at ( i );
797
 
798
                if ( tmpCrt->isFinished() )
799
                {
800
                        QStringList tmpTags;
801
 
802
                        if ( !tmpCrt->type )
803
                        {
13658 cbradney 804
                                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), QString ( "A collection was not found:\n%1\nit will be created" ).arg ( tmpCrt->xmlFile ) );
13520 pierre 805
                                tmpCollection = new imageCollection;
806
                                tmpCollection->imageFiles = tmpCrt->addImages;
807
                        }
808
                        else
809
                        {
810
                                tmpCollection = tmpCrt->collection;
811
                                tmpCollection->imageFiles += tmpCrt->addImages;
812
                        }
813
 
814
                        //add empty tags for list consistency
815
                        for ( int j = 0 ; j < tmpCrt->addImages.size() ; ++j )
816
                        {
817
                                tmpCollection->tags.append ( tmpTags );
818
                        }
819
 
820
                        tmpCwt = new collectionWriterThread ( tmpCrt->xmlFile, *tmpCollection );
821
                        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
822
                        cwtList.append ( tmpCwt );
823
                        tmpCwt->start();
824
 
825
                        delete tmpCollection;
826
                        delete crtList.takeAt ( i );
827
                }
828
        }
829
}
830
 
831
 
832
void PictureBrowser::collectionsDbWriterThreadFinished()
833
{
834
        if ( cdbwt->restartThread )
835
        {
836
                delete cdbwt;
837
 
838
                cdbwt = new collectionsWriterThread ( cdbFile, collectionsDb );
839
                connect ( cdbwt, SIGNAL ( finished() ), this, SLOT ( collectionsDbWriterThreadFinished() ) );
840
                cdbwt->start();
841
        }
842
        else
843
        {
844
                delete cdbwt;
845
                cdbwt = 0;
846
        }
847
}
848
 
849
 
850
void PictureBrowser::collectionWriterThreadListFinished()
851
{
852
        for ( int i = 0 ; i < cwtList.size() ; ++i )
853
        {
854
                if ( cwtList.at ( i )->isFinished() )
855
                {
856
                        delete cwtList.takeAt ( i );
857
                }
858
        }
859
}
860
 
861
 
862
void PictureBrowser::insertPagesComboboxCheckstateChanged ( int row )
863
{
864
        int tmpState = insertPagesCombobox->checkstate ( 1 );
865
 
866
        if ( row == 1 )
867
        {
868
                int itemsCount = insertPagesCombobox->count();
869
 
870
                for ( int i = 2 ; i < itemsCount ; ++i )
871
                {
872
                        insertPagesCombobox->setCheckstate ( i, tmpState );
873
                }
874
        }
875
        else if ( ( tmpState == 1 ) && ( row > 1 ) )
876
        {
877
                insertPagesCombobox->setCheckstate ( 1, 0 );
878
        }
879
 
880
        insertPagesCombobox->setCurrentIndex ( row );
881
}
882
 
883
 
884
void PictureBrowser::insertImageButtonClicked()
885
{
886
        if ( ( previewIconIndex < 0 ) || ( previewIconIndex > pModel->modelItemsList.size() ) )
887
        {
13658 cbradney 888
                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No image(s) selected" ) );
13520 pierre 889
                return;
890
        }
891
 
892
        previewImage *tmpImage;
893
 
894
//image from pModel needed here
895
        tmpImage = pModel->modelItemsList.at ( previewIconIndex );
896
        InsertAFrameData iafData;
897
 
898
        iafData.frameType=PageItem::ImageFrame;
899
        iafData.source=tmpImage->fileInformation.absoluteFilePath();
900
 
901
        QString pageList = "";
902
 
903
        if ( insertPagesCombobox->checkstate ( 1 ) == 1 )
904
        {
905
                iafData.locationType = 1;
906
        }
907
        else
908
        {
909
                iafData.locationType = 2;
910
 
911
                //current page has been selected
912
                if ( insertPagesCombobox->checkstate ( 0 ) == 1 )
913
                {
914
                        int currPage = srcDoc->currentPageNumber() + 1;
915
 
916
                        //prevent double insert, only add current page to pagelist if the page isn't selected yet
917
                        if ( insertPagesCombobox->checkstate ( currPage + 1 ) == 0 )
918
                        {
919
                                pageList += QString ( "%1," ).arg ( currPage );
920
                        }
921
                }
922
 
923
                for ( int i = 2 ; i < insertPagesCombobox->count() ; ++i )
924
                {
925
                        if ( insertPagesCombobox->checkstate ( i ) == 1 )
926
                        {
927
                                pageList += QString ( "%1," ).arg ( i-1 );
928
                        }
929
                }
930
 
931
                if ( pageList.isEmpty() )
932
                {
13658 cbradney 933
                        QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No page/image frame selected" ) );
13520 pierre 934
                        return;
935
                }
936
 
937
                pageList.chop ( 1 );
938
        }
939
 
940
        iafData.pageList = pageList;
941
        iafData.positionType = insertPositionCombobox->currentIndex();
942
        iafData.sizeType = insertSizeCombobox->currentIndex();
943
        iafData.x = insertPositionXSpinbox->value();
944
        iafData.y = insertPositionYSpinbox->value();
945
        iafData.width = insertWidthSpinbox->value();
946
        iafData.height = insertHeightSpinbox->value();
947
 
948
        /*dont need all this crap */
949
//iafData.impsetup=m_ImportSetup;
950
        iafData.columnCount = 0;
951
        iafData.columnGap = 0;
952
        iafData.linkTextFrames = false;
953
        iafData.linkToExistingFrame = false;
954
        iafData.linkToExistingFramePtr=NULL;
955
 
956
        tmpImage->insertIntoDocument ( srcDoc, iafData );
957
}
958
 
959
 
960
void PictureBrowser::insertPositionComboboxChanged ( int index )
961
{
962
        if ( ( index == 3 ) && !insertCustomPosition )
963
        {
964
                insertPositionXSpinbox->setEnabled ( true );
965
                insertPositionYSpinbox->setEnabled ( true );
966
                insertPositionXLabel->setEnabled ( true );
967
                insertPositionYLabel->setEnabled ( true );
968
                insertCustomPosition = true;
969
        }
970
        else if ( insertCustomPosition )
971
        {
972
                insertPositionXSpinbox->setEnabled ( false );
973
                insertPositionYSpinbox->setEnabled ( false );
974
                insertPositionXLabel->setEnabled ( false );
975
                insertPositionYLabel->setEnabled ( false );
976
                insertCustomPosition = false;
977
        }
978
}
979
 
980
 
981
void PictureBrowser::insertSizeComboboxChanged ( int index )
982
{
983
        if ( ( index == 3 ) && !insertCustomSize )
984
        {
985
                insertWidthSpinbox->setEnabled ( true );
986
                insertHeightSpinbox->setEnabled ( true );
987
                insertWidthLabel->setEnabled ( true );
988
                insertHeightLabel->setEnabled ( true );
989
                insertCustomSize = true;
990
        }
991
        else if ( insertCustomSize )
992
        {
993
                insertWidthSpinbox->setEnabled ( false );
994
                insertHeightSpinbox->setEnabled ( false );
995
                insertWidthLabel->setEnabled ( false );
996
                insertHeightLabel->setEnabled ( false );
997
                insertCustomSize = false;
998
        }
999
}
1000
 
1001
 
1002
void PictureBrowser::filterCriteriaComboboxChanged ( int index )
1003
{
1004
        //this check shouldnt be necessary but you never know...
1005
        if ( ( index >= 0 ) && ( index < 5 ) )
1006
        {
1007
                filterStackedwidget->setCurrentIndex ( index );
1008
        }
1009
}
1010
 
1011
 
1012
void PictureBrowser::filterTargetComboboxChanged ( int index )
1013
{
1014
        if ( ( index >= 0 ) && ( index < 3 ) )
1015
        {
1016
                filterTargetStackedWidget->setCurrentIndex ( index );
1017
        }
1018
 
1019
        if ( index == 1 )
1020
        {
1021
                filterFilterButton->setText ( "Search" );
1022
        }
1023
        else
1024
        {
1025
                filterFilterButton->setText ( "Apply Filters" );
1026
        }
1027
}
1028
 
1029
 
1030
void PictureBrowser::filterFilterButtonClicked()
1031
{
1032
        if ( filterTargetCombobox->currentIndex() == 1 )
1033
        {
1034
                QString searchDir = filterSearchLineedit->text();
1035
                QDir dir ( searchDir );
1036
 
1037
                if ( !dir.exists() )
1038
                {
13658 cbradney 1039
                        QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "Directory does not exist" ) );
13520 pierre 1040
                        return;
1041
                }
1042
 
1043
                currPath = searchDir;
1044
 
1045
                if ( !fit )
1046
                {
1047
                        fit = new findImagesThread ( currPath, nameFilters, QDir::Name, true );
1048
                        connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ) );
1049
                        fit->start();
1050
                }
1051
                else
1052
                {
1053
                        fit->restart();
1054
                }
1055
        }
1056
        else if ( filterTargetCombobox->currentIndex() == 2 )
1057
        {
1058
                /*      if(!clrt)
1059
                        {
1060
                        clrt = new collectionListReaderThread(collections);
1061
                        connect(clrt, SIGNAL(finished()), this, SLOT(collectionListReaderThreadFinished()));
1062
                        clrt->start();
1063
                        }
1064
                        else
1065
                        {
1066
                        clrt->restart();
1067
                        }*/
1068
        }
1069
        else
1070
        {
1071
                updateBrowser ( true, false, false );
1072
        }
1073
}
1074
 
1075
 
1076
void PictureBrowser::filterClearButtonClicked()
1077
{
1078
        pImages->clearFilters();
1079
        filterFiltersListwidget->clear();
1080
 
1081
        delete filters;
1082
        filters = new imageFilters;
1083
 
1084
        updateBrowser ( true, false, false );
1085
}
1086
 
1087
 
1088
void PictureBrowser::filterAddCriterionButtonClicked()
1089
{
1090
        QListWidgetItem *newItem = new QListWidgetItem;
1091
 
1092
        newItem->setFlags ( Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
1093
        newItem->setCheckState ( Qt::Checked );
1094
 
1095
        int index = filterCriteriaCombobox->currentIndex();
13658 cbradney 1096
        QString filterText = "Empty Filter";
13520 pierre 1097
 
1098
        if ( index == 0 )
1099
        {
1100
                if ( filterNameCombobox->currentIndex() == 0 )
1101
                {
13658 cbradney 1102
                        filterText = QString ( "Name contains \"%1\"" ).arg ( filterNameLineedit->text() );
13520 pierre 1103
                        filters->nameInverts.append ( true );
1104
                }
1105
                else
1106
                {
13658 cbradney 1107
                        filterText = QString ( "Name does not contain \"%1\"" ).arg ( filterNameLineedit->text() );
13520 pierre 1108
                        filters->nameInverts.append ( false );
1109
                }
1110
 
1111
                filters->nameFilters.append ( filterNameLineedit->text() );
1112
        }
1113
        else if ( index == 1 )
1114
        {
1115
                if ( filterDateCombobox->currentIndex() == 0 )
1116
                {
13658 cbradney 1117
                        filterText = QString ( "Newer than %1" ).arg ( filterDateDatetimeedit->dateTime().toString ( "dd.MM.yyyy hh:mm" ) );
13520 pierre 1118
                        filters->dateInverts.append ( false );
1119
                }
1120
                else
1121
                {
13658 cbradney 1122
                        filterText = QString ( "Older than %1" ).arg ( filterDateDatetimeedit->dateTime().toString ( "dd.MM.yyyy hh:mm" ) );
13520 pierre 1123
                        filters->dateInverts.append ( true );
1124
                }
1125
 
1126
                filters->dateFilters.append ( filterDateDatetimeedit->dateTime() );
1127
        }
1128
        else if ( index == 2 )
1129
        {
1130
                if ( filterSizeCombobox->currentIndex() == 0 )
1131
                {
13658 cbradney 1132
                        filterText = QString ( "Smaller than %1 KB" ).arg ( filterSizeSpinbox->value() );
13520 pierre 1133
                        filters->sizeInverts.append ( true );
1134
                }
1135
                else
1136
                {
13658 cbradney 1137
                        filterText = QString ( "Bigger than %1 KB" ).arg ( filterSizeSpinbox->value() );
13520 pierre 1138
                        filters->sizeInverts.append ( false );
1139
                }
1140
 
1141
                filters->sizeFilters.append ( filterSizeSpinbox->value() );
1142
        }
1143
        else if ( index == 3 )
1144
        {
1145
                QStringList types;
13658 cbradney 1146
                filterText = QString ( "Allowed types: " );
13520 pierre 1147
 
1148
                if ( filterTypeCombobox->checkstate ( 0 ) == 1 )
1149
                {
13658 cbradney 1150
                        filterText += QString ( "All supported types (really a useful filter...)" );
13520 pierre 1151
                        types = nameFilters;
1152
                }
1153
                else
1154
                {
1155
                        int itemsCount = filterTypeCombobox->count();
1156
 
1157
                        for ( int i = 1 ; i < itemsCount ; ++i )
1158
                        {
1159
                                if ( filterTypeCombobox->checkstate ( i ) == 1 )
1160
                                {
1161
                                        filterText += QString ( "\"%1\", " ).arg ( nameFilters.at ( i - 1 ) );
1162
                                        types.append ( nameFilters.at ( i - 1 ) );
1163
                                }
1164
                        }
1165
                }
1166
 
1167
                filters->typeFilters.append ( types );
1168
        }
1169
        else if ( index == 4 )
1170
        {
1171
                QStringList tags;
13658 cbradney 1172
                filterText = QString ( "Has tags: " );
13520 pierre 1173
 
1174
                int itemsCount = filterTagsCombobox->count();
1175
 
1176
                for ( int i = 1 ; i < itemsCount ; ++i )
1177
                {
1178
                        if ( filterTagsCombobox->checkstate ( i ) == 1 )
1179
                        {
1180
                                filterText += QString ( "\"%1\", " ).arg ( filterTagsCombobox->itemText ( i ) );
1181
                                tags.append ( filterTagsCombobox->itemText ( i ) );
1182
                        }
1183
                }
1184
 
1185
                filters->tagFilters.append ( tags );
1186
        }
1187
 
1188
        filters->filterMap.append ( index );
1189
 
1190
        newItem->setText ( filterText );
1191
        filterFiltersListwidget->addItem ( newItem );
1192
}
1193
 
1194
 
1195
void PictureBrowser::filterSearchDirButtonClicked()
1196
{
1197
        QString searchDir = QFileDialog::getExistingDirectory ( this, tr ( "Select Directory" ), QDir::rootPath(), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks );
1198
        filterSearchLineedit->setText ( searchDir );
1199
}
1200
 
1201
 
1202
void PictureBrowser::collectionsNewCategoryButtonClicked()
1203
{
1204
        collectionsWidget->blockSignals ( true );
1205
 
1206
        QTreeWidgetItem *tmpCategory;
1207
 
1208
        tmpCategory = new QTreeWidgetItem ( collectionsWidget, QStringList ( "New Category" ) );
1209
        tmpCategory->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
13658 cbradney 1210
        tmpCategory->setData ( 0, Qt::UserRole, QString ( "Category" ) );
13520 pierre 1211
        tmpCategory->setExpanded ( true );
1212
 
1213
        collectionsWidget->blockSignals ( false );
1214
 
1215
        collectionsWidget->setCurrentItem ( tmpCategory );
1216
        collectionsWidget->editItem ( tmpCategory );
1217
 
1218
        saveCollectionsDb();
1219
}
1220
 
1221
 
1222
void PictureBrowser::collectionsNewButtonClicked()
1223
{
1224
        collectionsWidget->blockSignals ( true );
1225
 
1226
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1227
 
1228
        if ( !currItem )
1229
        {
1230
                currItem = collectionsWidget->topLevelItem ( 0 );
1231
 
1232
                if ( !currItem )
1233
                {
13658 cbradney 1234
                        QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to create a category first" ) );
13520 pierre 1235
                        return;
1236
                }
1237
        }
1238
 
1239
        QTreeWidgetItem *parentItem, *tmpItem;
13608 jghali 1240
        QString newCollectionFile = ScPaths::instance().getPluginDataDir();
13520 pierre 1241
 
1242
        parentItem = currItem->parent();
1243
 
1244
        if ( parentItem )
1245
        {
1246
                tmpItem = new QTreeWidgetItem ( parentItem, QStringList ( "New Collection" ) );
1247
                newCollectionFile += QString ( "c%1_%2.sic" ).arg ( collectionsWidget->indexOfTopLevelItem ( parentItem ) ).arg ( parentItem->childCount() );
1248
        }
1249
        else
1250
        {
1251
                tmpItem = new QTreeWidgetItem ( currItem, QStringList ( "New Collection" ) );
1252
                newCollectionFile += QString ( "c%1_%2.sic" ).arg ( collectionsWidget->indexOfTopLevelItem ( currItem ) ).arg ( currItem->childCount() );
1253
        }
1254
 
1255
        tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1256
        tmpItem->setData ( 0, Qt::UserRole, newCollectionFile );
1257
        tmpItem->setIcon ( 0, *iconCollection );
1258
        collectionsWidget->blockSignals ( false );
1259
 
1260
        collectionsWidget->setCurrentItem ( tmpItem );
1261
        collectionsWidget->editItem ( tmpItem );
1262
 
1263
        saveCollectionsDb();
1264
 
1265
        imageCollection tmpCollection;
1266
        collectionWriterThread *tmpCwt;
1267
        tmpCwt = new collectionWriterThread ( newCollectionFile, tmpCollection );
1268
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1269
        cwtList.append ( tmpCwt );
1270
        tmpCwt->start();
1271
}
1272
 
1273
 
1274
void PictureBrowser::collectionsImportButtonClicked()
1275
{
13658 cbradney 1276
        QString fileName = QFileDialog::getOpenFileName ( this, tr ( "Import Image Collection" ), QDir::rootPath(), tr ( "Scribus ImageCollection (*.sic)" ) );
13520 pierre 1277
 
1278
        if ( !fileName.isEmpty() )
1279
        {
1280
                currCollectionFile = fileName;
1281
 
1282
                if ( !crt )
1283
                {
1284
                        crt = new collectionReaderThread ( currCollectionFile, true );
1285
                        connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
1286
                        crt->start();
1287
                }
1288
                else
1289
                {
1290
                        crt->restart();
1291
                }
1292
        }
1293
}
1294
 
1295
 
1296
void PictureBrowser::collectionsExportButtonClicked()
1297
{
13658 cbradney 1298
        QString fileName = QFileDialog::getSaveFileName ( this, tr ( "Export Image Collection" ), QDir::rootPath(), tr ( "Scribus ImageCollection (*.sic)" ) );
13520 pierre 1299
 
1300
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1301
 
1302
        if ( !currItem )
1303
        {
13658 cbradney 1304
                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to select something you want to export" ) );
13520 pierre 1305
                return;
1306
        }
1307
 
1308
        //collection
1309
        if ( currItem->parent() )
1310
        {
1311
                collectionWriterThread *tmpCwt;
1312
                tmpCwt = new collectionWriterThread ( fileName, *currCollection );
1313
                connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1314
                cwtList.append ( tmpCwt );
1315
                tmpCwt->start();
1316
        }
1317
        //category
1318
        else
1319
        {
1320
 
1321
        }
1322
}
1323
 
1324
 
1325
void PictureBrowser::collectionsDeleteButtonClicked()
1326
{
1327
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1328
 
1329
        if ( !currItem )
1330
        {
1331
                return;
1332
        }
1333
 
1334
        delete currItem;
1335
 
1336
        saveCollectionsDb();
1337
}
1338
 
1339
 
1340
void PictureBrowser::collectionsRenameButtonClicked()
1341
{
1342
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1343
 
1344
        if ( !currItem )
1345
        {
1346
                return;
1347
        }
1348
 
1349
        collectionsWidget->editItem ( currItem );
1350
}
1351
 
1352
 
1353
void PictureBrowser::collectionsAddImagesButtonClicked()
1354
{
1355
        collectionsStackedwidget->setCurrentIndex ( 1 );
1356
        updateCollectionsWidget ( true );
1357
        collectionsWidget->blockSignals ( true );
1358
}
1359
 
1360
 
1361
void PictureBrowser::collectionsSetTagsButtonClicked()
1362
{
1363
        for ( int i = 0 ; i < collectionsTagImagesCombobox->count() ; ++i )
1364
        {
1365
                if ( collectionsTagImagesCombobox->checkstate ( i ) == 0 )
1366
                {
1367
                        for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
1368
                        {
1369
                                pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.removeAll ( collectionsTagImagesCombobox->itemText ( i ) );
1370
                        }
1371
                }
1372
                else if ( collectionsTagImagesCombobox->checkstate ( i ) == 1 )
1373
                {
1374
                        for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
1375
                        {
1376
                                if ( !pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.contains ( collectionsTagImagesCombobox->itemText ( i ) ) )
1377
                                {
1378
                                        pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.append ( collectionsTagImagesCombobox->itemText ( i ) );
1379
                                }
1380
                        }
1381
                }
1382
        }
1383
 
1384
 
1385
        collectionWriterThread *tmpCwt;
1386
 
1387
        currCollection->imageFiles.clear();
1388
        currCollection->tags.clear();
1389
 
1390
        for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1391
        {
1392
                currCollection->imageFiles.append ( pImages->previewImagesList.at ( i )->fileInformation.absoluteFilePath() );
1393
                currCollection->tags.append ( pImages->previewImagesList.at ( i )->tags );
1394
        }
1395
 
1396
        tmpCwt = new collectionWriterThread ( currCollection->file, *currCollection );
1397
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1398
        cwtList.append ( tmpCwt );
1399
        tmpCwt->start();
1400
}
1401
 
1402
 
1403
void PictureBrowser::collectionsAddNewTagButtonClicked()
1404
{
1405
        QString newTag = collectionsAddNewTagLineedit->text();
1406
 
1407
        if ( !newTag.isEmpty() )
1408
        {
1409
                collectionsTagImagesCombobox->addItem ( newTag, 1 );
1410
        }
1411
        else
1412
        {
13658 cbradney 1413
                QMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No tag entered" ) );
13520 pierre 1414
        }
1415
}
1416
 
1417
 
1418
void PictureBrowser::collectionsRemoveImagesButtonClicked()
1419
{
1420
        collectionWriterThread *tmpCwt;
1421
        QList<previewImage *> tmpPreviewImagesList;
1422
 
1423
        for ( int i = 0 ; i < selectedIndexes.size() ; ++i )
1424
        {
1425
                tmpPreviewImagesList.append ( pImages->previewImagesList.takeAt ( selectedIndexes.at ( i ) ) );
1426
        }
1427
 
1428
//update view
1429
        updateBrowser ( false, false, false );
1430
 
1431
        for ( int i = 0 ; i < tmpPreviewImagesList.size() ; ++i )
1432
        {
1433
                delete tmpPreviewImagesList.at ( i );
1434
        }
1435
 
1436
        currCollection->imageFiles.clear();
1437
        currCollection->tags.clear();
1438
 
1439
        for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1440
        {
1441
                currCollection->imageFiles.append ( pImages->previewImagesList.at ( i )->fileInformation.absoluteFilePath() );
1442
                currCollection->tags.append ( pImages->previewImagesList.at ( i )->tags );
1443
        }
1444
 
1445
        tmpCwt = new collectionWriterThread ( currCollection->file, *currCollection );
1446
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1447
        cwtList.append ( tmpCwt );
1448
        tmpCwt->start();
1449
}
1450
 
1451
 
1452
void PictureBrowser::collectionsTagImagesButtonClicked()
1453
{
1454
}
1455
 
1456
 
1457
void PictureBrowser::collectionsAddImagesOkButtonClicked()
1458
{
1459
        QTreeWidgetItem *tmpItem, *tmpItem2;
1460
        QString collectionFile;
1461
        collectionReaderThread *tmpCrt;
1462
 
1463
        QStringList addImages;
1464
 
1465
        for ( int k = 0 ; k < selectedIndexes.size() ; ++k )
1466
        {
1467
                addImages.append ( pModel->modelItemsList.at ( selectedIndexes.at ( k ) )->fileInformation.absoluteFilePath() );
1468
        }
1469
 
1470
 
1471
        for ( int i = 0 ; i < collectionsWidget->topLevelItemCount() ; ++i )
1472
        {
1473
                tmpItem = collectionsWidget->topLevelItem ( i );
1474
 
1475
                for ( int j = 0 ; j < tmpItem->childCount() ; ++j )
1476
                {
1477
                        tmpItem2 = tmpItem->child ( j );
1478
 
1479
                        if ( tmpItem2->checkState ( 0 ) == Qt::Checked )
1480
                        {
1481
                                //add images here
1482
                                collectionFile = tmpItem2->data ( 0, Qt::UserRole ).toString();
1483
 
1484
                                tmpCrt = new collectionReaderThread ( collectionFile, false );
1485
                                tmpCrt->addImages = addImages;
1486
                                connect ( tmpCrt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadListFinishedSave() ) );
1487
                                crtList.append ( tmpCrt );
1488
                                tmpCrt->start();
1489
                        }
1490
                }
1491
        }
1492
 
1493
        collectionsStackedwidget->setCurrentIndex ( 0 );
1494
        updateCollectionsWidget ( false );
1495
        collectionsWidget->blockSignals ( false );
1496
}
1497
 
1498
 
1499
void PictureBrowser::collectionsAddImagesCancelButtonClicked()
1500
{
1501
        collectionsStackedwidget->setCurrentIndex ( 0 );
1502
        updateCollectionsWidget ( false );
1503
        collectionsWidget->blockSignals ( false );
1504
}
1505
 
1506
 
1507
void PictureBrowser::updateBrowser ( bool filter, bool sort, bool reload )
1508
{
1509
        if ( filter )
1510
        {
1511
                applyFilters();
1512
        }
1513
 
1514
        if ( sort )
1515
        {
1516
                pImages->sortPreviewImages ( pbSettings.sortSetting );
1517
        }
1518
 
1519
        if ( reload )
1520
        {
1521
                previewImage *tmpImage;
1522
 
1523
                //force reload, check if needed is necessary
1524
                for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1525
                {
1526
                        tmpImage = pImages->previewImagesList.at ( i );
1527
                        tmpImage->previewImageLoading = false;
1528
                        tmpImage->previewIconCreated = false;
1529
                }
1530
        }
1531
 
1532
        pModel->setModelItemsList ( pImages->previewImagesList );
1533
        statusLabel->setText ( QString ( "%1 image(s) displayed, %2 image(s) filtered" ).arg ( imagesDisplayed ).arg ( imagesFiltered ) );
1534
}
1535
 
1536
 
1537
void PictureBrowser::loadIcons()
1538
{
1539
        iconArrowUp = new QIcon ( loadIcon ( "pitr_green_arrows_set_1.svg" ) );
1540
        iconArrowDown = new QIcon ( loadIcon ( "pitr_green_arrows_set_5.svg" ) );
1541
        iconFolderBrowser = new QIcon ( loadIcon ( "sarxos_Simple_Folder_Seek.svg" ) );
1542
        iconCollectionsBrowser = new QIcon ( loadIcon ( "sarxos_Simple_Green_Yellow_Blue_Violet_Folders.svg" ) );
1543
        iconDocumentBrowser = new QIcon ( loadIcon ( "sarxos_Paper_Sheets.svg" ) );
1544
        iconDocument = new QIcon ( loadIcon ( "doc.png" ) );
1545
        iconCollection = new QIcon ( loadIcon ( "cmyk.png" ) );
1546
        iconOk = new QIcon ( loadIcon ( "ok22.png" ) );
1547
        iconClose = new QIcon ( loadIcon ( "/16/close.png" ) );
1548
        iconZoomPlus = new QIcon ( loadIcon ( "viewmagin.png" ) );
1549
        iconZoomMinus = new QIcon ( loadIcon ( "viewmagout.png" ) );
1550
        iconNew = new QIcon ( loadIcon ( "/16/insert-table.png" ) );
1551
        iconNew2 = new QIcon ( loadIcon ( "/16/document-new.png" ) );
1552
        iconEdit = new QIcon ( loadIcon ( "/16/document-properties.png" ) );
1553
        iconRemove = new QIcon ( loadIcon ( "/16/edit-cut.png" ) );
1554
        iconLoad = new QIcon ( loadIcon ( "/16/document-open.png" ) );
1555
        iconSave = new QIcon ( loadIcon ( "/16/document-save.png" ) );
1556
        iconPlus = new QIcon ( loadIcon ( "/16/list-add.png" ) );
1557
        iconMinus = new QIcon ( loadIcon ( "/16/list-remove.png" ) );
1558
        iconPen = new QIcon ( loadIcon ( "/16/story-editor.png" ) );
1559
 
1560
        collectionsNewCategoryButton->setIcon ( *iconNew );
1561
        collectionsNewButton->setIcon ( *iconNew2 );
1562
        collectionsRenameButton->setIcon ( *iconEdit );
1563
        collectionsDeleteButton->setIcon ( *iconRemove );
1564
        collectionsImportButton->setIcon ( *iconLoad );
1565
        collectionsExportButton->setIcon ( *iconSave );
1566
        collectionsAddImagesButton->setIcon ( *iconPlus );
1567
        collectionsRemoveImagesButton->setIcon ( *iconMinus );
1568
        collectionsTagImagesButton->setIcon ( *iconPen );
1569
        collectionsAddImagesOkButton->setIcon ( *iconOk );
1570
        collectionsAddImagesCancelButton->setIcon ( *iconClose );
1571
 
1572
        navigationBox->setItemIcon ( 0, *iconFolderBrowser );
1573
        navigationBox->setItemIcon ( 1, *iconCollectionsBrowser );
1574
        navigationBox->setItemIcon ( 2, *iconDocumentBrowser );
1575
 
1576
        zoomPlusButton->setIcon ( *iconZoomPlus );
1577
        zoomMinusButton->setIcon ( *iconZoomMinus );
1578
 
1579
        actionsGoButton->setIcon ( *iconOk );
1580
 
1581
        closeButton->setIcon ( *iconClose );
1582
 
1583
        moreButton->setIcon ( *iconArrowDown );
1584
}
1585
 
1586
 
1587
void PictureBrowser::setSettings()
1588
{
1589
//set settings
1590
        if ( pbSettings.saveSettings )
1591
        {
1592
                saveSettingsCheckbox->setCheckState ( Qt::Checked );
1593
        }
1594
 
1595
        if ( pbSettings.showMore )
1596
        {
1597
                expandDialog ( true );
1598
        }
1599
        else
1600
        {
1601
                expandDialog ( false );
1602
        }
1603
 
1604
        if ( pbSettings.sortOrder )
1605
        {
1606
                sortOrderButton->setIcon ( *iconArrowUp );
1607
        }
1608
        else
1609
        {
1610
                sortOrderButton->setIcon ( *iconArrowDown );
1611
        }
1612
 
1613
        sortCombobox->setCurrentIndex ( pbSettings.sortSetting );
1614
        previewModeCombobox->setCurrentIndex ( pbSettings.previewMode );
1615
 
1616
        if ( pbSettings.alwaysOnTop )
1617
        {
1618
                alwaysOnTopCheckbox->setCheckState ( Qt::Checked );
1619
                setAlwaysOnTop ( true );
1620
        }
1621
}
1622
 
1623
void PictureBrowser::changedDocument ( ScribusDoc* doc )
1624
{
1625
        srcDoc = doc;
1626
        updateDocumentbrowser();
1627
        actionsGoButton->setEnabled ( true );
1628
        insertImageButton->setEnabled ( true );
1629
}
1630
 
1631
void PictureBrowser::closedDocument()
1632
{
1633
        documentWidget->clear();
1634
        documentItems.clear();
1635
        srcDoc = NULL;
1636
        pImages->clearPreviewImagesList();
1637
        updateBrowser ( false, false, false );
1638
        actionsGoButton->setEnabled ( false );
1639
        insertImageButton->setEnabled ( false );
1640
}
1641
 
1642
void PictureBrowser::updateDocumentbrowser()
1643
{
1644
        documentWidget->clear();
1645
        documentItems.clear();
13658 cbradney 1646
        QTreeWidgetItem* allpages=new QTreeWidgetItem ( documentWidget, QStringList ( "All Pages" ) );
13520 pierre 1647
        allpages->setData ( 0, Qt::UserRole, 0 );
1648
        allpages->setExpanded ( true );
1649
        documentWidget->addTopLevelItem ( allpages );
1650
 
1651
        QTreeWidgetItem *tmpItem;
1652
 
1653
        for ( int i = 0 ; i < ( int ) ( srcDoc->Pages->count() ) ; ++i )
1654
        {
1655
                tmpItem = new QTreeWidgetItem ( allpages, QStringList ( QString ( "Page %1" ).arg ( i+1 ) ) );
1656
                tmpItem->setData ( 0, Qt::UserRole, ( i+1 ) );
1657
                tmpItem->setIcon ( 0, *iconDocument );
1658
                documentItems.append ( tmpItem );
1659
        }
1660
 
1661
        documentWidget->insertTopLevelItems ( 0, documentItems );
1662
}
1663
 
1664
 
1665
void PictureBrowser::previewImageSelectionChanged ( const QItemSelection & selected, const QItemSelection & deselected )
1666
{
1667
        QItemSelectionModel *selectionModel = imageViewArea->selectionModel();
1668
        QModelIndexList selection = selectionModel->selectedIndexes();
1669
        int tmpIndex;
1670
 
1671
 
1672
        selectedIndexes.clear();
1673
 
1674
        for ( int i = 0 ; i < selection.size() ; ++i )
1675
        {
1676
                tmpIndex = selection.at ( i ).row();
1677
 
1678
                //take filtered images into account
1679
                for ( int j = 0 ; ( j <= tmpIndex ) && ( j < pImages->previewImagesList.size() ) ; ++j )
1680
                {
1681
                        if ( pImages->previewImagesList.at ( j )->filtered )
1682
                        {
1683
                                tmpIndex++;
1684
                        }
1685
                }
1686
 
1687
                selectedIndexes.append ( tmpIndex );
1688
        }
1689
 
1690
        updateTagImagesTab();
1691
}
1692
 
1693
 
1694
void PictureBrowser::updateInformationTab ( int index )
1695
{
1696
        if ( pbSettings.showMore && ( tabWidget->currentIndex() == 0 ) )
1697
        {
1698
                if ( ( index >= 0 ) && ( index < pModel->modelItemsList.size() ) )
1699
                {
1700
                        previewImage *tmpImage;
1701
                        tmpImage = pModel->modelItemsList.at ( index );
1702
 
1703
                        informationFilenameLabel->setText ( tmpImage->fileInformation.fileName() );
1704
                        informationFilepathLabel->setText ( tmpImage->fileInformation.absolutePath() );
13658 cbradney 1705
                        informationFilesizeLabel->setText ( QString ( "%1 Bytes" ).arg ( tmpImage->fileInformation.size() ) );
13520 pierre 1706
                        informationFiledateLabel->setText ( tmpImage->fileInformation.lastModified().toString ( "dd.MM.yyyy hh:mm:ss" ) );
1707
 
1708
                        if ( tmpImage->imgInfo->valid )
1709
                        {
1710
                                QString format;
1711
 
1712
                                switch ( tmpImage->imgInfo->type )
1713
                                {
1714
                                        case 0:
1715
                                                format = tr ( "JPG" );
1716
                                                break;
1717
 
1718
                                        case 1:
1719
                                                format = tr ( "TIFF" );
1720
                                                break;
1721
 
1722
                                        case 2:
1723
                                                format = tr ( "PSD" );
1724
                                                break;
1725
 
1726
                                        case 3:
1727
                                                format = tr ( "EPS/PS" );
1728
                                                break;
1729
 
1730
                                        case 4:
1731
                                                format = tr ( "PDF" );
1732
                                                break;
1733
 
1734
                                        case 5:
1735
                                                format = tr ( "JPG2000" );
1736
                                                break;
1737
 
1738
                                        case 6:
1739
                                                format = tmpImage->fileInformation.suffix().toUpper();
1740
                                                break;
1741
 
1742
                                        case 7:
1743
                                                format = tr ( "emb. PSD" );
1744
                                                break;
1745
 
1746
                                        default:
1747
                                                format = tr ( "not available" );
1748
                                                break;
1749
                                }
1750
 
1751
                                informationFormatLabel->setText ( format );
1752
                                informationColorspaceLabel->setText ( colorSpaceText ( tmpImage->imgInfo->colorspace ) );
1753
                                informationDpiLabel->setText ( QString ( "%1 x %2" ).arg ( tmpImage->imgInfo->xdpi ).arg ( tmpImage->imgInfo->ydpi ) );
13658 cbradney 1754
                                informationWidthLabel->setText ( QString ( "%1 Pixels" ).arg ( tmpImage->imgInfo->width ) );
1755
                                informationHeightLabel->setText ( QString ( "%1 Pixels" ).arg ( tmpImage->imgInfo->height ) );
13520 pierre 1756
                                informationLayersLabel->setText ( QString ( "%1" ).arg ( tmpImage->imgInfo->layers ) );
1757
 
1758
                                if ( tmpImage->imgInfo->embedded )
1759
                                {
13658 cbradney 1760
                                        informationEmbeddedLabel->setText ( QString ( "Yes" ) );
13520 pierre 1761
                                }
1762
                                else
1763
                                {
13658 cbradney 1764
                                        informationEmbeddedLabel->setText ( QString ( "No" ) );
13520 pierre 1765
                                }
1766
 
1767
                                informationProfilenameLabel->setText ( QString ( "%1" ).arg ( tmpImage->imgInfo->profileName ) );
1768
                        }
1769
                }
1770
                else
1771
                {
13658 cbradney 1772
                        informationFilenameLabel->setText ( "No image selected" );
13520 pierre 1773
                }
1774
        }
1775
}
1776
 
1777
 
1778
void PictureBrowser::updateCollectionsWidget ( bool addImages )
1779
{
1780
        collectionsWidget->blockSignals ( true );
1781
        collectionsWidget->clear();
1782
 
1783
        for ( int i = 0 ; i < collectionsDb.size() ; ++i )
1784
        {
1785
                collections *tmpCollections = collectionsDb.at ( i );
1786
 
1787
                QTreeWidgetItem *tmpCategory;
1788
                tmpCategory = new QTreeWidgetItem ( collectionsWidget, QStringList ( tmpCollections->name ) );
1789
                tmpCategory->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
13658 cbradney 1790
                tmpCategory->setData ( 0, Qt::UserRole, QString ( "Category" ) );
13520 pierre 1791
                tmpCategory->setExpanded ( true );
1792
 
1793
                for ( int j = 0 ; j < tmpCollections->collectionNames.size() ; ++j )
1794
                {
1795
                        QTreeWidgetItem *tmpItem;
1796
                        tmpItem = new QTreeWidgetItem ( tmpCategory, QStringList ( tmpCollections->collectionNames.at ( j ) ) );
1797
 
1798
                        if ( addImages )
1799
                        {
1800
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsUserCheckable|Qt::ItemIsEnabled );
1801
                                tmpItem->setCheckState ( 0, Qt::Unchecked );
1802
                        }
1803
                        else
1804
                        {
1805
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1806
                        }
1807
 
1808
                        tmpItem->setData ( 0, Qt::UserRole, tmpCollections->collectionFiles.at ( j ) );
1809
                        tmpItem->setIcon ( 0, *iconCollection );
1810
                }
1811
        }
1812
 
1813
        collectionsWidget->blockSignals ( false );
1814
}
1815
 
1816
 
1817
void PictureBrowser::updateCollectionsAddImagesCombobox()
1818
{
1819
        /*
1820
        collections *tmpCollections;
1821
 
1822
                for(int i = 0 ; i < collectionsDb.size() ; ++i)
1823
                {
1824
                tmpCollections = collectionsDb.at(i);
1825
 
1826
                        for(int j = 0 ; j < tmpCollections->collectionNames.size() ; ++j)
1827
                        {
1828
                        collectionsAddImagesCombobox->addItem(QString("%1/%2").arg(tmpCollections->name).arg(tmpCollections->collectionNames.at(j)), false);
1829
                        }
1830
                }*/
1831
}
1832
 
1833
 
1834
void PictureBrowser::expandDialog ( bool expand )
1835
{
1836
        if ( expand )
1837
        {
1838
                tabWidget->show();
1839
 
1840
                resize ( 872, 550 );
13658 cbradney 1841
                moreButton->setText ( "Hide" );
13520 pierre 1842
                moreButton->setIcon ( *iconArrowUp );
1843
        }
1844
        else
1845
        {
1846
                tabWidget->hide();
1847
 
1848
                resize ( 872, 385 );
13658 cbradney 1849
                moreButton->setText ( "More" );
13520 pierre 1850
                moreButton->setIcon ( *iconArrowDown );
1851
        }
1852
}
1853
 
1854
 
1855
void PictureBrowser::setAlwaysOnTop ( bool alwaysOnTop )
1856
{
1857
        Qt::WindowFlags flags = windowFlags();
1858
 
1859
//save current position of the window
1860
        QPoint pos = mapToParent ( QPoint ( 0, 0 ) );
1861
 
1862
        if ( alwaysOnTop )
1863
        {
1864
                flags |= Qt::WindowStaysOnTopHint;
1865
        }
1866
        else
1867
        {
1868
                flags ^= Qt::WindowStaysOnTopHint;
1869
        }
1870
 
1871
        this->setWindowFlags ( flags );
1872
 
1873
//move to previous position
1874
        move ( pos );
1875
 
1876
//FIXME: calling setWindowFlags sets window invisible (odd behaviour, documented). causes flickering
1877
        this->show();
1878
}
1879
 
1880
 
1881
void PictureBrowser::saveCollectionsDb()
1882
{
1883
        QTreeWidgetItem *tmpItem, *tmpItem2;
1884
        collections *tmpCollections;
1885
 
1886
        for ( int i = 0 ; i < collectionsDb.size() ; ++i )
1887
        {
1888
                delete collectionsDb.at ( i );
1889
        }
1890
 
1891
        collectionsDb.clear();
1892
 
1893
 
1894
        for ( int i = 0 ; i < collectionsWidget->topLevelItemCount() ; ++i )
1895
        {
1896
                tmpItem = collectionsWidget->topLevelItem ( i );
1897
 
1898
                tmpCollections = new collections ( tmpItem->text ( 0 ) );
1899
                collectionsDb.append ( tmpCollections );
1900
 
1901
                for ( int j = 0 ; j < tmpItem->childCount() ; ++j )
1902
                {
1903
                        tmpItem2 = tmpItem->child ( j );
1904
                        tmpCollections->collectionNames.append ( tmpItem2->text ( 0 ) );
1905
                        tmpCollections->collectionFiles.append ( tmpItem2->data ( 0, Qt::UserRole ).toString() );
1906
                }
1907
        }
1908
 
1909
 
1910
        if ( !cdbwt )
1911
        {
1912
                cdbwt = new collectionsWriterThread ( cdbFile, collectionsDb );
1913
                connect ( cdbwt, SIGNAL ( finished() ), this, SLOT ( collectionsDbWriterThreadFinished() ) );
1914
                cdbwt->start();
1915
        }
1916
        else
1917
        {
1918
                cdbwt->restart();
1919
        }
1920
}
1921
 
1922
 
1923
void PictureBrowser::applyFilters()
1924
{
1925
        QListWidgetItem *item;
1926
        int c[5] = {0, 0, 0, 0, 0};
1927
        int filterType;
1928
 
1929
        pImages->clearFilters();
1930
 
1931
        for ( int i = 0 ; i < filterFiltersListwidget->count() ; ++i )
1932
        {
1933
                item = filterFiltersListwidget->item ( i );
1934
                filterType = filters->filterMap.at ( i );
1935
 
1936
                if ( item->checkState() == Qt::Checked )
1937
                {
1938
                        switch ( filterType )
1939
                        {
1940
                                case 0:
1941
                                        if ( c[0] < filters->nameFilters.size() )
1942
                                        {
1943
                                                pImages->filterFileName ( filters->nameFilters.at ( c[0] ), filters->nameInverts.at ( c[0] ) );
1944
                                        }
1945
                                        break;
1946
 
1947
                                case 1:
1948
                                        if ( c[1] < filters->dateFilters.size() )
1949
                                        {
1950
                                                pImages->filterFileModified ( filters->dateFilters.at ( c[1] ), filters->dateInverts.at ( c[1] ) );
1951
                                        }
1952
                                        break;
1953
 
1954
                                case 2:
1955
                                        if ( c[2] < filters->sizeFilters.size() )
1956
                                        {
1957
                                                pImages->filterFileSize ( ( filters->sizeFilters.at ( c[2] ) *1024 ), filters->sizeInverts.at ( c[2] ) );
1958
                                        }
1959
                                        break;
1960
 
1961
                                case 3:
1962
                                        if ( c[3] < filters->typeFilters.size() )
1963
                                        {
1964
                                                pImages->filterFileType ( filters->typeFilters.at ( c[3] ), true );
1965
                                        }
1966
                                case 4:
1967
                                        if ( c[4] < filters->tagFilters.size() )
1968
                                        {
1969
                                                pImages->filterTag ( filters->tagFilters.at ( c[4] ), true );
1970
                                        }
1971
                                        break;
1972
                        }
1973
                }
1974
 
1975
                c[filterType]++;
1976
        }
1977
}
1978
 
1979
 
1980
void PictureBrowser::updateTagImagesTab()
1981
{
1982
        QStringList tmpTags, tmpTagList;
1983
 
1984
 
1985
        collectionsSelectedImagesListwidget->clear();
1986
        collectionsTagImagesCombobox->clear();
1987
 
1988
 
1989
        for ( int i = 0 ; ( i < selectedIndexes.size() ) && ( i < currCollection->imageFiles.size() ) ; ++i )
1990
        {
1991
                new QListWidgetItem ( pImages->previewImagesList.at ( selectedIndexes.at ( i ) )->fileInformation.absoluteFilePath(), collectionsSelectedImagesListwidget );
1992
        }
1993
 
1994
        for ( int i = 0 ; i < currCollection->tags.size() ; ++i )
1995
        {
1996
                tmpTags = currCollection->tags.at ( i );
1997
 
1998
                for ( int j = 0 ; j < tmpTags.size() ; ++j )
1999
                {
2000
                        if ( !tmpTagList.contains ( tmpTags.at ( j ) ) )
2001
                        {
2002
                                tmpTagList.append ( tmpTags.at ( j ) );
2003
                        }
2004
                }
2005
        }
2006
 
2007
 
2008
        for ( int i = 0 ; i < tmpTagList.size() ; ++i )
2009
        {
2010
                collectionsTagImagesCombobox->addItem ( tmpTagList.at ( i ), 0 );
2011
 
2012
                int tagCount=0;
2013
 
2014
                for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
2015
                {
2016
                        if ( pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.contains ( tmpTagList.at ( i ) ) )
2017
                        {
2018
                                tagCount++;
2019
                        }
2020
                        else if ( tagCount > 0 )
2021
                        {
2022
                                break;
2023
                        }
2024
                }
2025
 
2026
                if ( tagCount == selectedIndexes.size() )
2027
                {
2028
                        collectionsTagImagesCombobox->setCheckstate ( i, 1 );
2029
                }
2030
                else if ( tagCount > 0 )
2031
                {
2032
                        collectionsTagImagesCombobox->setCheckstate ( i, 2 );
2033
                }
2034
        }
2035
}
2036
 
2037
 
2038
ImageInformation::ImageInformation()
2039
{
2040
}
2041
 
2042
 
2043
previewImage::previewImage ( QString imageFile )
2044
{
2045
        filtered = false;
2046
        previewIconCreated = false;
2047
        previewImageLoading = false;
2048
 
2049
        fileInformation.setFile ( imageFile );
2050
//enable caching
2051
        fileInformation.setCaching ( true );
2052
}
2053
 
2054
 
2055
//nothing to do yet
2056
previewImage::~previewImage()
2057
{
2058
}
2059
 
2060
 
2061
bool previewImage::createPreviewIcon ( const QImage &image, int size )
2062
{
2063
        QPainter p;
2064
//width/height of our icon (exclusive 1px border)
2065
 
2066
        previewIcon = QPixmap ( size, size );
2067
 
2068
        QBrush b ( QColor ( 205,205,205 ), loadIcon ( "testfill.png" ) );
2069
 
2070
        p.begin ( &previewIcon );
2071
 
2072
        p.setPen ( QPen ( Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin ) );
2073
        p.setBrush ( b );
2074
        p.drawRect ( 0, 0, size-1, size-1 );
2075
 
2076
        p.drawImage ( ( ( size - image.width() ) / 2 ), ( ( size - image.height() ) / 2 ), image );
2077
 
2078
        p.end();
2079
 
2080
        previewIconCreated = true;
2081
        currentSize = size;
2082
 
2083
        return true;
2084
}
2085
 
2086
 
2087
bool previewImage::insertIntoDocument ( ScribusDoc *doc, InsertAFrameData &iafData )
2088
{
2089
//adding imageframe
2090
        doc->itemAddUserFrame ( iafData );
2091
 
2092
        return true;
2093
}
2094
 
2095
 
2096
bool previewImage::insertIntoImageFrame ( ScribusDoc *doc, PageItem *imageFrame )
2097
{
2098
        //inserting image
2099
        if ( !imageFrame->loadImage ( fileInformation.absoluteFilePath(), false, -1, true ) )
2100
        {
2101
                return false;
2102
        }
2103
 
2104
        return true;
2105
}
2106
 
2107
 
2108
previewImages::previewImages ( const QStringList& imageFiles )
2109
{
2110
        createPreviewImagesList ( imageFiles );
2111
}
2112
 
2113
 
2114
void previewImages::createPreviewImagesList ( const QStringList& imageFiles )
2115
{
2116
        //if there are already previewimages allocated, remove them
2117
        if ( previewImagesList.size() > 0 )
2118
        {
2119
                clearPreviewImagesList();
2120
        }
2121
 
2122
        if ( imageFiles.isEmpty() )
2123
        {
2124
                return;
2125
        }
2126
 
2127
 
2128
        int s = imageFiles.size();
2129
        previewImage *tmpPreviewImage;
2130
 
2131
        for ( int i = 0 ; i < s ; ++i )
2132
        {
2133
                tmpPreviewImage = new previewImage ( imageFiles.at ( i ) );
2134
                previewImagesList.append ( tmpPreviewImage );
2135
        }
2136
}
2137
 
2138
 
2139
void previewImages::createPreviewImagesList ( const imageCollection *collection )
2140
{
2141
        //if there are already previewimages allocated, remove them
2142
        if ( previewImagesList.size() > 0 )
2143
        {
2144
                clearPreviewImagesList();
2145
        }
2146
 
2147
        if ( collection->imageFiles.isEmpty() )
2148
        {
2149
                return;
2150
        }
2151
 
2152
 
2153
        int s = collection->imageFiles.size();
2154
        previewImage *tmpPreviewImage;
2155
 
2156
        for ( int i = 0 ; i < s ; ++i )
2157
        {
2158
                tmpPreviewImage = new previewImage ( collection->imageFiles.at ( i ) );
2159
                tmpPreviewImage->tags = collection->tags.at ( i );
2160
                previewImagesList.append ( tmpPreviewImage );
2161
        }
2162
}
2163
 
2164
 
2165
void previewImages::clearPreviewImagesList()
2166
{
2167
        int s = previewImagesList.size();
2168
 
2169
        for ( int i = 0 ; i < s ; ++i )
2170
        {
2171
                delete previewImagesList.at ( i );
2172
        }
2173
 
2174
        previewImagesList.clear();
2175
}
2176
 
2177
 
2178
bool previewImages::toRemove ( bool a, bool b )
2179
{
2180
        if ( a )
2181
        {
2182
                if ( !b )
2183
                {
2184
                        return true;
2185
                }
2186
        }
2187
        else if ( b )
2188
        {
2189
                return true;
2190
        }
2191
 
2192
        return false;
2193
}
2194
 
2195
 
2196
void previewImages::filterFileName ( const QString &fileName, bool invert )
2197
{
2198
        previewImage *tmpPreviewImage;
2199
        QRegExp rx ( fileName );
2200
//wildcardmode should be sufficient
2201
        rx.setPatternSyntax ( QRegExp::Wildcard );
2202
 
2203
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2204
        {
2205
                tmpPreviewImage = previewImagesList.at ( i );
2206
 
2207
                if ( toRemove ( rx.exactMatch ( tmpPreviewImage->fileInformation.fileName() ), invert ) )
2208
                {
2209
                        tmpPreviewImage->filtered = true;
2210
                }
2211
        }
2212
}
2213
 
2214
 
2215
void previewImages::filterFileSize ( qint64 fileSize, bool smallerThan )
2216
{
2217
        previewImage *tmpPreviewImage;
2218
 
2219
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2220
        {
2221
                tmpPreviewImage = previewImagesList.at ( i );
2222
 
2223
                if ( toRemove ( ( tmpPreviewImage->fileInformation.size() < fileSize ), smallerThan ) )
2224
                {
2225
                        tmpPreviewImage->filtered = true;
2226
                }
2227
        }
2228
}
2229
 
2230
 
2231
void previewImages::filterFileType ( const QStringList &types, bool invert )
2232
{
2233
        previewImage *tmpPreviewImage;
2234
 
2235
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2236
        {
2237
                tmpPreviewImage = previewImagesList.at ( i );
2238
                QString type = QString ( "*." ) + tmpPreviewImage->fileInformation.suffix();
2239
 
2240
                if ( toRemove ( ( types.contains ( type ) ), invert ) )
2241
                {
2242
                        tmpPreviewImage->filtered = true;
2243
                }
2244
        }
2245
}
2246
 
2247
 
2248
void previewImages::filterFileModified ( const QDateTime &modified, bool smallerThan )
2249
{
2250
        previewImage *tmpPreviewImage;
2251
 
2252
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2253
        {
2254
                tmpPreviewImage = previewImagesList.at ( i );
2255
 
2256
                if ( toRemove ( ( tmpPreviewImage->fileInformation.lastModified() < modified ), smallerThan ) )
2257
                {
2258
                        tmpPreviewImage->filtered = true;
2259
                }
2260
        }
2261
}
2262
 
2263
 
2264
//real image needs to be loaded for this info
2265
void previewImages::filterResolution ( qint64 resolution, bool smallerThan )
2266
{
2267
        previewImage *tmpPreviewImage;
2268
 
2269
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2270
        {
2271
                tmpPreviewImage = previewImagesList.at ( i );
2272
 
2273
                if ( toRemove ( ( resolution < resolution ), smallerThan ) )
2274
                {
2275
                        tmpPreviewImage->filtered = true;
2276
                }
2277
        }
2278
}
2279
 
2280
 
2281
void previewImages::filterTag ( const QStringList &tags, bool invert )
2282
{
2283
        previewImage *tmpPreviewImage;
2284
 
2285
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2286
        {
2287
                tmpPreviewImage = previewImagesList.at ( i );
2288
 
2289
                for ( int j = 0 ; j < tags.size() ; ++j )
2290
                {
2291
                        if ( toRemove ( tmpPreviewImage->tags.contains ( tags.at ( j ) ), invert ) )
2292
                        {
2293
                                tmpPreviewImage->filtered = true;
2294
                                break;
2295
                        }
2296
                }
2297
        }
2298
}
2299
 
2300
 
2301
void previewImages::clearFilters()
2302
{
2303
        previewImage *tmpPreviewImage;
2304
 
2305
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2306
        {
2307
                tmpPreviewImage = previewImagesList.at ( i );
2308
                tmpPreviewImage->filtered = false;
2309
        }
2310
}
2311
 
2312
 
2313
void previewImages::sortPreviewImages ( const int sort )
2314
{
2315
        switch ( sort )
2316
        {
2317
                        //sort by filename
2318
                case 0:
2319
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageFileName );
2320
                        break;
2321
 
2322
                case 1:
2323
                        //sort by filedate
2324
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageFileType );
2325
                        break;
2326
 
2327
                case 2:
2328
                        //sort by filetype
2329
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageFileDate );
2330
                        break;
2331
 
2332
                case 3:
2333
                        //sort by filesize
2334
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageFileSize );
2335
                        break;
2336
 
2337
                case 4:
2338
                        //sort by imageresolution
2339
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageResolution );
2340
                        break;
2341
 
2342
                default:
2343
                        break;
2344
                        //if a wrong argument was specified, sort by name
2345
                        qSort ( previewImagesList.begin(), previewImagesList.end(), comparePreviewImageFileName );
2346
        }
2347
}
2348
 
2349
 
2350
bool comparePreviewImageFileName ( const previewImage *i1, const previewImage *i2 )
2351
{
2352
        return i1->fileInformation.fileName() < i2->fileInformation.fileName();
2353
}
2354
 
2355
 
2356
bool comparePreviewImageFileType ( const previewImage *i1, const previewImage *i2 )
2357
{
2358
        return i1->fileInformation.suffix() < i2->fileInformation.suffix();
2359
}
2360
 
2361
 
2362
bool comparePreviewImageFileDate ( const previewImage *i1, const previewImage *i2 )
2363
{
2364
        return i1->fileInformation.lastModified() < i2->fileInformation.lastModified();
2365
}
2366
 
2367
 
2368
bool comparePreviewImageFileSize ( const previewImage *i1, const previewImage *i2 )
2369
{
2370
        return i1->fileInformation.size() < i2->fileInformation.size();
2371
}
2372
 
2373
//real image needs to be loaded for this information!
2374
bool comparePreviewImageResolution ( const previewImage *i1, const previewImage *i2 )
2375
{
2376
//return (resolution) < (resolution);
2377
        return true;
2378
}
2379
 
2380
 
2381
PreviewImagesModel::PreviewImagesModel ( QObject *parent ) : QAbstractListModel ( parent )
2382
{
2383
}
2384
 
2385
 
2386
PreviewImagesModel::PreviewImagesModel ( PictureBrowser *parent ) : QAbstractListModel ( parent )
2387
{
2388
        pictureBrowser = parent;
2389
        pId = 0;
2390
 
2391
        createDefaultIcon ( pictureBrowser->pbSettings.previewIconSize );
2392
}
2393
 
2394
 
2395
void PreviewImagesModel::createDefaultIcon ( int size )
2396
{
2397
        QPainter p;
2398
 
2399
        defaultIcon = QPixmap ( size, size );
2400
 
2401
        QBrush b ( QColor ( 205,205,205 ), loadIcon ( "testfill.png" ) );
2402
 
2403
        p.begin ( &defaultIcon );
2404
 
2405
        p.setPen ( QPen ( Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin ) );
2406
        p.setBrush ( b );
2407
        p.drawRect ( 0, 0, size-1, size-1 );
2408
 
2409
        p.end();
2410
 
2411
        defaultIconSize = size;
2412
}
2413
 
2414
 
2415
void PreviewImagesModel::setModelItemsList ( const QList<previewImage *> &previewImagesList )
2416
{
2417
//create new id
2418
        pId++;
2419
 
2420
        //if there are already items stored, remove them
2421
        if ( modelItemsList.size() > 0 )
2422
        {
2423
                clearModelItemsList();
2424
        }
2425
 
2426
        pictureBrowser->imagesDisplayed = 0;
2427
        pictureBrowser->imagesFiltered = 0;
2428
 
2429
        beginInsertRows ( QModelIndex(), 0, previewImagesList.size() );
2430
 
2431
        previewImage *tmpPreviewImage;
2432
 
2433
        for ( int i = 0 ; i < previewImagesList.size() ; ++i )
2434
        {
2435
                if ( ! ( pictureBrowser->pbSettings.sortOrder ) )
2436
                {
2437
                        tmpPreviewImage = previewImagesList.at ( i );
2438
                }
2439
                else
2440
                {
2441
                        tmpPreviewImage = previewImagesList.at ( previewImagesList.size() - i - 1 );
2442
                }
2443
 
2444
                if ( ! ( tmpPreviewImage->filtered ) )
2445
                {
2446
                        modelItemsList.append ( tmpPreviewImage );
2447
                        pictureBrowser->imagesDisplayed++;
2448
                }
2449
                else
2450
                {
2451
                        pictureBrowser->imagesFiltered++;
2452
                }
2453
        }
2454
 
2455
        endInsertRows();
2456
}
2457
 
2458
 
2459
void PreviewImagesModel::clearModelItemsList()
2460
{
2461
        beginRemoveRows ( QModelIndex(), 0, ( modelItemsList.size() - 1 ) );
2462
 
2463
        modelItemsList.clear();
2464
 
2465
        endRemoveRows();
2466
}
2467
 
2468
 
2469
QVariant PreviewImagesModel::data ( const QModelIndex &index, int role ) const
2470
{
2471
        if ( !index.isValid() )
2472
        {
2473
                return QVariant();
2474
        }
2475
 
2476
        int row = index.row();
2477
        previewImage *tmpImage = modelItemsList.at ( row );
2478
 
2479
        if ( role == Qt::DecorationRole )
2480
        {
2481
                pictureBrowser->currentRow = row;
2482
 
2483
                //preload icons before and after current icon
2484
                if ( ( row - pictureBrowser->previewIconsVisible ) >= 0 )
2485
                {
2486
                        previewImage *tmpImage2 = modelItemsList.at ( row - pictureBrowser->previewIconsVisible );
2487
 
2488
                        if ( ( !tmpImage2->previewIconCreated ) && ( !tmpImage2->previewImageLoading ) )
2489
                        {
2490
                                tmpImage2->previewImageLoading = true;
2491
                                pictureBrowser->callLoadImageThread ( row - pictureBrowser->previewIconsVisible, pId );
2492
                        }
2493
                }
2494
 
2495
                if ( ( row + pictureBrowser->previewIconsVisible ) < modelItemsList.size() )
2496
                {
2497
                        previewImage *tmpImage3 = modelItemsList.at ( row + pictureBrowser->previewIconsVisible );
2498
 
2499
                        if ( ( !tmpImage3->previewIconCreated ) && ( !tmpImage3->previewImageLoading ) )
2500
                        {
2501
                                tmpImage3->previewImageLoading = true;
2502
                                pictureBrowser->callLoadImageThread ( row + pictureBrowser->previewIconsVisible, pId );
2503
                        }
2504
                }
2505
 
2506
                if ( !tmpImage->previewIconCreated )
2507
                {
2508
                        if ( !tmpImage->previewImageLoading )
2509
                        {
2510
                                tmpImage->previewImageLoading = true;
2511
                                pictureBrowser->callLoadImageThread ( row, pId );
2512
                        }
2513
 
2514
                        return QIcon ( defaultIcon );
2515
                }
2516
                else
2517
                {
2518
                        return QIcon ( tmpImage->previewIcon );
2519
                }
2520
 
2521
                return QVariant();
2522
        }
2523
        else if ( role == Qt::DisplayRole )
2524
        {
2525
                if ( pictureBrowser->pbSettings.previewMode == 1 )
2526
                {
2527
                        return tmpImage->fileInformation.fileName();
2528
                }
2529
                else
2530
                {
2531
                        return QVariant();
2532
                }
2533
        }
2534
 
2535
        return QVariant();
2536
}
2537
 
2538
 
2539
Qt::ItemFlags PreviewImagesModel::flags ( const QModelIndex &index ) const
2540
{
2541
        if ( index.isValid() )
2542
        {
2543
                return ( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled );
2544
        }
2545
 
2546
//Qt modeltest requests 0 here
2547
        return 0;
2548
}
2549
 
2550
 
2551
int PreviewImagesModel::rowCount ( const QModelIndex &parent ) const
2552
{
2553
        if ( parent.isValid() )
2554
        {
2555
                return 0;
2556
        }
2557
        else
2558
        {
2559
                return modelItemsList.size();
2560
        }
2561
}
2562
 
2563
 
2564
QStringList PreviewImagesModel::mimeTypes() const
2565
{
2566
        QStringList types;
2567
        types << "text/uri-list";
2568
        return types;
2569
}
2570
 
2571
 
2572
QMimeData *PreviewImagesModel::mimeData ( const QModelIndexList &indexes ) const
2573
{
2574
        QMimeData *mimeData = new QMimeData();
2575
        int row;
2576
        QList<QUrl> urls;
2577
        QString imageFile;
2578
 
2579
        foreach ( QModelIndex index, indexes )
2580
        {
2581
                if ( index.isValid() )
2582
                {
2583
                        row = index.row();
2584
 
2585
                        if ( ( row >= 0 ) && ( row < modelItemsList.size() ) )
2586
                        {
2587
                                imageFile = modelItemsList.at ( row )->fileInformation.absoluteFilePath();
2588
                                urls.append ( QUrl ( imageFile ) );
2589
                        }
2590
                }
2591
        }
2592
 
2593
        mimeData->setUrls ( urls );
2594
        return mimeData;
2595
}
2596
 
2597
 
2598
void PreviewImagesModel::processLoadedImage ( int row, const QImage image, ImageInformation* imgInfo, int tpId )
2599
{
2600
        //check if list of files has changed and this job is obsolete
2601
        if ( tpId != pId )
2602
        {
2603
                return;
2604
        }
2605
 
2606
//emit layoutAboutToBeChanged();
2607
 
2608
        previewImage *loadedImage = modelItemsList.at ( row );
2609
        loadedImage->previewImageLoading = false;
2610
        loadedImage->createPreviewIcon ( image, pictureBrowser->pbSettings.previewIconSize );
2611
 
2612
        loadedImage->imgInfo = imgInfo;
2613
 
2614
//emit layoutChanged();
2615
 
2616
        QModelIndex changedIndex = index ( row );
2617
        dataChanged ( changedIndex, changedIndex );
2618
}
2619
 
2620
 
2621
void PreviewImagesModel::processImageLoadError ( int row, int tpId, int errorcode )
2622
{
2623
        //check if list of files has changed and this job is obsolete
2624
        if ( tpId != pId )
2625
        {
2626
                return;
2627
        }
2628
 
2629
//emit layoutAboutToBeChanged();
2630
 
2631
        previewImage *loadedImage = modelItemsList.at ( row );
2632
        loadedImage->previewImageLoading = false;
2633
 
2634
//emit layoutChanged();
2635
}
2636
 
2637
 
2638
imageCollection::imageCollection()
2639
{
2640
}
2641
 
2642
 
2643
collections::collections ( QString collectionsName )
2644
{
2645
        name = collectionsName;
2646
}
2647
 
2648
 
2649
collectionReaderThread::collectionReaderThread ( QString &xmlFile2, bool importCollection )
2650
{
2651
        categoriesCount = 0;
2652
        type = 0;
2653
        restartThread = false;
2654
 
2655
        xmlFile = xmlFile2;
2656
        import = importCollection;
2657
}
2658
 
2659
 
2660
void collectionReaderThread::readFile()
2661
{
2662
        QFile inputFile ( xmlFile );
2663
 
2664
        if ( !inputFile.open ( QFile::ReadOnly | QFile::Text ) )
2665
        {
2666
                return;
2667
        }
2668
 
2669
        setDevice ( &inputFile );
2670
 
2671
        while ( !atEnd() )
2672
        {
2673
                readNext();
2674
 
2675
                if ( isStartElement() )
2676
                {
2677
                        if ( name() == "picturebrowser" )
2678
                        {
2679
                                //we have a collectionsdbfile
2680
                                if ( attributes().value ( "type" ) == "collectionsset" )
2681
                                {
2682
                                        readCollectionsDb();
2683
                                        type = 1;
2684
                                }
2685
                                //we have a collectionfile
2686
                                else if ( attributes().value ( "type" ) == "collection" )
2687
                                {
2688
                                        collection = new imageCollection;
2689
                                        collection->file = xmlFile;
2690
 
2691
                                        QString name = attributes().value ( "name" ).toString();
2692
 
2693
                                        if ( !name.isEmpty() )
2694
                                        {
2695
                                                collection->name = name;
2696
                                        }
2697
                                        else
2698
                                        {
2699
                                                collection->name = xmlFile;
2700
                                        }
2701
 
2702
                                        readCollectionFile();
2703
                                        type = 2;
2704
                                }
2705
                        }
2706
                }
2707
        }
2708
}
2709
 
2710
 
2711
void collectionReaderThread::readCollectionsDb()
2712
{
2713
        while ( !atEnd() )
2714
        {
2715
                readNext();
2716
 
2717
                if ( isEndElement() )
2718
                {
2719
                        break;
2720
                }
2721
 
2722
                if ( isStartElement() )
2723
                {
2724
                        if ( name() == "category" )
2725
                        {
2726
                                QString name = attributes().value ( "name" ).toString();
2727
                                collections *tmpCollections = new collections ( name );
2728
                                collectionsSet.append ( tmpCollections );
2729
 
2730
                                readCategory();
2731
 
2732
                                categoriesCount++;
2733
                        }
2734
                        else
2735
                        {
2736
                                readUnknownElement();
2737
                        }
2738
                }
2739
        }
2740
}
2741
 
2742
 
2743
void collectionReaderThread::readCollectionFile()
2744
{
2745
        while ( !atEnd() && !restartThread )
2746
        {
2747
                readNext();
2748
 
2749
                if ( isEndElement() )
2750
                {
2751
                        break;
2752
                }
2753
 
2754
                if ( isStartElement() )
2755
                {
2756
                        if ( name() == "image" )
2757
                        {
2758
                                QString tmpImageFile = attributes().value ( "file" ).toString();
2759
                                collection->imageFiles.append ( tmpImageFile );
2760
 
2761
                                readImage();
2762
                        }
2763
                        else
2764
                        {
2765
                                readUnknownElement();
2766
                        }
2767
                }
2768
        }
2769
}
2770
 
2771
 
2772
void collectionReaderThread::readCategory()
2773
{
2774
        while ( !atEnd() )
2775 <