Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
19605 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
#include <QtGui>
8
#include <QMessageBox>
9
#include <iostream>
10
#include "picturebrowser.h"
11
#include "collection.h"
12
#include "findimage.h"
13
#include "previewimage.h"
14
#include "loadimage.h"
15
#include "ui/scmessagebox.h"
16
 
17
#include "fileloader.h"
18
#include "loadsaveplugin.h"
19
#include "../../plugins/formatidlist.h"
20
 
21
#include "prefsfile.h"
22
#include "prefsmanager.h"
23
 
24
//provides loadIcon()
25
#include "util_icon.h"
26
#include "util_formats.h"
27
 
28
PictureBrowser::PictureBrowser ( ScribusDoc* doc, QWidget *parent ) : QDialog ( parent )
29
{
30
        setupUi ( this );
31
 
32
//set Scribusdoc
33
        m_Doc = doc;
34
        m_ScMW = doc->scMW();
35
 
36
//load settings
37
        pbSettings.load();
38
 
39
 
40
        connect ( navigationBox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( navigate ( int ) ) );
41
        connect ( sortCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( sortChanged ( int ) ) );
42
        connect ( previewModeCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( previewModeChanged ( int ) ) );
43
        connect ( moreButton, SIGNAL ( clicked() ), this, SLOT ( moreButtonClicked() ) );
44
        connect ( resetSettingsButton, SIGNAL ( clicked() ), this, SLOT ( resetSettingsButtonClicked() ) );
45
        connect ( sortOrderButton, SIGNAL ( clicked() ), this, SLOT ( sortOrderButtonClicked() ) );
46
        connect ( actionsGoButton, SIGNAL ( clicked() ), this, SLOT ( actionsGoButtonClicked() ) );
47
 
48
        connect ( zoomPlusButton, SIGNAL ( clicked() ), this, SLOT ( zoomPlusButtonClicked() ) );
49
        connect ( zoomMinusButton, SIGNAL ( clicked() ), this, SLOT ( zoomMinusButtonClicked() ) );
50
 
51
//close button
52
        connect ( closeButton, SIGNAL ( clicked() ), this, SLOT ( accept() ) );
53
 
54
        connect ( tabWidget, SIGNAL ( currentChanged ( int ) ), this, SLOT ( tabWidgetCurrentChanged ( int ) ) );
55
 
56
//"goto page" button in documentbrowser
57
        connect ( gotoPageButton, SIGNAL ( clicked() ), this, SLOT ( gotoPageButtonClicked() ) );
58
 
59
        connect ( folderView, SIGNAL ( activated ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
60
        connect ( folderView, SIGNAL ( clicked ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
61
        connect ( folderView, SIGNAL ( doubleClicked ( const QModelIndex & ) ), this, SLOT ( dirChosen ( const QModelIndex & ) ) );
62
 
63
//changing page
64
        connect ( this, SIGNAL ( selectPage ( int ) ), ScCore->primaryMainWindow(), SLOT ( selectPagesFromOutlines ( int ) ) );
65
        connect ( this, SIGNAL ( selectMasterPage ( QString ) ), ScCore->primaryMainWindow(), SLOT ( editMasterPagesStart ( QString ) ) );
66
 
67
//always-on-top checkbox
68
        connect ( alwaysOnTopCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( alwaysOnTopCheckboxStateChanged() ) );
69
//save settings checkbox
70
        connect ( saveSettingsCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( saveSettingsCheckboxStateChanged() ) );
71
 
72
//folderbrowser:include subdirs
73
        connect ( subdirsCheckbox, SIGNAL ( stateChanged ( int ) ), this, SLOT ( subdirsCheckboxStateChanged() ) );
74
 
75
        loadIcons();
76
 
77
        setSettings();
78
 
79
        navigationStack->setCurrentIndex ( 0 );
80
 
81
 
82
//maybe add QDir::Readable, although users might wonder where their folders are
83
        folderModel.setFilter ( QDir::AllDirs|QDir::Drives|QDir::NoDotAndDotDot|QDir::NoSymLinks/*|QDir::Hidden*/ );
84
        folderView->setModel ( &folderModel );
85
 
86
// this should give a little performance boost
87
        folderView->setUniformRowHeights ( true );
88
        folderView->setCurrentIndex ( folderModel.index ( QDir::currentPath() ) );
89
        folderView->scrollTo ( folderView->currentIndex(), QAbstractItemView::PositionAtTop );
90
        folderView->resizeColumnToContents ( 0 );
91
 
92
//this needs to be calculated later from height/width of QListView!
93
        previewIconsVisible = 8;
94
        folderBrowserIncludeSubdirs = false;
95
 
96
        imagesDisplayed = 0;
97
        imagesFiltered = 0;
98
        previewIconIndex = -1;
99
        insertCustomPosition = false;
100
        insertCustomSize = false;
101
        currentRow = 0;
102
 
103
//set up previewimages instance, fill with last shown images later
104
        pImages = new previewImages ( QStringList() );
105
 
106
//set threadpointer to 0
107
        fit = 0;
108
        crt = 0;
109
        cdbwt = 0;
110
        clrt = 0;
111
 
112
 
113
        pModel = new PreviewImagesModel ( this );
114
 
115
//create loadImagesThread instance, connect and run it
116
        lit = new loadImagesThread ( this, pModel );
117
        lit->start();
118
 
119
        connect ( imageViewArea, SIGNAL ( clicked ( const QModelIndex & ) ), this, SLOT ( previewIconClicked ( const QModelIndex & ) ) );
120
        connect ( imageViewArea, SIGNAL ( doubleClicked ( const QModelIndex & ) ), this, SLOT ( previewIconDoubleClicked ( const QModelIndex & ) ) );
121
 
122
        imageViewArea->SetIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
123
        imageViewArea->SetGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
124
        imageViewArea->SetModel ( pModel );
125
 
126
//register item selections
127
        connect ( imageViewArea->SelectionModel(), SIGNAL ( selectionChanged ( const QItemSelection &, const QItemSelection & ) ), this, SLOT ( previewImageSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) );
128
 
129
//documentbrowser setup
130
        connect ( documentWidget, SIGNAL ( itemActivated ( QTreeWidgetItem * , int ) ), this, SLOT ( documentChosen ( QTreeWidgetItem * , int ) ) );
131
        connect ( documentWidget, SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ), this, SLOT ( documentChosen ( QTreeWidgetItem * , int ) ) );
132
 
133
        documentWidget->setColumnCount ( 1 );
134
        documentWidget->setHeaderLabels ( QStringList ( "Pages" ) );
135
 
136
 
137
//collectionsbrowser setup
138
        connect ( collectionsWidget, SIGNAL ( itemActivated ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionChosen ( QTreeWidgetItem * , int ) ) );
139
        connect ( collectionsWidget, SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionChosen ( QTreeWidgetItem * , int ) ) );
140
        connect ( collectionsWidget, SIGNAL ( itemChanged ( QTreeWidgetItem * , int ) ), this, SLOT ( collectionsWidgetItemEdited ( QTreeWidgetItem * , int ) ) );
141
        connect ( collectionsNewCategoryButton, SIGNAL ( clicked() ), this, SLOT ( collectionsNewCategoryButtonClicked() ) );
142
        connect ( collectionsNewButton, SIGNAL ( clicked() ), this, SLOT ( collectionsNewButtonClicked() ) );
143
        connect ( collectionsImportButton, SIGNAL ( clicked() ), this, SLOT ( collectionsImportButtonClicked() ) );
144
        connect ( collectionsExportButton, SIGNAL ( clicked() ), this, SLOT ( collectionsExportButtonClicked() ) );
145
        connect ( collectionsDeleteButton, SIGNAL ( clicked() ), this, SLOT ( collectionsDeleteButtonClicked() ) );
146
        connect ( collectionsRenameButton, SIGNAL ( clicked() ), this, SLOT ( collectionsRenameButtonClicked() ) );
147
 
148
        connect ( collectionsAddImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesButtonClicked() ) );
149
        connect ( collectionsRemoveImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsRemoveImagesButtonClicked() ) );
150
        connect ( collectionsTagImagesButton, SIGNAL ( clicked() ), this, SLOT ( collectionsTagImagesButtonClicked() ) );
151
        connect ( collectionsAddImagesOkButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesOkButtonClicked() ) );
152
        connect ( collectionsAddImagesCancelButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddImagesCancelButtonClicked() ) );
153
 
154
        connect ( collectionsSetTagsButton, SIGNAL ( clicked() ), this, SLOT ( collectionsSetTagsButtonClicked() ) );
155
        connect ( collectionsAddNewTagButton, SIGNAL ( clicked() ), this, SLOT ( collectionsAddNewTagButtonClicked() ) );
156
 
157
 
158
        collectionsWidget->setColumnCount ( 1 );
159
        collectionsWidget->setHeaderLabels ( QStringList ( "Name" ) );
160
 
161
        cdbFile = ScPaths::instance().getPluginDataDir() + QString ( "collectionsdb.xml" );
162
//emtpy initialization, maybe accessed before collection is actually loaded
163
        currCollection = new imageCollection;
164
        currCollection->name = "empty";
165
        currCollection->file = "empty";
166
 
167
        crt = new collectionReaderThread ( cdbFile, false );
168
        connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
169
        crt->start();
170
 
171
        connect ( insertPositionCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( insertPositionComboboxChanged ( int ) ) );
172
        connect ( insertSizeCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( insertSizeComboboxChanged ( int ) ) );
173
        connect ( insertImageButton, SIGNAL ( clicked() ), this, SLOT ( insertImageButtonClicked() ) );
174
        connect ( insertPagesCombobox, SIGNAL ( checkstateChanged ( int ) ), this, SLOT ( insertPagesComboboxCheckstateChanged ( int ) ) );
175
        insertPagesCombobox->addItem ( "Current Page", 1 );
176
        insertPagesCombobox->addItem ( "All Pages", 0 );
177
 
178
        for ( int i = 0 ; i < ( int ) ( m_Doc->Pages->count() ) ; ++i )
179
        {
180
                insertPagesCombobox->addItem ( QString ( "Page %1" ).arg ( i+1 ), 0 );
181
        }
182
 
183
        insertFramesCombobox->addItem ( "All Frames", 0 );
184
        insertFramesCombobox->addItem ( "All Empty Frames", 0 );
