Subversion Repositories Scribus

Rev

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