185
 
186
 
187
        PageItem *pItem;
188
        QList<PageItem*> allItems;
189
        for (int a = 0; a < m_Doc->MasterItems.count(); ++a)
190
        {
191
                PageItem *currItem = m_Doc->MasterItems.at(a);
192
                if (currItem->isGroup())
193
                        allItems = currItem->getItemList();
194
                else
195
                        allItems.append(currItem);
196
                for (int ii = 0; ii < allItems.count(); ii++)
197
                {
198
                        pItem = allItems.at(ii);
199
                        if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( !pItem->asLatexFrame() ) )
200
                        {
201
                                QString itemText;
202
                                if ( pItem->PictureIsAvailable )
203
                                        itemText = QString ( "Frame %1" ).arg ( pItem->itemName() );
204
                                else
205
                                        itemText = QString ( "Frame %1 (empty)" ).arg ( pItem->itemName() );
206
                                insertFramesCombobox->addItem ( itemText, 0 );
207
                        }
208
                }
209
                allItems.clear();
210
        }
211
        for (int a = 0; a < m_Doc->Items->count(); ++a)
212
        {
213
                PageItem *currItem = m_Doc->Items->at(a);
214
                if (currItem->isGroup())
215
                        allItems = currItem->getItemList();
216
                else
217
                        allItems.append(currItem);
218
                for (int ii = 0; ii < allItems.count(); ii++)
219
                {
220
                        pItem = allItems.at(ii);
221
                        if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( !pItem->asLatexFrame() ) )
222
                        {
223
                                QString itemText;
224
                                if ( pItem->PictureIsAvailable )
225
                                        itemText = QString ( "Frame %1" ).arg ( pItem->itemName() );
226
                                else
227
                                        itemText = QString ( "Frame %1 (empty)" ).arg ( pItem->itemName() );
228
                                insertFramesCombobox->addItem ( itemText, 0 );
229
                        }
230
                }
231
                allItems.clear();
232
        }
233
 
234
 
235
//set namefilters for global use
236
//      nameFilters << "*.jpg" << "*.jpeg" << "*.gif" << "*.png" << "*.ps" << "*.psd" << "*.tif" << "*.tiff" << "*.xpm" << "*.eps" << "*.epsf" << "*.epsi" << "*.eps2" << "*.eps3" << "*.epi" << "*.epg";
237
 
238
        QString formatD(FormatsManager::instance()->extensionListForFormat(FormatsManager::IMAGESIMGFRAME, 0));
239
        nameFilters = formatD.split(" ", QString::SkipEmptyParts);
240
        nameFilters.append("*.svg");
241
 
242
        QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_FIRSTUSER);
243
        for (int v = 0; v < vectorFiles.count(); v++)
244
        {
245
                nameFilters.append("*." + vectorFiles[v]);
246
        }
247
 
248
 
249
//filter/search setup
250
        connect ( filterTargetCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( filterTargetComboboxChanged ( int ) ) );
251
        connect ( filterCriteriaCombobox, SIGNAL ( currentIndexChanged ( int ) ), this, SLOT ( filterCriteriaComboboxChanged ( int ) ) );
252
        connect ( filterFilterButton, SIGNAL ( clicked() ), this, SLOT ( filterFilterButtonClicked() ) );
253
        connect ( filterClearButton, SIGNAL ( clicked() ), this, SLOT ( filterClearButtonClicked() ) );
254
        connect ( filterAddCriterionButton, SIGNAL ( clicked() ), this, SLOT ( filterAddCriterionButtonClicked() ) );
255
        connect ( filterSearchDirButton, SIGNAL ( clicked() ), this, SLOT ( filterSearchDirButtonClicked() ) );
256
 
257
        filters = new imageFilters;
258
 
259
 
260
        filterTypeCombobox->addItem ( "All Supported Formats", 1 );
261
 
262
        for ( int i = 0 ; i < nameFilters.size() ; ++i )
263
        {
264
                filterTypeCombobox->addItem ( nameFilters.at ( i ), 1 );
265
        }
266
 
267
//fix: scrollperitem doesnt work
268
//imageViewArea->setLayoutMode(QListView::Batched);
269
//imageViewArea->setBatchSize(4);
270
//imageViewArea->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
271
//imageViewArea->setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);
272
}
273
 
274
 
275
PictureBrowser::~PictureBrowser()
276
{
277
}
278
 
279
 
280
void PictureBrowser::callLoadImageThread ( int row, int pId )
281
{
282
        previewImage *imageToLoad = pModel->modelItemsList.at ( row );
283
 
284
        emit loadImageJob ( row, imageToLoad->fileInformation.absoluteFilePath(), pbSettings.previewIconSize, pId );
285
}
286
 
287
 
288
void PictureBrowser::navigate ( int index )
289
{
290
        //this check shouldnt be necessary but you never know...
291
        if ( ( index >= 0 ) && ( index < 3 ) )
292
        {
293
                if ( index == 2 )
294
                {
295
                        updateDocumentbrowser();
296
                }
297
 
298
                navigationStack->setCurrentIndex ( index );
299
        }
300
}
301
 
302
 
303
void PictureBrowser::previewIconClicked ( const QModelIndex &index )
304
{
305
        int row = index.row();
306
 
307
        if ( row >= 0 )
308
        {
309
                previewIconIndex = row;
310
                updateInformationTab ( previewIconIndex );
311
        }
312
}
313
 
314
 
315
void PictureBrowser::previewIconDoubleClicked ( const QModelIndex &index )
316
{
317
        int row = index.row();
318
 
319
        if ( row >= 0 )
320
        {
321
                ScribusDoc *currentDoc ( m_ScMW->doc );
322
                Imagedialog *id ( new Imagedialog ( pImages->previewImagesList.at ( row )->fileInformation.absoluteFilePath(), currentDoc ,this ) );
323
 
324
                if ( id )
325
                {
326
                        id->setAttribute ( Qt::WA_DeleteOnClose );
327
                        id->show();
328
                        id->raise();
329
                        id->activateWindow();
330
                }
331
        }
332
}
333
 
334
 
335
void PictureBrowser::sortChanged ( int index )
336
{
337
        //this check shouldnt be necessary but you never know...
338
        if ( ( index >= 0 ) && ( index < 4 ) )
339
        {
340
                pbSettings.sortSetting = index;
341
 
342
                if ( saveSettingsCheckbox->isChecked() )
343
                {
344
                        pbSettings.save();
345
                }
346
 
347
                updateBrowser ( false, true, false );
348
        }
349
}
350
 
351
 
352
void PictureBrowser::previewModeChanged ( int index )
353
{
354
        if ( ( index >= 0 ) && ( index < 2 ) )
355
        {
356
                pbSettings.previewMode = index;
357
                imageViewArea->SetGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
358
 
359
                if ( saveSettingsCheckbox->isChecked() )
360
                {
361
                        pbSettings.save();
362
                }
363
        }
364
}
365
 
366
 
367
// enlarge dialog to show more information/options
368
//FIXME: still quick and dirty, professional animation required
369
void PictureBrowser::moreButtonClicked()
370
{
371
        // dialog is not enlarged -> enlarge, change buttontext/icon
372
        if ( !pbSettings.showMore )
373
        {
374
                expandDialog ( true );
375
                pbSettings.showMore = true;
376
 
377
                if ( tabWidget->currentIndex() == 0 )
378
                {
379
                        updateInformationTab ( previewIconIndex );
380
                }
381
        }
382
        // dialog is enlarged, set back to original size, change buttontext/icon
383
        else
384
        {
385
                expandDialog ( false );
386
                pbSettings.showMore = false;
387
        }
388
 
389
        if ( saveSettingsCheckbox->isChecked() )
390
        {
391
                pbSettings.save();
392
        }
393
}
394
 
395
 
396
void PictureBrowser::resetSettingsButtonClicked()
397
{
398
        pbSettings.reset();
399
        setSettings();
400
}
401
 
402
 
403
void PictureBrowser::actionsGoButtonClicked()
404
{
405
        int index = actionsCombobox->currentIndex();
406
 
407
        if ( ( previewIconIndex < 0 ) || ( previewIconIndex > pImages->previewImagesList.size() ) )
408
        {
409
                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No Image(s) Selected" ) );
410
                return;
411
        }
412
 
413
        if ( index == 0 )
414
        {
415
                previewImage *tmpImage;
416
 
417
                //image from pModel needed here
418
                tmpImage = pModel->modelItemsList.at ( previewIconIndex );
419
                InsertAFrameData iafData;
420
 
421
                iafData.frameType=PageItem::ImageFrame;
422
                iafData.source=tmpImage->fileInformation.absoluteFilePath();
423
                iafData.locationType = 0;
424
                iafData.pageList = QString ( "" );
425
                iafData.positionType = 0;
426
                iafData.sizeType = 0;
427
                iafData.x = 0;
428
                iafData.y = 0;
429
                iafData.width = 0;
430
                iafData.height = 0;
431
                //iafData.impsetup=m_ImportSetup;
432
                iafData.columnCount = 0;
433
                iafData.columnGap = 0;
434
                iafData.linkTextFrames = false;
435
                iafData.linkToExistingFrame = false;
436
                iafData.linkToExistingFramePtr=NULL;
437
 
438
                tmpImage->insertIntoDocument ( m_Doc, iafData );
439
        }
440
        else if ( index == 1 )
441
        {
442
                if ( !pbSettings.showMore )
443
                {
444
                        expandDialog ( true );
445
                }
446
 
447
                if ( tabWidget->currentIndex() != 3 )
448
                {
449
                        tabWidget->setCurrentIndex ( 3 );
450
                }
451
        }
452
        else if ( index == 2 )
453
        {
454
                navigationBox->setCurrentIndex ( 1 );
455
                collectionsStackedwidget->setCurrentIndex ( 1 );
456
                updateCollectionsWidget ( true );
457
                collectionsWidget->blockSignals ( true );
458
        }
459
}
460
 
461
 
462
void PictureBrowser::sortOrderButtonClicked()
463
{
464
        if ( !pbSettings.sortOrder )
465
        {
466
                pbSettings.sortOrder = true;
467
                sortOrderButton->setIcon ( *iconArrowUp );
468
        }
469
        else
470
        {
471
                pbSettings.sortOrder = false;
472
                sortOrderButton->setIcon ( *iconArrowDown );
473
        }
474
 
475
        if ( saveSettingsCheckbox->isChecked() )
476
        {
477
                pbSettings.save();
478
        }
479
 
480
        updateBrowser ( false, false, false );
481
}
482
 
483
 
484
void PictureBrowser::zoomPlusButtonClicked()
485
{
486
        if ( pbSettings.previewIconSize < 500 )
487
        {
488
                pbSettings.previewIconSize += 20;
489
 
490
                imageViewArea->SetIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
491
                imageViewArea->SetGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
492
 
493
                pModel->createDefaultIcon ( pbSettings.previewIconSize );
494
 
495
                if ( saveSettingsCheckbox->isChecked() )
496
                {
497
                        pbSettings.save();
498
                }
499
 
500
                updateBrowser ( false, false, true );
501
        }
502
}
503
 
504
 
505
void PictureBrowser::zoomMinusButtonClicked()
506
{
507
        if ( pbSettings.previewIconSize > 50 )
508
        {
509
                pbSettings.previewIconSize -= 20;
510
 
511
                imageViewArea->SetIconSize ( QSize ( pbSettings.previewIconSize, pbSettings.previewIconSize ) );
512
                imageViewArea->SetGridSize ( QSize ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ), ( qRound ( ( 1.1 ) *pbSettings.previewIconSize ) + pbSettings.previewMode*10 ) ) );
513
 
514
                pModel->createDefaultIcon ( pbSettings.previewIconSize );
515
 
516
                if ( saveSettingsCheckbox->isChecked() )
517
                {
518
                        pbSettings.save();
519
                }
520
 
521
                updateBrowser ( false, false, true );
522
        }
523
}
524
 
525
 
526
void PictureBrowser::tabWidgetCurrentChanged ( int index )
527
{
528
        if ( index == 0 )
529
        {
530
                updateInformationTab ( previewIconIndex );
531
        }
532
}
533
 
534
 
535
void PictureBrowser::gotoPageButtonClicked()
536
{
537
        QTreeWidgetItem *item = documentWidget->currentItem();
538
 
539
        if ( !item )
540
        {
541
                return;
542
        }
543
 
544
        int id = item->data ( 0, Qt::UserRole ).toInt();
545
 
546
        if ( id > 0 )
547
        {
548
                id--;
549
        }
550
 
551
        ScCore->primaryMainWindow()->closeActiveWindowMasterPageEditor();
552
        emit selectPage ( id );
553
}
554
 
555
 
556
void PictureBrowser::alwaysOnTopCheckboxStateChanged()
557
{
558
        pbSettings.alwaysOnTop = alwaysOnTopCheckbox->isChecked();
559
 
560
        if ( saveSettingsCheckbox->isChecked() )
561
        {
562
                pbSettings.save();
563
        }
564
 
565
        setAlwaysOnTop ( pbSettings.alwaysOnTop );
566
}
567
 
568
 
569
void PictureBrowser::saveSettingsCheckboxStateChanged()
570
{
571
        pbSettings.saveSettings = saveSettingsCheckbox->isChecked();
572
        pbSettings.save();
573
}
574
 
575
 
576
void PictureBrowser::subdirsCheckboxStateChanged()
577
{
578
        folderBrowserIncludeSubdirs = subdirsCheckbox->isChecked();
579
}
580
 
581
 
582
// processes chosen dirs in the folderbrowser
583
void PictureBrowser::dirChosen ( const QModelIndex &index )
584
{
585
        // as long as the folder doesnt change, only the first signal (click, doubleclick or activated) is processed
586
        if ( !tmpindex.isValid() || ( tmpindex != index ) )
587
        {
588
                tmpindex = index;
589
 
590
                currPath = folderModel.filePath ( index );
591
 
592
                if ( !fit )
593
                {
594
                        fit = new findImagesThread ( currPath, nameFilters, QDir::Name, folderBrowserIncludeSubdirs );
595
                        connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ), Qt::QueuedConnection );
596
                        fit->start();
597
                }
598
                else
599
                {
600
                        fit->restart();
601
                }
602
        }
603
}
604
 
605
 
606
void PictureBrowser::documentChosen ( QTreeWidgetItem * item, int column )
607
{
608
        PageItem *pItem;
609
        QStringList imageFiles;
610
        int id = item->data ( 0, Qt::UserRole ).toInt();
611
        QList<PageItem*> allItems;
612
        for (int a = 0; a < m_Doc->MasterItems.count(); ++a)
613
        {
614
                PageItem *currItem = m_Doc->MasterItems.at(a);
615
                if (currItem->isGroup())
616
                        allItems = currItem->getItemList();
617
                else
618
                        allItems.append(currItem);
619
                for (int ii = 0; ii < allItems.count(); ii++)
620
                {
621
                        pItem = allItems.at(ii);
622
                        if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( pItem->PictureIsAvailable ) && ( !pItem->asLatexFrame() ) )
623
                        {
624
                                if ( ( id == 0 ) || ( ( id-1 ) == pItem->OwnPage ) )
625
                                {
626
                                        imageFiles.append ( pItem->Pfile );
627
                                }
628
                        }
629
                }
630
                allItems.clear();
631
        }
632
        for (int a = 0; a < m_Doc->Items->count(); ++a)
633
        {
634
                PageItem *currItem = m_Doc->Items->at(a);
635
                if (currItem->isGroup())
636
                        allItems = currItem->getItemList();
637
                else
638
                        allItems.append(currItem);
639
                for (int ii = 0; ii < allItems.count(); ii++)
640
                {
641
                        pItem = allItems.at(ii);
642
                        if ( ( pItem->itemType() == PageItem::ImageFrame ) && ( pItem->PictureIsAvailable ) && ( !pItem->asLatexFrame() ) )
643
                        {
644
                                if ( ( id == 0 ) || ( ( id-1 ) == pItem->OwnPage ) )
645
                                {
646
                                        imageFiles.append ( pItem->Pfile );
647
                                }
648
                        }
649
                }
650
                allItems.clear();
651
        }
652
 
653
//todo: check if item is selected: item->isSelected()
654
 
655
 
656
        pImages->createPreviewImagesList ( imageFiles );
657
 
658
        updateBrowser ( true, true, false );
659
}
660
 
661
 
662
void PictureBrowser::collectionChosen ( QTreeWidgetItem * item, int column )
663
{
664
        QString collectionFile = item->data ( 0, Qt::UserRole ).toString();
665
 
666
        if ( collectionFile == "Category" )
667
        {
668
                return;
669
        }
670
 
671
        currCollectionFile = collectionFile;
672
 
673
        if ( !crt )
674
        {
675
                crt = new collectionReaderThread ( currCollectionFile, false );
676
                connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
677
                crt->start();
678
        }
679
        else
680
        {
681
                crt->restart();
682
        }
683
}
684
 
685
 
686
void PictureBrowser::collectionsWidgetItemEdited ( QTreeWidgetItem * item, int column )
687
{
688
        saveCollectionsDb();
689
}
690
 
691
 
692
void PictureBrowser::findImagesThreadFinished()
693
{
694
        if ( fit->restartThread )
695
        {
696
                delete fit;
697
 
698
                //maybe the state of folderBrowserIncludeSubdirs needs to be saved when canceling the old thread
699
                fit = new findImagesThread ( currPath, nameFilters, QDir::Name, folderBrowserIncludeSubdirs );
700
                connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ), Qt::QueuedConnection );
701
                fit->start();
702
        }
703
        else
704
        {
705
                pImages->createPreviewImagesList ( fit->imageFiles );
706
 
707
                updateBrowser ( true, true, false );
708
 
709
                delete fit;
710
                fit = 0;
711
        }
712
}
713
 
714
 
715
void PictureBrowser::collectionReaderThreadFinished()
716
{
717
        if ( crt->restartThread )
718
        {
719
                bool import = crt->import;
720
                delete crt;
721
 
722
                crt = new collectionReaderThread ( currCollectionFile, import );
723
                connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
724
                crt->start();
725
 
726
                return;
727
        }
728
 
729
        switch ( crt->type )
730
        {
731
                case 0:
732
//                      ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "File not found or file is not a collection file" ) );
733
                        break;
734
 
735
                case 1:
736
                        collectionsDb += crt->collectionsSet;
737
 
738
                        updateCollectionsWidget ( false );
739
                        updateCollectionsAddImagesCombobox();
740
                        break;
741
 
742
                case 2:
743
                        if ( crt->import )
744
                        {
745
                                collectionsWidget->blockSignals ( true );
746
 
747
                                QTreeWidgetItem *currItem = collectionsWidget->currentItem();
748
 
749
                                if ( !currItem )
750
                                {
751
                                        currItem = collectionsWidget->topLevelItem ( 0 );
752
 
753
                                        if ( !currItem )
754
                                        {
755
                                                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to create a category first" ) );
756
                                                return;
757
                                        }
758
                                }
759
 
760
                                QTreeWidgetItem *tmpItem;
761
 
762
                                if ( currItem->parent() )
763
                                {
764
                                        tmpItem = new QTreeWidgetItem ( currItem->parent(), QStringList ( crt->collection->name ) );
765
                                }
766
                                else
767
                                {
768
                                        tmpItem = new QTreeWidgetItem ( currItem, QStringList ( crt->collection->name ) );
769
                                }
770
 
771
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
772
                                tmpItem->setData ( 0, Qt::UserRole, crt->collection->file );
773
                                tmpItem->setIcon ( 0, *iconCollection );
774
                                collectionsWidget->blockSignals ( false );
775
 
776
                                collectionsWidget->setCurrentItem ( tmpItem );
777
                                saveCollectionsDb();
778
                        }
779
 
780
                        currCollection = crt->collection;
781
                        pImages->createPreviewImagesList ( currCollection );
782
 
783
                        //update view
784
                        updateBrowser ( true, true, false );
785
                        updateCollectionsAddImagesCombobox();
786
                        break;
787
 
788
                default:
789
                        break;
790
        }
791
 
792
        delete crt;
793
        crt = 0;
794
}
795
 
796
 
797
void PictureBrowser::collectionListReaderThreadFinished()
798
{
799
        /*      if(clrt->restartThread)
800
                {
801
                delete clrt;
802
 
803
                clrt = new collectionListReaderThread(collections);
804
                connect(clrt, SIGNAL(finished()), this, SLOT(collectionListReaderThreadFinished()));
805
                clrt->start();
806
                }
807
                else
808
                {
809
                pImages->createPreviewImagesList(clrt->imageFiles);
810
 
811
                updateBrowser(true, true, false);
812
 
813
                delete clrt;
814
                clrt = 0;
815
                }*/
816
}
817
 
818
 
819
void PictureBrowser::collectionReaderThreadListFinishedSave()
820
{
821
        collectionReaderThread *tmpCrt;
822
        collectionWriterThread *tmpCwt;
823
        imageCollection *tmpCollection;
824
 
825
        for ( int i = 0 ; i < crtList.size() ; ++i )
826
        {
827
                tmpCrt = crtList.at ( i );
828
 
829
                if ( tmpCrt->isFinished() )
830
                {
831
                        QStringList tmpTags;
832
 
833
                        if ( !tmpCrt->type )
834
                        {
835
                                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), QString ( "A collection was not found:\n%1\nit will be created" ).arg ( tmpCrt->xmlFile ) );
836
                                tmpCollection = new imageCollection;
837
                                tmpCollection->imageFiles = tmpCrt->addImages;
838
                        }
839
                        else
840
                        {
841
                                tmpCollection = tmpCrt->collection;
842
                                tmpCollection->imageFiles += tmpCrt->addImages;
843
                        }
844
 
845
                        //add empty tags for list consistency
846
                        for ( int j = 0 ; j < tmpCrt->addImages.size() ; ++j )
847
                        {
848
                                tmpCollection->tags.append ( tmpTags );
849
                        }
850
 
851
                        tmpCwt = new collectionWriterThread ( tmpCrt->xmlFile, *tmpCollection );
852
                        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
853
                        cwtList.append ( tmpCwt );
854
                        tmpCwt->start();
855
 
856
                        delete tmpCollection;
857
                        delete crtList.takeAt ( i );
858
                }
859
        }
860
}
861
 
862
 
863
void PictureBrowser::collectionsDbWriterThreadFinished()
864
{
865
        if ( cdbwt->restartThread )
866
        {
867
                delete cdbwt;
868
 
869
                cdbwt = new collectionsWriterThread ( cdbFile, collectionsDb );
870
                connect ( cdbwt, SIGNAL ( finished() ), this, SLOT ( collectionsDbWriterThreadFinished() ) );
871
                cdbwt->start();
872
        }
873
        else
874
        {
875
                delete cdbwt;
876
                cdbwt = 0;
877
        }
878
}
879
 
880
 
881
void PictureBrowser::collectionWriterThreadListFinished()
882
{
883
        for ( int i = 0 ; i < cwtList.size() ; ++i )
884
        {
885
                if ( cwtList.at ( i )->isFinished() )
886
                {
887
                        delete cwtList.takeAt ( i );
888
                }
889
        }
890
}
891
 
892
 
893
void PictureBrowser::insertPagesComboboxCheckstateChanged ( int row )
894
{
895
        int tmpState = insertPagesCombobox->checkstate ( 1 );
896
 
897
        if ( row == 1 )
898
        {
899
                int itemsCount = insertPagesCombobox->count();
900
 
901
                for ( int i = 2 ; i < itemsCount ; ++i )
902
                {
903
                        insertPagesCombobox->setCheckstate ( i, tmpState );
904
                }
905
        }
906
        else if ( ( tmpState == 1 ) && ( row > 1 ) )
907
        {
908
                insertPagesCombobox->setCheckstate ( 1, 0 );
909
        }
910
 
911
        insertPagesCombobox->setCurrentIndex ( row );
912
}
913
 
914
 
915
void PictureBrowser::insertImageButtonClicked()
916
{
917
        if ( ( previewIconIndex < 0 ) || ( previewIconIndex > pModel->modelItemsList.size() ) )
918
        {
919
                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No image(s) selected" ) );
920
                return;
921
        }
922
 
923
        previewImage *tmpImage;
924
 
925
//image from pModel needed here
926
        tmpImage = pModel->modelItemsList.at ( previewIconIndex );
927
        InsertAFrameData iafData;
928
 
929
        iafData.frameType=PageItem::ImageFrame;
930
        iafData.source=tmpImage->fileInformation.absoluteFilePath();
931
 
932
        QString pageList = "";
933
 
934
        if ( insertPagesCombobox->checkstate ( 1 ) == 1 )
935
        {
936
                iafData.locationType = 1;
937
        }
938
        else
939
        {
940
                iafData.locationType = 2;
941
 
942
                //current page has been selected
943
                if ( insertPagesCombobox->checkstate ( 0 ) == 1 )
944
                {
945
                        int currPage = m_Doc->currentPageNumber() + 1;
946
 
947
                        //prevent double insert, only add current page to pagelist if the page isn't selected yet
948
                        if ( insertPagesCombobox->checkstate ( currPage + 1 ) == 0 )
949
                        {
950
                                pageList += QString ( "%1," ).arg ( currPage );
951
                        }
952
                }
953
 
954
                for ( int i = 2 ; i < insertPagesCombobox->count() ; ++i )
955
                {
956
                        if ( insertPagesCombobox->checkstate ( i ) == 1 )
957
                        {
958
                                pageList += QString ( "%1," ).arg ( i-1 );
959
                        }
960
                }
961
 
962
                if ( pageList.isEmpty() )
963
                {
964
                        ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No page/image frame selected" ) );
965
                        return;
966
                }
967
 
968
                pageList.chop ( 1 );
969
        }
970
 
971
        iafData.pageList = pageList;
972
        iafData.positionType = insertPositionCombobox->currentIndex();
973
        iafData.sizeType = insertSizeCombobox->currentIndex();
974
        iafData.x = insertPositionXSpinbox->value();
975
        iafData.y = insertPositionYSpinbox->value();
976
        iafData.width = insertWidthSpinbox->value();
977
        iafData.height = insertHeightSpinbox->value();
978
 
979
        /*dont need all this crap */
980
//iafData.impsetup=m_ImportSetup;
981
        iafData.columnCount = 0;
982
        iafData.columnGap = 0;
983
        iafData.linkTextFrames = false;
984
        iafData.linkToExistingFrame = false;
985
        iafData.linkToExistingFramePtr=NULL;
986
 
987
        tmpImage->insertIntoDocument ( m_Doc, iafData );
988
}
989
 
990
 
991
void PictureBrowser::insertPositionComboboxChanged ( int index )
992
{
993
        if ( ( index == 3 ) && !insertCustomPosition )
994
        {
995
                insertPositionXSpinbox->setEnabled ( true );
996
                insertPositionYSpinbox->setEnabled ( true );
997
                insertPositionXLabel->setEnabled ( true );
998
                insertPositionYLabel->setEnabled ( true );
999
                insertCustomPosition = true;
1000
        }
1001
        else if ( insertCustomPosition )
1002
        {
1003
                insertPositionXSpinbox->setEnabled ( false );
1004
                insertPositionYSpinbox->setEnabled ( false );
1005
                insertPositionXLabel->setEnabled ( false );
1006
                insertPositionYLabel->setEnabled ( false );
1007
                insertCustomPosition = false;
1008
        }
1009
}
1010
 
1011
 
1012
void PictureBrowser::insertSizeComboboxChanged ( int index )
1013
{
1014
        if ( ( index == 3 ) && !insertCustomSize )
1015
        {
1016
                insertWidthSpinbox->setEnabled ( true );
1017
                insertHeightSpinbox->setEnabled ( true );
1018
                insertWidthLabel->setEnabled ( true );
1019
                insertHeightLabel->setEnabled ( true );
1020
                insertCustomSize = true;
1021
        }
1022
        else if ( insertCustomSize )
1023
        {
1024
                insertWidthSpinbox->setEnabled ( false );
1025
                insertHeightSpinbox->setEnabled ( false );
1026
                insertWidthLabel->setEnabled ( false );
1027
                insertHeightLabel->setEnabled ( false );
1028
                insertCustomSize = false;
1029
        }
1030
}
1031
 
1032
 
1033
void PictureBrowser::filterCriteriaComboboxChanged ( int index )
1034
{
1035
        //this check shouldnt be necessary but you never know...
1036
        if ( ( index >= 0 ) && ( index < 5 ) )
1037
        {
1038
                filterStackedwidget->setCurrentIndex ( index );
1039
        }
1040
}
1041
 
1042
 
1043
void PictureBrowser::filterTargetComboboxChanged ( int index )
1044
{
1045
        if ( ( index >= 0 ) && ( index < 3 ) )
1046
        {
1047
                filterTargetStackedWidget->setCurrentIndex ( index );
1048
        }
1049
 
1050
        if ( index == 1 )
1051
        {
1052
                filterFilterButton->setText ( "Search" );
1053
        }
1054
        else
1055
        {
1056
                filterFilterButton->setText ( "Apply Filters" );
1057
        }
1058
}
1059
 
1060
 
1061
void PictureBrowser::filterFilterButtonClicked()
1062
{
1063
        if ( filterTargetCombobox->currentIndex() == 1 )
1064
        {
1065
                QString searchDir = filterSearchLineedit->text();
1066
                QDir dir ( searchDir );
1067
 
1068
                if ( !dir.exists() )
1069
                {
1070
                        ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "Directory does not exist" ) );
1071
                        return;
1072
                }
1073
 
1074
                currPath = searchDir;
1075
 
1076
                if ( !fit )
1077
                {
1078
                        fit = new findImagesThread ( currPath, nameFilters, QDir::Name, true );
1079
                        connect ( fit, SIGNAL ( finished() ), this, SLOT ( findImagesThreadFinished() ) );
1080
                        fit->start();
1081
                }
1082
                else
1083
                {
1084
                        fit->restart();
1085
                }
1086
        }
1087
        else if ( filterTargetCombobox->currentIndex() == 2 )
1088
        {
1089
                /*      if(!clrt)
1090
                        {
1091
                        clrt = new collectionListReaderThread(collections);
1092
                        connect(clrt, SIGNAL(finished()), this, SLOT(collectionListReaderThreadFinished()));
1093
                        clrt->start();
1094
                        }
1095
                        else
1096
                        {
1097
                        clrt->restart();
1098
                        }*/
1099
        }
1100
        else
1101
        {
1102
                updateBrowser ( true, false, false );
1103
        }
1104
}
1105
 
1106
 
1107
void PictureBrowser::filterClearButtonClicked()
1108
{
1109
        pImages->clearFilters();
1110
        filterFiltersListwidget->clear();
1111
 
1112
        delete filters;
1113
        filters = new imageFilters;
1114
 
1115
        updateBrowser ( true, false, false );
1116
}
1117
 
1118
 
1119
void PictureBrowser::filterAddCriterionButtonClicked()
1120
{
1121
        QListWidgetItem *newItem = new QListWidgetItem;
1122
 
1123
        newItem->setFlags ( Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
1124
        newItem->setCheckState ( Qt::Checked );
1125
 
1126
        int index = filterCriteriaCombobox->currentIndex();
1127
        QString filterText = "Empty Filter";
1128
 
1129
        if ( index == 0 )
1130
        {
1131
                if ( filterNameCombobox->currentIndex() == 0 )
1132
                {
1133
                        filterText = QString ( "Name contains \"%1\"" ).arg ( filterNameLineedit->text() );
1134
                        filters->nameInverts.append ( true );
1135
                }
1136
                else
1137
                {
1138
                        filterText = QString ( "Name does not contain \"%1\"" ).arg ( filterNameLineedit->text() );
1139
                        filters->nameInverts.append ( false );
1140
                }
1141
 
1142
                filters->nameFilters.append ( filterNameLineedit->text() );
1143
        }
1144
        else if ( index == 1 )
1145
        {
1146
                if ( filterDateCombobox->currentIndex() == 0 )
1147
                {
1148
                        filterText = QString ( "Newer than %1" ).arg ( filterDateDatetimeedit->dateTime().toString ( "dd.MM.yyyy hh:mm" ) );
1149
                        filters->dateInverts.append ( false );
1150
                }
1151
                else
1152
                {
1153
                        filterText = QString ( "Older than %1" ).arg ( filterDateDatetimeedit->dateTime().toString ( "dd.MM.yyyy hh:mm" ) );
1154
                        filters->dateInverts.append ( true );
1155
                }
1156
 
1157
                filters->dateFilters.append ( filterDateDatetimeedit->dateTime() );
1158
        }
1159
        else if ( index == 2 )
1160
        {
1161
                if ( filterSizeCombobox->currentIndex() == 0 )
1162
                {
1163
                        filterText = QString ( "Smaller than %1 KB" ).arg ( filterSizeSpinbox->value() );
1164
                        filters->sizeInverts.append ( true );
1165
                }
1166
                else
1167
                {
1168
                        filterText = QString ( "Bigger than %1 KB" ).arg ( filterSizeSpinbox->value() );
1169
                        filters->sizeInverts.append ( false );
1170
                }
1171
 
1172
                filters->sizeFilters.append ( filterSizeSpinbox->value() );
1173
        }
1174
        else if ( index == 3 )
1175
        {
1176
                QStringList types;
1177
                filterText = QString ( "Allowed types: " );
1178
 
1179
                if ( filterTypeCombobox->checkstate ( 0 ) == 1 )
1180
                {
1181
                        filterText += QString ( "All supported types (really a useful filter...)" );
1182
                        types = nameFilters;
1183
                }
1184
                else
1185
                {
1186
                        int itemsCount = filterTypeCombobox->count();
1187
 
1188
                        for ( int i = 1 ; i < itemsCount ; ++i )
1189
                        {
1190
                                if ( filterTypeCombobox->checkstate ( i ) == 1 )
1191
                                {
1192
                                        filterText += QString ( "\"%1\", " ).arg ( nameFilters.at ( i - 1 ) );
1193
                                        types.append ( nameFilters.at ( i - 1 ) );
1194
                                }
1195
                        }
1196
                }
1197
 
1198
                filters->typeFilters.append ( types );
1199
        }
1200
        else if ( index == 4 )
1201
        {
1202
                QStringList tags;
1203
                filterText = QString ( "Has tags: " );
1204
 
1205
                int itemsCount = filterTagsCombobox->count();
1206
 
1207
                for ( int i = 1 ; i < itemsCount ; ++i )
1208
                {
1209
                        if ( filterTagsCombobox->checkstate ( i ) == 1 )
1210
                        {
1211
                                filterText += QString ( "\"%1\", " ).arg ( filterTagsCombobox->itemText ( i ) );
1212
                                tags.append ( filterTagsCombobox->itemText ( i ) );
1213
                        }
1214
                }
1215
 
1216
                filters->tagFilters.append ( tags );
1217
        }
1218
 
1219
        filters->filterMap.append ( index );
1220
 
1221
        newItem->setText ( filterText );
1222
        filterFiltersListwidget->addItem ( newItem );
1223
}
1224
 
1225
 
1226
void PictureBrowser::filterSearchDirButtonClicked()
1227
{
1228
        QString searchDir = QFileDialog::getExistingDirectory ( this, tr ( "Select Directory" ), QDir::rootPath(), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks );
1229
        filterSearchLineedit->setText ( searchDir );
1230
}
1231
 
1232
 
1233
void PictureBrowser::collectionsNewCategoryButtonClicked()
1234
{
1235
        collectionsWidget->blockSignals ( true );
1236
 
1237
        QTreeWidgetItem *tmpCategory;
1238
 
1239
        tmpCategory = new QTreeWidgetItem ( collectionsWidget, QStringList ( "New Category" ) );
1240
        tmpCategory->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1241
        tmpCategory->setData ( 0, Qt::UserRole, QString ( "Category" ) );
1242
        tmpCategory->setExpanded ( true );
1243
 
1244
        collectionsWidget->blockSignals ( false );
1245
 
1246
        collectionsWidget->setCurrentItem ( tmpCategory );
1247
        collectionsWidget->editItem ( tmpCategory );
1248
 
1249
        saveCollectionsDb();
1250
}
1251
 
1252
 
1253
void PictureBrowser::collectionsNewButtonClicked()
1254
{
1255
        collectionsWidget->blockSignals ( true );
1256
 
1257
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1258
 
1259
        if ( !currItem )
1260
        {
1261
                currItem = collectionsWidget->topLevelItem ( 0 );
1262
 
1263
                if ( !currItem )
1264
                {
1265
                        ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to create a category first" ) );
1266
                        return;
1267
                }
1268
        }
1269
 
1270
        QTreeWidgetItem *parentItem, *tmpItem;
1271
        QString newCollectionFile = ScPaths::instance().getPluginDataDir();
1272
 
1273
        parentItem = currItem->parent();
1274
 
1275
        if ( parentItem )
1276
        {
1277
                tmpItem = new QTreeWidgetItem ( parentItem, QStringList ( "New Collection" ) );
1278
                newCollectionFile += QString ( "c%1_%2.sic" ).arg ( collectionsWidget->indexOfTopLevelItem ( parentItem ) ).arg ( parentItem->childCount() );
1279
        }
1280
        else
1281
        {
1282
                tmpItem = new QTreeWidgetItem ( currItem, QStringList ( "New Collection" ) );
1283
                newCollectionFile += QString ( "c%1_%2.sic" ).arg ( collectionsWidget->indexOfTopLevelItem ( currItem ) ).arg ( currItem->childCount() );
1284
        }
1285
 
1286
        tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1287
        tmpItem->setData ( 0, Qt::UserRole, newCollectionFile );
1288
        tmpItem->setIcon ( 0, *iconCollection );
1289
        collectionsWidget->blockSignals ( false );
1290
 
1291
        collectionsWidget->setCurrentItem ( tmpItem );
1292
        collectionsWidget->editItem ( tmpItem );
1293
 
1294
        saveCollectionsDb();
1295
 
1296
        imageCollection tmpCollection;
1297
        collectionWriterThread *tmpCwt;
1298
        tmpCwt = new collectionWriterThread ( newCollectionFile, tmpCollection );
1299
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1300
        cwtList.append ( tmpCwt );
1301
        tmpCwt->start();
1302
}
1303
 
1304
 
1305
void PictureBrowser::collectionsImportButtonClicked()
1306
{
1307
        QString fileName = QFileDialog::getOpenFileName ( this, tr ( "Import Image Collection" ), QDir::rootPath(), tr ( "Scribus ImageCollection (*.sic)" ) );
1308
 
1309
        if ( !fileName.isEmpty() )
1310
        {
1311
                currCollectionFile = fileName;
1312
 
1313
                if ( !crt )
1314
                {
1315
                        crt = new collectionReaderThread ( currCollectionFile, true );
1316
                        connect ( crt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadFinished() ) );
1317
                        crt->start();
1318
                }
1319
                else
1320
                {
1321
                        crt->restart();
1322
                }
1323
        }
1324
}
1325
 
1326
 
1327
void PictureBrowser::collectionsExportButtonClicked()
1328
{
1329
        QString fileName = QFileDialog::getSaveFileName ( this, tr ( "Export Image Collection" ), QDir::rootPath(), tr ( "Scribus ImageCollection (*.sic)" ) );
1330
 
1331
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1332
 
1333
        if ( !currItem )
1334
        {
1335
                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "You have to select something you want to export" ) );
1336
                return;
1337
        }
1338
 
1339
        //collection
1340
        if ( currItem->parent() )
1341
        {
1342
                collectionWriterThread *tmpCwt;
1343
                tmpCwt = new collectionWriterThread ( fileName, *currCollection );
1344
                connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1345
                cwtList.append ( tmpCwt );
1346
                tmpCwt->start();
1347
        }
1348
        //category
1349
        else
1350
        {
1351
 
1352
        }
1353
}
1354
 
1355
 
1356
void PictureBrowser::collectionsDeleteButtonClicked()
1357
{
1358
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1359
 
1360
        if ( !currItem )
1361
        {
1362
                return;
1363
        }
1364
 
1365
        delete currItem;
1366
 
1367
        saveCollectionsDb();
1368
}
1369
 
1370
 
1371
void PictureBrowser::collectionsRenameButtonClicked()
1372
{
1373
        QTreeWidgetItem *currItem = collectionsWidget->currentItem();
1374
 
1375
        if ( !currItem )
1376
        {
1377
                return;
1378
        }
1379
 
1380
        collectionsWidget->editItem ( currItem );
1381
}
1382
 
1383
 
1384
void PictureBrowser::collectionsAddImagesButtonClicked()
1385
{
1386
        collectionsStackedwidget->setCurrentIndex ( 1 );
1387
        updateCollectionsWidget ( true );
1388
        collectionsWidget->blockSignals ( true );
1389
}
1390
 
1391
 
1392
void PictureBrowser::collectionsSetTagsButtonClicked()
1393
{
1394
        for ( int i = 0 ; i < collectionsTagImagesCombobox->count() ; ++i )
1395
        {
1396
                if ( collectionsTagImagesCombobox->checkstate ( i ) == 0 )
1397
                {
1398
                        for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
1399
                        {
1400
                                pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.removeAll ( collectionsTagImagesCombobox->itemText ( i ) );
1401
                        }
1402
                }
1403
                else if ( collectionsTagImagesCombobox->checkstate ( i ) == 1 )
1404
                {
1405
                        for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
1406
                        {
1407
                                if ( !pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.contains ( collectionsTagImagesCombobox->itemText ( i ) ) )
1408
                                {
1409
                                        pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.append ( collectionsTagImagesCombobox->itemText ( i ) );
1410
                                }
1411
                        }
1412
                }
1413
        }
1414
 
1415
 
1416
        collectionWriterThread *tmpCwt;
1417
 
1418
        currCollection->imageFiles.clear();
1419
        currCollection->tags.clear();
1420
 
1421
        for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1422
        {
1423
                currCollection->imageFiles.append ( pImages->previewImagesList.at ( i )->fileInformation.absoluteFilePath() );
1424
                currCollection->tags.append ( pImages->previewImagesList.at ( i )->tags );
1425
        }
1426
 
1427
        tmpCwt = new collectionWriterThread ( currCollection->file, *currCollection );
1428
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1429
        cwtList.append ( tmpCwt );
1430
        tmpCwt->start();
1431
}
1432
 
1433
 
1434
void PictureBrowser::collectionsAddNewTagButtonClicked()
1435
{
1436
        QString newTag = collectionsAddNewTagLineedit->text();
1437
 
1438
        if ( !newTag.isEmpty() )
1439
        {
1440
                collectionsTagImagesCombobox->addItem ( newTag, 1 );
1441
        }
1442
        else
1443
        {
1444
                ScMessageBox::warning ( this, tr ( "Picture Browser Error" ), tr ( "No tag entered" ) );
1445
        }
1446
}
1447
 
1448
 
1449
void PictureBrowser::collectionsRemoveImagesButtonClicked()
1450
{
1451
        collectionWriterThread *tmpCwt;
1452
        QList<previewImage *> tmpPreviewImagesList;
1453
 
1454
        for ( int i = 0 ; i < selectedIndexes.size() ; ++i )
1455
        {
1456
                tmpPreviewImagesList.append ( pImages->previewImagesList.takeAt ( selectedIndexes.at ( i ) ) );
1457
        }
1458
 
1459
//update view
1460
        updateBrowser ( false, false, false );
1461
 
1462
        for ( int i = 0 ; i < tmpPreviewImagesList.size() ; ++i )
1463
        {
1464
                delete tmpPreviewImagesList.at ( i );
1465
        }
1466
 
1467
        currCollection->imageFiles.clear();
1468
        currCollection->tags.clear();
1469
 
1470
        for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1471
        {
1472
                currCollection->imageFiles.append ( pImages->previewImagesList.at ( i )->fileInformation.absoluteFilePath() );
1473
                currCollection->tags.append ( pImages->previewImagesList.at ( i )->tags );
1474
        }
1475
 
1476
        tmpCwt = new collectionWriterThread ( currCollection->file, *currCollection );
1477
        connect ( tmpCwt, SIGNAL ( finished() ), this, SLOT ( collectionWriterThreadListFinished() ) );
1478
        cwtList.append ( tmpCwt );
1479
        tmpCwt->start();
1480
}
1481
 
1482
 
1483
void PictureBrowser::collectionsTagImagesButtonClicked()
1484
{
1485
}
1486
 
1487
 
1488
void PictureBrowser::collectionsAddImagesOkButtonClicked()
1489
{
1490
        QTreeWidgetItem *tmpItem, *tmpItem2;
1491
        QString collectionFile;
1492
        collectionReaderThread *tmpCrt;
1493
 
1494
        QStringList addImages;
1495
 
1496
        for ( int k = 0 ; k < selectedIndexes.size() ; ++k )
1497
        {
1498
                addImages.append ( pModel->modelItemsList.at ( selectedIndexes.at ( k ) )->fileInformation.absoluteFilePath() );
1499
        }
1500
 
1501
 
1502
        for ( int i = 0 ; i < collectionsWidget->topLevelItemCount() ; ++i )
1503
        {
1504
                tmpItem = collectionsWidget->topLevelItem ( i );
1505
 
1506
                for ( int j = 0 ; j < tmpItem->childCount() ; ++j )
1507
                {
1508
                        tmpItem2 = tmpItem->child ( j );
1509
 
1510
                        if ( tmpItem2->checkState ( 0 ) == Qt::Checked )
1511
                        {
1512
                                //add images here
1513
                                collectionFile = tmpItem2->data ( 0, Qt::UserRole ).toString();
1514
 
1515
                                tmpCrt = new collectionReaderThread ( collectionFile, false );
1516
                                tmpCrt->addImages = addImages;
1517
                                connect ( tmpCrt, SIGNAL ( finished() ), this, SLOT ( collectionReaderThreadListFinishedSave() ) );
1518
                                crtList.append ( tmpCrt );
1519
                                tmpCrt->start();
1520
                        }
1521
                }
1522
        }
1523
 
1524
        collectionsStackedwidget->setCurrentIndex ( 0 );
1525
        updateCollectionsWidget ( false );
1526
        collectionsWidget->blockSignals ( false );
1527
}
1528
 
1529
 
1530
void PictureBrowser::collectionsAddImagesCancelButtonClicked()
1531
{
1532
        collectionsStackedwidget->setCurrentIndex ( 0 );
1533
        updateCollectionsWidget ( false );
1534
        collectionsWidget->blockSignals ( false );
1535
}
1536
 
1537
 
1538
void PictureBrowser::updateBrowser ( bool filter, bool sort, bool reload )
1539
{
1540
        if ( filter )
1541
        {
1542
                applyFilters();
1543
        }
1544
 
1545
        if ( sort )
1546
        {
1547
                pImages->sortPreviewImages ( pbSettings.sortSetting );
1548
        }
1549
 
1550
        if ( reload )
1551
        {
1552
                previewImage *tmpImage;
1553
 
1554
                //force reload, check if needed is necessary
1555
                for ( int i = 0 ; i < pImages->previewImagesList.size() ; ++i )
1556
                {
1557
                        tmpImage = pImages->previewImagesList.at ( i );
1558
                        tmpImage->previewImageLoading = false;
1559
                        tmpImage->previewIconCreated = false;
1560
                }
1561
        }
1562
 
1563
        pModel->setModelItemsList ( pImages->previewImagesList );
1564
        statusLabel->setText ( QString ( "%1 image(s) displayed, %2 image(s) filtered" ).arg ( imagesDisplayed ).arg ( imagesFiltered ) );
1565
}
1566
 
1567
 
1568
void PictureBrowser::loadIcons()
1569
{
1570
        iconArrowUp = new QIcon ( loadIcon ( "pitr_green_arrows_set_1.svg" ) );
1571
        iconArrowDown = new QIcon ( loadIcon ( "pitr_green_arrows_set_5.svg" ) );
1572
        iconFolderBrowser = new QIcon ( loadIcon ( "sarxos_Simple_Folder_Seek.svg" ) );
1573
        iconCollectionsBrowser = new QIcon ( loadIcon ( "sarxos_Simple_Green_Yellow_Blue_Violet_Folders.svg" ) );
1574
        iconDocumentBrowser = new QIcon ( loadIcon ( "sarxos_Paper_Sheets.svg" ) );
1575
        iconDocument = new QIcon ( loadIcon ( "doc.png" ) );
1576
        iconCollection = new QIcon ( loadIcon ( "cmyk.png" ) );
1577
        iconOk = new QIcon ( loadIcon ( "ok22.png" ) );
1578
        iconClose = new QIcon ( loadIcon ( "/16/close.png" ) );
1579
        iconZoomPlus = new QIcon ( loadIcon ( "viewmagin.png" ) );
1580
        iconZoomMinus = new QIcon ( loadIcon ( "viewmagout.png" ) );
1581
        iconNew = new QIcon ( loadIcon ( "/16/insert-table.png" ) );
1582
        iconNew2 = new QIcon ( loadIcon ( "/16/document-new.png" ) );
1583
        iconEdit = new QIcon ( loadIcon ( "/16/document-properties.png" ) );
1584
        iconRemove = new QIcon ( loadIcon ( "/16/edit-cut.png" ) );
1585
        iconLoad = new QIcon ( loadIcon ( "/16/document-open.png" ) );
1586
        iconSave = new QIcon ( loadIcon ( "/16/document-save.png" ) );
1587
        iconPlus = new QIcon ( loadIcon ( "/16/list-add.png" ) );
1588
        iconMinus = new QIcon ( loadIcon ( "/16/list-remove.png" ) );
1589
        iconPen = new QIcon ( loadIcon ( "/16/story-editor.png" ) );
1590
 
1591
        collectionsNewCategoryButton->setIcon ( *iconNew );
1592
        collectionsNewButton->setIcon ( *iconNew2 );
1593
        collectionsRenameButton->setIcon ( *iconEdit );
1594
        collectionsDeleteButton->setIcon ( *iconRemove );
1595
        collectionsImportButton->setIcon ( *iconLoad );
1596
        collectionsExportButton->setIcon ( *iconSave );
1597
        collectionsAddImagesButton->setIcon ( *iconPlus );
1598
        collectionsRemoveImagesButton->setIcon ( *iconMinus );
1599
        collectionsTagImagesButton->setIcon ( *iconPen );
1600
        collectionsAddImagesOkButton->setIcon ( *iconOk );
1601
        collectionsAddImagesCancelButton->setIcon ( *iconClose );
1602
 
1603
        navigationBox->setItemIcon ( 0, *iconFolderBrowser );
1604
        navigationBox->setItemIcon ( 1, *iconCollectionsBrowser );
1605
        navigationBox->setItemIcon ( 2, *iconDocumentBrowser );
1606
 
1607
        zoomPlusButton->setIcon ( *iconZoomPlus );
1608
        zoomMinusButton->setIcon ( *iconZoomMinus );
1609
 
1610
        actionsGoButton->setIcon ( *iconOk );
1611
 
1612
        closeButton->setIcon ( *iconClose );
1613
 
1614
        moreButton->setIcon ( *iconArrowDown );
1615
}
1616
 
1617
 
1618
void PictureBrowser::setSettings()
1619
{
1620
//set settings
1621
        if ( pbSettings.saveSettings )
1622
        {
1623
                saveSettingsCheckbox->setCheckState ( Qt::Checked );
1624
        }
1625
 
1626
        if ( pbSettings.showMore )
1627
        {
1628
                expandDialog ( true );
1629
        }
1630
        else
1631
        {
1632
                expandDialog ( false );
1633
        }
1634
 
1635
        if ( pbSettings.sortOrder )
1636
        {
1637
                sortOrderButton->setIcon ( *iconArrowUp );
1638
        }
1639
        else
1640
        {
1641
                sortOrderButton->setIcon ( *iconArrowDown );
1642
        }
1643
 
1644
        sortCombobox->setCurrentIndex ( pbSettings.sortSetting );
1645
        previewModeCombobox->setCurrentIndex ( pbSettings.previewMode );
1646
 
1647
        if ( pbSettings.alwaysOnTop )
1648
        {
1649
                alwaysOnTopCheckbox->setCheckState ( Qt::Checked );
1650
                setAlwaysOnTop ( true );
1651
        }
1652
}
1653
 
1654
void PictureBrowser::changedDocument ( ScribusDoc* doc )
1655
{
1656
        m_Doc = doc;
1657
        updateDocumentbrowser();
1658
        actionsGoButton->setEnabled ( true );
1659
        insertImageButton->setEnabled ( true );
1660
}
1661
 
1662
void PictureBrowser::closedDocument()
1663
{
1664
        documentWidget->clear();
1665
        documentItems.clear();
1666
        m_Doc = NULL;
1667
        pImages->clearPreviewImagesList();
1668
        updateBrowser ( false, false, false );
1669
        actionsGoButton->setEnabled ( false );
1670
        insertImageButton->setEnabled ( false );
1671
}
1672
 
1673
void PictureBrowser::updateDocumentbrowser()
1674
{
1675
        documentWidget->clear();
1676
        documentItems.clear();
1677
        QTreeWidgetItem* allpages=new QTreeWidgetItem ( documentWidget, QStringList ( "All Pages" ) );
1678
        allpages->setData ( 0, Qt::UserRole, 0 );
1679
        allpages->setExpanded ( true );
1680
        documentWidget->addTopLevelItem ( allpages );
1681
 
1682
        QTreeWidgetItem *tmpItem;
1683
 
1684
        for ( int i = 0 ; i < ( int ) ( m_Doc->Pages->count() ) ; ++i )
1685
        {
1686
                tmpItem = new QTreeWidgetItem ( allpages, QStringList ( QString ( "Page %1" ).arg ( i+1 ) ) );
1687
                tmpItem->setData ( 0, Qt::UserRole, ( i+1 ) );
1688
                tmpItem->setIcon ( 0, *iconDocument );
1689
                documentItems.append ( tmpItem );
1690
        }
1691
 
1692
        documentWidget->insertTopLevelItems ( 0, documentItems );
1693
}
1694
 
1695
 
1696
void PictureBrowser::previewImageSelectionChanged ( const QItemSelection & selected, const QItemSelection & deselected )
1697
{
1698
        QItemSelectionModel *selectionModel = imageViewArea->SelectionModel();
1699
        QModelIndexList selection = selectionModel->selectedIndexes();
1700
        int tmpIndex;
1701
 
1702
 
1703
        selectedIndexes.clear();
1704
 
1705
        for ( int i = 0 ; i < selection.size() ; ++i )
1706
        {
1707
                tmpIndex = selection.at ( i ).row();
1708
 
1709
                //take filtered images into account
1710
                for ( int j = 0 ; ( j <= tmpIndex ) && ( j < pImages->previewImagesList.size() ) ; ++j )
1711
                {
1712
                        if ( pImages->previewImagesList.at ( j )->filtered )
1713
                        {
1714
                                tmpIndex++;
1715
                        }
1716
                }
1717
 
1718
                selectedIndexes.append ( tmpIndex );
1719
        }
1720
 
1721
        updateTagImagesTab();
1722
}
1723
 
1724
 
1725
void PictureBrowser::updateInformationTab ( int index )
1726
{
1727
        if ( pbSettings.showMore && ( tabWidget->currentIndex() == 0 ) )
1728
        {
1729
                if ( ( index >= 0 ) && ( index < pModel->modelItemsList.size() ) )
1730
                {
1731
                        previewImage *tmpImage;
1732
                        tmpImage = pModel->modelItemsList.at ( index );
1733
 
1734
                        informationFilenameLabel->setText ( tmpImage->fileInformation.fileName() );
1735
                        informationFilepathLabel->setText ( tmpImage->fileInformation.absolutePath() );
1736
                        informationFilesizeLabel->setText ( QString ( "%1 Bytes" ).arg ( tmpImage->fileInformation.size() ) );
1737
                        informationFiledateLabel->setText ( tmpImage->fileInformation.lastModified().toString ( "dd.MM.yyyy hh:mm:ss" ) );
1738
 
1739
                        if(tmpImage->previewImageLoading)
1740
                                informationFilenameLabel->setText (tr("Image still loading"));
1741
                        else if ( tmpImage->imgInfo->valid )
1742
                        {
1743
                                QString format;
1744
 
1745
                                switch ( tmpImage->imgInfo->type )
1746
                                {
1747
                                        case 0:
1748
                                                format = tr ( "JPG" );
1749
                                                break;
1750
 
1751
                                        case 1:
1752
                                                format = tr ( "TIFF" );
1753
                                                break;
1754
 
1755
                                        case 2:
1756
                                                format = tr ( "PSD" );
1757
                                                break;
1758
 
1759
                                        case 3:
1760
                                                format = tr ( "EPS/PS" );
1761
                                                break;
1762
 
1763
                                        case 4:
1764
                                                format = tr ( "PDF" );
1765
                                                break;
1766
 
1767
                                        case 5:
1768
                                                format = tr ( "JPG2000" );
1769
                                                break;
1770
 
1771
                                        case 6:
1772
                                                format = tmpImage->fileInformation.suffix().toUpper();
1773
                                                break;
1774
 
1775
                                        case 7:
1776
                                                format = tr ( "emb. PSD" );
1777
                                                break;
1778
 
1779
                                        default:
1780
                                                format = tr ( "not available" );
1781
                                                break;
1782
                                }
1783
 
1784
                                informationFormatLabel->setText ( format );
1785
                                informationColorspaceLabel->setText ( colorSpaceText ( tmpImage->imgInfo->colorspace ) );
1786
                                informationDpiLabel->setText ( QString ( "%1 x %2" ).arg ( tmpImage->imgInfo->xdpi ).arg ( tmpImage->imgInfo->ydpi ) );
1787
                                informationWidthLabel->setText ( QString ( "%1 Pixels" ).arg ( tmpImage->imgInfo->width ) );
1788
                                informationHeightLabel->setText ( QString ( "%1 Pixels" ).arg ( tmpImage->imgInfo->height ) );
1789
                                informationLayersLabel->setText ( QString ( "%1" ).arg ( tmpImage->imgInfo->layers ) );
1790
 
1791
                                if ( tmpImage->imgInfo->embedded )
1792
                                {
1793
                                        informationEmbeddedLabel->setText ( QString ( "Yes" ) );
1794
                                }
1795
                                else
1796
                                {
1797
                                        informationEmbeddedLabel->setText ( QString ( "No" ) );
1798
                                }
1799
 
1800
                                informationProfilenameLabel->setText ( QString ( "%1" ).arg ( tmpImage->imgInfo->profileName ) );
1801
                        }
1802
                }
1803
                else
1804
                {
1805
                        informationFilenameLabel->setText ( tr("No image selected") );
1806
                }
1807
        }
1808
}
1809
 
1810
 
1811
void PictureBrowser::updateCollectionsWidget ( bool addImages )
1812
{
1813
        collectionsWidget->blockSignals ( true );
1814
        collectionsWidget->clear();
1815
 
1816
        for ( int i = 0 ; i < collectionsDb.size() ; ++i )
1817
        {
1818
                collections *tmpCollections = collectionsDb.at ( i );
1819
 
1820
                QTreeWidgetItem *tmpCategory;
1821
                tmpCategory = new QTreeWidgetItem ( collectionsWidget, QStringList ( tmpCollections->name ) );
1822
                tmpCategory->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1823
                tmpCategory->setData ( 0, Qt::UserRole, QString ( "Category" ) );
1824
                tmpCategory->setExpanded ( true );
1825
 
1826
                for ( int j = 0 ; j < tmpCollections->collectionNames.size() ; ++j )
1827
                {
1828
                        QTreeWidgetItem *tmpItem;
1829
                        tmpItem = new QTreeWidgetItem ( tmpCategory, QStringList ( tmpCollections->collectionNames.at ( j ) ) );
1830
 
1831
                        if ( addImages )
1832
                        {
1833
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsUserCheckable|Qt::ItemIsEnabled );
1834
                                tmpItem->setCheckState ( 0, Qt::Unchecked );
1835
                        }
1836
                        else
1837
                        {
1838
                                tmpItem->setFlags ( Qt::ItemIsSelectable|Qt::ItemIsEditable|Qt::ItemIsEnabled );
1839
                        }
1840
 
1841
                        tmpItem->setData ( 0, Qt::UserRole, tmpCollections->collectionFiles.at ( j ) );
1842
                        tmpItem->setIcon ( 0, *iconCollection );
1843
                }
1844
        }
1845
 
1846
        collectionsWidget->blockSignals ( false );
1847
}
1848
 
1849
 
1850
void PictureBrowser::updateCollectionsAddImagesCombobox()
1851
{
1852
        /*
1853
        collections *tmpCollections;
1854
 
1855
                for(int i = 0 ; i < collectionsDb.size() ; ++i)
1856
                {
1857
                tmpCollections = collectionsDb.at(i);
1858
 
1859
                        for(int j = 0 ; j < tmpCollections->collectionNames.size() ; ++j)
1860
                        {
1861
                        collectionsAddImagesCombobox->addItem(QString("%1/%2").arg(tmpCollections->name).arg(tmpCollections->collectionNames.at(j)), false);
1862
                        }
1863
                }*/
1864
}
1865
 
1866
 
1867
void PictureBrowser::expandDialog ( bool expand )
1868
{
1869
        if ( expand )
1870
        {
1871
                tabWidget->show();
1872
 
1873
                resize ( 872, 550 );
1874
                moreButton->setText ( "Hide" );
1875
                moreButton->setIcon ( *iconArrowUp );
1876
        }
1877
        else
1878
        {
1879
                tabWidget->hide();
1880
 
1881
                resize ( 872, 385 );
1882
                moreButton->setText ( "More" );
1883
                moreButton->setIcon ( *iconArrowDown );
1884
        }
1885
}
1886
 
1887
 
1888
void PictureBrowser::setAlwaysOnTop ( bool alwaysOnTop )
1889
{
1890
        Qt::WindowFlags flags = windowFlags();
1891
 
1892
//save current position of the window
1893
        QPoint pos = mapToParent ( QPoint ( 0, 0 ) );
1894
 
1895
        if ( alwaysOnTop )
1896
        {
1897
                flags |= Qt::WindowStaysOnTopHint;
1898
        }
1899
        else
1900
        {
1901
                flags ^= Qt::WindowStaysOnTopHint;
1902
        }
1903
 
1904
        this->setWindowFlags ( flags );
1905
 
1906
//move to previous position
1907
        move ( pos );
1908
 
1909
//FIXME: calling setWindowFlags sets window invisible (odd behaviour, documented). causes flickering
1910
        this->show();
1911
}
1912
 
1913
 
1914
void PictureBrowser::saveCollectionsDb()
1915
{
1916
        QTreeWidgetItem *tmpItem, *tmpItem2;
1917
        collections *tmpCollections;
1918
 
1919
        for ( int i = 0 ; i < collectionsDb.size() ; ++i )
1920
        {
1921
                delete collectionsDb.at ( i );
1922
        }
1923
 
1924
        collectionsDb.clear();
1925
 
1926
 
1927
        for ( int i = 0 ; i < collectionsWidget->topLevelItemCount() ; ++i )
1928
        {
1929
                tmpItem = collectionsWidget->topLevelItem ( i );
1930
 
1931
                tmpCollections = new collections ( tmpItem->text ( 0 ) );
1932
                collectionsDb.append ( tmpCollections );
1933
 
1934
                for ( int j = 0 ; j < tmpItem->childCount() ; ++j )
1935
                {
1936
                        tmpItem2 = tmpItem->child ( j );
1937
                        tmpCollections->collectionNames.append ( tmpItem2->text ( 0 ) );
1938
                        tmpCollections->collectionFiles.append ( tmpItem2->data ( 0, Qt::UserRole ).toString() );
1939
                }
1940
        }
1941
 
1942
 
1943
        if ( !cdbwt )
1944
        {
1945
                cdbwt = new collectionsWriterThread ( cdbFile, collectionsDb );
1946
                connect ( cdbwt, SIGNAL ( finished() ), this, SLOT ( collectionsDbWriterThreadFinished() ) );
1947
                cdbwt->start();
1948
        }
1949
        else
1950
        {
1951
                cdbwt->restart();
1952
        }
1953
}
1954
 
1955
 
1956
void PictureBrowser::applyFilters()
1957
{
1958
        QListWidgetItem *item;
1959
        int c[5] = {0, 0, 0, 0, 0};
1960
        int filterType;
1961
 
1962
        pImages->clearFilters();
1963
 
1964
        for ( int i = 0 ; i < filterFiltersListwidget->count() ; ++i )
1965
        {
1966
                item = filterFiltersListwidget->item ( i );
1967
                filterType = filters->filterMap.at ( i );
1968
 
1969
                if ( item->checkState() == Qt::Checked )
1970
                {
1971
                        switch ( filterType )
1972
                        {
1973
                                case 0:
1974
                                        if ( c[0] < filters->nameFilters.size() )
1975
                                        {
1976
                                                pImages->filterFileName ( filters->nameFilters.at ( c[0] ), filters->nameInverts.at ( c[0] ) );
1977
                                        }
1978
                                        break;
1979
 
1980
                                case 1:
1981
                                        if ( c[1] < filters->dateFilters.size() )
1982
                                        {
1983
                                                pImages->filterFileModified ( filters->dateFilters.at ( c[1] ), filters->dateInverts.at ( c[1] ) );
1984
                                        }
1985
                                        break;
1986
 
1987
                                case 2:
1988
                                        if ( c[2] < filters->sizeFilters.size() )
1989
                                        {
1990
                                                pImages->filterFileSize ( ( filters->sizeFilters.at ( c[2] ) *1024 ), filters->sizeInverts.at ( c[2] ) );
1991
                                        }
1992
                                        break;
1993
 
1994
                                case 3:
1995
                                        if ( c[3] < filters->typeFilters.size() )
1996
                                        {
1997
                                                pImages->filterFileType ( filters->typeFilters.at ( c[3] ), true );
1998
                                        }
1999
                                case 4:
2000
                                        if ( c[4] < filters->tagFilters.size() )
2001
                                        {
2002
                                                pImages->filterTag ( filters->tagFilters.at ( c[4] ), true );
2003
                                        }
2004
                                        break;
2005
                        }
2006
                }
2007
 
2008
                c[filterType]++;
2009
        }
2010
}
2011
 
2012
 
2013
void PictureBrowser::updateTagImagesTab()
2014
{
2015
        QStringList tmpTags, tmpTagList;
2016
 
2017
 
2018
        collectionsSelectedImagesListwidget->clear();
2019
        collectionsTagImagesCombobox->clear();
2020
 
2021
 
2022
        for ( int i = 0 ; ( i < selectedIndexes.size() ) && ( i < currCollection->imageFiles.size() ) ; ++i )
2023
        {
2024
                new QListWidgetItem ( pImages->previewImagesList.at ( selectedIndexes.at ( i ) )->fileInformation.absoluteFilePath(), collectionsSelectedImagesListwidget );
2025
        }
2026
 
2027
        for ( int i = 0 ; i < currCollection->tags.size() ; ++i )
2028
        {
2029
                tmpTags = currCollection->tags.at ( i );
2030
 
2031
                for ( int j = 0 ; j < tmpTags.size() ; ++j )
2032
                {
2033
                        if ( !tmpTagList.contains ( tmpTags.at ( j ) ) )
2034
                        {
2035
                                tmpTagList.append ( tmpTags.at ( j ) );
2036
                        }
2037
                }
2038
        }
2039
 
2040
 
2041
        for ( int i = 0 ; i < tmpTagList.size() ; ++i )
2042
        {
2043
                collectionsTagImagesCombobox->addItem ( tmpTagList.at ( i ), 0 );
2044
 
2045
                int tagCount=0;
2046
 
2047
                for ( int j = 0 ; j < selectedIndexes.size() ; ++j )
2048
                {
2049
                        if ( pImages->previewImagesList.at ( selectedIndexes.at ( j ) )->tags.contains ( tmpTagList.at ( i ) ) )
2050
                        {
2051
                                tagCount++;
2052
                        }
2053
                        else if ( tagCount > 0 )
2054
                        {
2055
                                break;
2056
                        }
2057
                }
2058
 
2059
                if ( tagCount == selectedIndexes.size() )
2060
                {
2061
                        collectionsTagImagesCombobox->setCheckstate ( i, 1 );
2062
                }
2063
                else if ( tagCount > 0 )
2064
                {
2065
                        collectionsTagImagesCombobox->setCheckstate ( i, 2 );
2066
                }
2067
        }
2068
}
2069
 
2070
 
2071
imageFilters::imageFilters()
2072
{
2073
}
2074
 
2075
 
2076
picturebrowserSettings::picturebrowserSettings()
2077
{
2078
}
2079
 
2080
 
2081
void picturebrowserSettings::load()
2082
{
2083
        PrefsContext *picturebrowserPluginPrefs = PrefsManager::instance()->prefsFile->getPluginContext ( "picturebrowser" );
2084
 
2085
        saveSettings = picturebrowserPluginPrefs->getBool ( "pb_savesettings", true );
2086
        showMore = picturebrowserPluginPrefs->getBool ( "pb_showmore", false );
2087
        sortOrder = picturebrowserPluginPrefs->getBool ( "pb_sortorder", false );
2088
        sortSetting = picturebrowserPluginPrefs->getInt ( "pb_sortsetting", 0 );
2089
        previewMode = picturebrowserPluginPrefs->getInt ( "pb_previewmode", 0 );
2090
        previewIconSize = picturebrowserPluginPrefs->getInt ( "pb_previewiconsize", 128 );
2091
        alwaysOnTop = picturebrowserPluginPrefs->getBool ( "pb_alwaysontop", false );
2092
 
2093
// default value "dog" will be used if "s" doesn't already exist
2094
//QString s = myPluginPrefs->get("s", "dog");
2095
}
2096
 
2097
 
2098
void picturebrowserSettings::save()
2099
{
2100
        PrefsContext *picturebrowserPluginPrefs = PrefsManager::instance()->prefsFile->getPluginContext ( "picturebrowser" );
2101
 
2102
        picturebrowserPluginPrefs->set ( "pb_savesettings", saveSettings );
2103
        picturebrowserPluginPrefs->set ( "pb_showmore", showMore );
2104
        picturebrowserPluginPrefs->set ( "pb_sortorder", sortOrder );
2105
        picturebrowserPluginPrefs->set ( "pb_sortsetting", sortSetting );
2106
        picturebrowserPluginPrefs->set ( "pb_previewmode", previewMode );
2107
        picturebrowserPluginPrefs->set ( "pb_previewiconsize", previewIconSize );
2108
        picturebrowserPluginPrefs->set ( "pb_alwaysontop", alwaysOnTop );
2109
 
2110
//picturebrowserPluginPrefs->set("previewMode", "cat");
2111
}
2112
 
2113
 
2114
void picturebrowserSettings::reset()
2115
{
2116
        saveSettings = true;
2117
        showMore = false;
2118
        sortOrder = false;
2119
        sortSetting = 0;
2120
        previewMode = 0;
2121
        previewIconSize = 128;
2122
        alwaysOnTop = false;
2123
 
2124
        save();
2125
}