Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/****************************************************************************
8
** Form implementation generated from reading ui file 'Bib.ui'
9
**
10
** Created: Sun Oct 14 19:47:56 2001
11
**
12
****************************************************************************/
10862 cbradney 13
#include "scrapbookpalette.h"
10859 cbradney 14
 
15
#include <QEvent>
9818 fschmid 16
#include <QDataStream>
8571 jghali 17
#include <QApplication>
9818 fschmid 18
#include <QHBoxLayout>
19
#include <QVBoxLayout>
20
#include <QSpacerItem>
8501 cbradney 21
#include <QKeyEvent>
9535 fschmid 22
#include <QByteArray>
8501 cbradney 23
#include <QPixmap>
9818 fschmid 24
#include <QFileDialog>
25
#include <QUrl>
8501 cbradney 26
#include <QDropEvent>
9818 fschmid 27
#include <QMenu>
28
#include <QAction>
29
#include <QSignalMapper>
30
#include <QFile>
31
#include <QFileInfo>
32
#include <QDomDocument>
33
#include <QToolButton>
34
#include <QCursor>
35
#include <QToolBox>
36
#include <QMessageBox>
37
#include <QToolTip>
9819 fschmid 38
#include <QPainter>
14716 fschmid 39
#include <QProgressDialog>
11269 fschmid 40
 
11605 jghali 41
#include "commonstrings.h"
415 Franz 42
#include "prefsfile.h"
2834 cbradney 43
#include "prefsmanager.h"
11605 jghali 44
#include "query.h"
45
#include "scpreview.h"
14716 fschmid 46
#include "scribuscore.h"
4693 fschmid 47
#include "stencilreader.h"
14678 fschmid 48
#include "fileloader.h"
49
#include "loadsaveplugin.h"
50
#include "plugins/formatidlist.h"
11605 jghali 51
#include "util.h"
52
#include "util_file.h"
10200 cbradney 53
#include "util_icon.h"
2856 cbradney 54
//CB TODO bring in the prefsManager instance locally here too
2534 craig 55
 
3 paul 56
/* The Scrapbook View Class
9818 fschmid 57
 * inherited from QListWidget */
58
BibView::BibView(QWidget* parent) : QListWidget(parent)
3 paul 59
{
9818 fschmid 60
        setDragEnabled(true);
61
        setViewMode(QListView::IconMode);
62
        setFlow(QListView::LeftToRight);
63
        setSortingEnabled(true);
64
        setWrapping(true);
65
        setAcceptDrops(true);
66
        setDropIndicatorShown(true);
67
        setDragDropMode(QAbstractItemView::DragDrop);
68
        setResizeMode(QListView::Adjust);
69
        setSelectionMode(QAbstractItemView::SingleSelection);
70
        setContextMenuPolicy(Qt::CustomContextMenu);
9819 fschmid 71
        setIconSize(QSize(60, 60));
2144 cbradney 72
        objectMap.clear();
4643 fschmid 73
        ScFilename = "";
9819 fschmid 74
        canWrite = true;
3 paul 75
}
9819 fschmid 76
 
9818 fschmid 77
 void BibView::startDrag(Qt::DropActions supportedActions)
78
 {
14678 fschmid 79
        QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_ODGIMPORT);
6028 jghali 80
        QString dt = objectMap[currentItem()->text()].Data;
4708 fschmid 81
        QFileInfo fi(dt);
10564 fschmid 82
        if (fi.suffix().toLower() == "sml")
4708 fschmid 83
        {
9535 fschmid 84
                QByteArray cf;
6062 jghali 85
                loadRawText(dt, cf);
86
                QString f = QString::fromUtf8(cf.data());
4708 fschmid 87
                StencilReader *pre = new StencilReader();
88
                dt = pre->createObjects(f);
89
                delete pre;
90
        }
10564 fschmid 91
        else if (fi.suffix().toLower() == "shape")
5954 fschmid 92
        {
9535 fschmid 93
                QByteArray cf;
6062 jghali 94
                loadRawText(dt, cf);
95
                QString f = QString::fromUtf8(cf.data());
5954 fschmid 96
                StencilReader *pre = new StencilReader();
97
                dt = pre->createShape(f);
98
                delete pre;
8248 fschmid 99
        }
10564 fschmid 100
        else if (fi.suffix().toLower() == "sce")
4735 fschmid 101
        {
8288 fschmid 102
                if ( fi.exists() )
103
                {
12045 jghali 104
                        QUrl ur = QUrl::fromLocalFile(dt);
8288 fschmid 105
                        dt = ur.toString();
106
                }
4735 fschmid 107
        }
14678 fschmid 108
        else if (vectorFiles.contains(fi.suffix().toLower()))
109
        {
110
                if ( fi.exists() )
111
                {
112
                        QUrl ur = QUrl::fromLocalFile(dt);
113
                        dt = ur.toString();
114
                }
115
        }
9818 fschmid 116
        QMimeData *mimeData = new QMimeData;
117
        mimeData->setText(dt);
118
        QDrag *drag = new QDrag(this);
119
        drag->setMimeData(mimeData);
12873 fschmid 120
        drag->setDragCursor(objectMap[currentItem()->text()].Preview, Qt::CopyAction);
10643 fschmid 121
        drag->exec(Qt::CopyAction);
4649 fschmid 122
        clearSelection();
9818 fschmid 123
 }
124
 
125
void BibView::dragEnterEvent(QDragEnterEvent *e)
126
{
127
        if (e->source() == this)
128
                e->ignore();
129
        else
130
                e->acceptProposedAction();
3 paul 131
}
132
 
9818 fschmid 133
void BibView::dragMoveEvent(QDragMoveEvent *e)
134
{
135
        if (e->source() == this)
136
                e->ignore();
137
        else
138
                e->acceptProposedAction();
139
}
140
 
141
void BibView::dropEvent(QDropEvent *e)
142
{
143
        if (e->mimeData()->hasText())
144
        {
145
                e->acceptProposedAction();
146
                if (e->source() == this)
147
                        return;
148
                QString nam, tmp = "";
149
                QString text = e->mimeData()->text();
150
                if (text.startsWith("<SCRIBUSELEM"))
151
                        emit objDropped(text);
152
        }
14715 fschmid 153
        else if ( e->mimeData()->hasFormat("text/uri-list"))
154
        {
155
                QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_ODGIMPORT);
156
                QList<QUrl> fileUrls = e->mimeData()->urls();
157
                e->acceptProposedAction();
158
                for( int i = 0; i < fileUrls.count(); ++i )
159
                {
160
                        QUrl url( fileUrls[i] );
161
                        QFileInfo fi(url.path());
162
                        if (vectorFiles.contains(fi.suffix().toLower()))
163
                        {
164
                                FileLoader *fileLoader = new FileLoader(url.path());
165
                                int testResult = fileLoader->TestFile();
166
                                delete fileLoader;
167
                                if ((testResult != -1) && (testResult >= FORMATID_ODGIMPORT) && (fi.exists()))
168
                                        emit fileDropped(url.path(), testResult);
169
                        }
170
                }
171
        }
9818 fschmid 172
        else
173
                e->ignore();
174
}
175
 
3 paul 176
void BibView::AddObj(QString name, QString daten, QPixmap Bild)
177
{
178
        struct Elem DrElem;
248 Franz 179
        DrElem.Data = daten;
180
        DrElem.Preview = Bild;
2144 cbradney 181
        objectMap.insert(name, DrElem);
3 paul 182
}
183
 
8288 fschmid 184
void BibView::checkAndChange(QString &text, QString nam, QString dir)
185
{
186
        QDomDocument docu("scridoc");
187
        docu.setContent(text);
188
        QDomElement elem = docu.documentElement();
189
        QDomNode DOC = elem.firstChild();
190
        bool hasImage = false;
191
        while(!DOC.isNull())
192
        {
193
                QDomElement pg = DOC.toElement();
194
                if(pg.tagName() == "ITEM")
195
                {
196
                        PageItem::ItemType PType = static_cast<PageItem::ItemType>(pg.attribute("PTYPE").toInt());
197
                        if ((PType == PageItem::ImageFrame) || (PType == PageItem::TextFrame))
198
                        {
199
                                QString Pfile = pg.attribute("PFILE");
200
                                QString Pfile2 = pg.attribute("PFILE2","");
201
                                QString Pfile3 = pg.attribute("PFILE3","");
202
                                if (!Pfile.isEmpty())
203
                                        hasImage = true;
204
                                if (!Pfile2.isEmpty())
205
                                        hasImage = true;
206
                                if (!Pfile3.isEmpty())
207
                                        hasImage = true;
208
                        }
209
                }
210
                DOC = DOC.nextSibling();
211
        }
212
        QFileInfo fid(nam);
213
        if (hasImage)
214
        {
215
                QDir dd = QDir(dir);
10398 cbradney 216
                dd.mkdir(QDir::cleanPath(QDir::convertSeparators(dir + "/" + fid.baseName())));
8288 fschmid 217
        }
8295 fschmid 218
        QString source = "";
8288 fschmid 219
        QString target = "";
11548 fschmid 220
        bool first = true;
8288 fschmid 221
        DOC = elem.firstChild();
222
        while(!DOC.isNull())
223
        {
224
                QDomElement pg = DOC.toElement();
225
                if(pg.tagName() == "ITEM")
226
                {
11548 fschmid 227
                        if (first)
228
                                pg.setAttribute("ANNAME", fid.baseName());
229
                        first = false;
8288 fschmid 230
                        PageItem::ItemType PType = static_cast<PageItem::ItemType>(pg.attribute("PTYPE").toInt());
231
                        if ((PType == PageItem::ImageFrame) || (PType == PageItem::TextFrame))
232
                        {
233
                                QString Pfile = pg.attribute("PFILE");
234
                                if (!Pfile.isEmpty())
235
                                {
236
                                        if (static_cast<bool>(pg.attribute("relativePaths", "0").toInt()))
237
                                        {
10398 cbradney 238
                                                QFileInfo pfi2(QDir::cleanPath(QDir::convertSeparators(dir+"/"+Pfile)));
10564 fschmid 239
                                                source = pfi2.absoluteFilePath();
8288 fschmid 240
                                        }
241
                                        else
242
                                        {
243
                                                QFileInfo fi(Pfile);
10398 cbradney 244
                                                source = QDir::cleanPath(QDir::convertSeparators(QDir::homePath()+"/"+Pfile));
8288 fschmid 245
                                        }
246
                                        QFileInfo fi(Pfile);
10398 cbradney 247
                                        QString target = QDir::cleanPath(QDir::convertSeparators(dir + "/" + fid.baseName() + "/" + fi.fileName()));
8288 fschmid 248
                                        copyFile(source, target);
249
                                        pg.setAttribute("PFILE", fid.baseName() + "/" + fi.fileName());
250
                                }
251
                                QString Pfile2 = pg.attribute("PFILE2","");
252
                                if (!Pfile2.isEmpty())
253
                                {
254
                                        if (static_cast<bool>(pg.attribute("relativePaths", "0").toInt()))
255
                                        {
10398 cbradney 256
                                                QFileInfo pfi2(QDir::cleanPath(QDir::convertSeparators(dir+"/"+Pfile2)));
10564 fschmid 257
                                                source = pfi2.absoluteFilePath();
8288 fschmid 258
                                        }
259
                                        else
260
                                        {
261
                                                QFileInfo fi(Pfile2);
10398 cbradney 262
                                                source = QDir::cleanPath(QDir::convertSeparators(QDir::homePath()+"/"+Pfile));
8288 fschmid 263
                                        }
264
                                        QFileInfo fi(Pfile2);
10398 cbradney 265
                                        QString target = QDir::cleanPath(QDir::convertSeparators(dir + "/" + fid.baseName() + "/" + fi.fileName()));
8288 fschmid 266
                                        copyFile(source, target);
8295 fschmid 267
                                        pg.setAttribute("PFILE2", fid.baseName() + "/" + fi.fileName());
8288 fschmid 268
                                }
269
                                QString Pfile3 = pg.attribute("PFILE3","");
270
                                if (!Pfile3.isEmpty())
271
                                {
272
                                        if (static_cast<bool>(pg.attribute("relativePaths", "0").toInt()))
273
                                        {
10398 cbradney 274
                                                QFileInfo pfi2(QDir::cleanPath(QDir::convertSeparators(dir+"/"+Pfile3)));
10564 fschmid 275
                                                source = pfi2.absoluteFilePath();
8288 fschmid 276
                                        }
277
                                        else
278
                                        {
279
                                                QFileInfo fi(Pfile3);
10398 cbradney 280
                                                source = QDir::cleanPath(QDir::convertSeparators(QDir::homePath()+"/"+Pfile3));
8288 fschmid 281
                                        }
282
                                        QFileInfo fi(Pfile3);
10398 cbradney 283
                                        QString target = QDir::cleanPath(QDir::convertSeparators(dir + "/" + fid.baseName() + "/" + fi.fileName()));
8288 fschmid 284
                                        copyFile(source, target);
8295 fschmid 285
                                        pg.setAttribute("PFILE3", fid.baseName() + "/" + fi.fileName());
8288 fschmid 286
                                }
287
                                pg.setAttribute("relativePaths", 1);
288
                        }
289
                }
290
                DOC = DOC.nextSibling();
291
        }
292
        QFile f(nam);
8501 cbradney 293
        if(!f.open(QIODevice::WriteOnly))
8288 fschmid 294
                return ;
9818 fschmid 295
        QDataStream s;
8571 jghali 296
        QByteArray cs = docu.toByteArray();
8288 fschmid 297
        s.setDevice(&f);
10564 fschmid 298
        s.writeRawData(cs.data(), cs.length());
8288 fschmid 299
        f.close();
300
}
301
 
4611 fschmid 302
void BibView::SaveContents(QString name, QString oldName)
3 paul 303
{
4611 fschmid 304
        QDir d(oldName, "*.sce", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
305
        if ((d.exists()) && (d.count() != 0))
248 Franz 306
        {
4611 fschmid 307
                for (uint dc = 0; dc < d.count(); ++dc)
308
                {
9535 fschmid 309
                        QByteArray cf;
10398 cbradney 310
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d[dc])), cf))
4611 fschmid 311
                                continue;
8288 fschmid 312
                        QString ff = QString::fromUtf8(cf.data());
4649 fschmid 313
                        QPixmap pm;
10398 cbradney 314
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d[dc])));
10564 fschmid 315
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4649 fschmid 316
                        if (fi2.exists())
10564 fschmid 317
                                pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4649 fschmid 318
                        else
319
                        {
6062 jghali 320
                                QString f;
321
                                if (cf.left(16) == "<SCRIBUSELEMUTF8")
322
                                        f = QString::fromUtf8(cf.data());
323
                                else
324
                                        f = cf.data();
4649 fschmid 325
                                ScPreview *pre = new ScPreview();
326
                                pm = pre->createPreview(f);
327
                                delete pre;
328
                        }
10398 cbradney 329
                        QFileInfo fi3(QDir::cleanPath(QDir::convertSeparators(name + "/" + d[dc])));
14715 fschmid 330
                        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
331
                                pm.save(QDir::cleanPath(QDir::convertSeparators(fi3.path()+"/"+fi3.baseName()+".png")), "PNG");
10564 fschmid 332
                        checkAndChange(ff, QDir::cleanPath(QDir::convertSeparators(name + "/" + d[dc])), QDir::cleanPath(QDir::convertSeparators(name)));
4611 fschmid 333
                }
248 Franz 334
        }
4735 fschmid 335
        QDir d2(oldName, "*.sml", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
5954 fschmid 336
        if ((d2.exists()) && (d2.count() != 0))
4735 fschmid 337
        {
338
                for (uint dc = 0; dc < d2.count(); ++dc)
339
                {
9535 fschmid 340
                        QByteArray cf;
10398 cbradney 341
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d2[dc])), cf))
4735 fschmid 342
                                continue;
10398 cbradney 343
                        QFile fil(QDir::cleanPath(QDir::convertSeparators(name + "/" + d2[dc])));
8501 cbradney 344
                        if(!fil.open(QIODevice::WriteOnly))
4735 fschmid 345
                                continue ;
9818 fschmid 346
                        QDataStream s(&fil);
10564 fschmid 347
                        s.writeRawData(cf.data(), cf.length());
4735 fschmid 348
                        fil.close();
349
                        QPixmap pm;
10398 cbradney 350
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d2[dc])));
10564 fschmid 351
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4735 fschmid 352
                        if (fi2.exists())
10564 fschmid 353
                                pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4735 fschmid 354
                        else
355
                        {
6062 jghali 356
                                QString f = QString::fromUtf8(cf.data());
4735 fschmid 357
                                StencilReader *pre = new StencilReader();
358
                                pm = pre->createPreview(f);
359
                                delete pre;
360
                        }
10398 cbradney 361
                        QFileInfo fi3(QDir::cleanPath(QDir::convertSeparators(name + "/" + d2[dc])));
14715 fschmid 362
                        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
363
                                pm.save(QDir::cleanPath(QDir::convertSeparators(fi3.path()+"/"+fi3.baseName()+".png")), "PNG");
4735 fschmid 364
                }
365
        }
8248 fschmid 366
        QDir d3(name, "*.shape", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
5954 fschmid 367
        if ((d3.exists()) && (d3.count() != 0))
368
        {
369
                for (uint dc = 0; dc < d3.count(); ++dc)
370
                {
9535 fschmid 371
                        QByteArray cf;
10398 cbradney 372
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d3[dc])), cf))
5954 fschmid 373
                                continue;
10398 cbradney 374
                        QFile fil(QDir::cleanPath(QDir::convertSeparators(name + "/" + d3[dc])));
8501 cbradney 375
                        if(!fil.open(QIODevice::WriteOnly))
5954 fschmid 376
                                continue ;
9818 fschmid 377
                        QDataStream s(&fil);
10564 fschmid 378
                        s.writeRawData(cf.data(), cf.length());
5954 fschmid 379
                        fil.close();
380
                        QPixmap pm;
10398 cbradney 381
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d3[dc])));
10564 fschmid 382
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
5954 fschmid 383
                        if (fi2.exists())
10564 fschmid 384
                                pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
5954 fschmid 385
                        else
386
                        {
6062 jghali 387
                                QString f = QString::fromUtf8(cf.data());
5954 fschmid 388
                                StencilReader *pre = new StencilReader();
6062 jghali 389
                                QString f2 = pre->createShape(f);
5954 fschmid 390
                                ScPreview *pre2 = new ScPreview();
391
                                pm = pre2->createPreview(f2);
392
                                delete pre;
393
                                delete pre2;
394
                        }
10398 cbradney 395
                        QFileInfo fi3(QDir::cleanPath(QDir::convertSeparators(name + "/" + d3[dc])));
14715 fschmid 396
                        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
397
                                pm.save(QDir::cleanPath(QDir::convertSeparators(fi3.path()+"/"+fi3.baseName()+".png")), "PNG");
5954 fschmid 398
                }
8248 fschmid 399
        }
14678 fschmid 400
        QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_ODGIMPORT);
401
        for (int v = 0; v < vectorFiles.count(); v++)
402
        {
403
                QString ext = "*." + vectorFiles[v];
404
                QDir d4(name, ext, QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
405
                if ((d4.exists()) && (d4.count() != 0))
406
                {
407
                        for (uint dc = 0; dc < d4.count(); ++dc)
408
                        {
409
                                QByteArray cf;
410
                                if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(oldName + "/" + d4[dc])), cf))
411
                                        continue;
412
                                QFile fil(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
413
                                if(!fil.open(QIODevice::WriteOnly))
414
                                        continue ;
415
                                QDataStream s(&fil);
416
                                s.writeRawData(cf.data(), cf.length());
417
                                fil.close();
418
                                QPixmap pm;
419
                                QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
420
                                QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
421
                                if (fi2.exists())
422
                                        pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
423
                                else
424
                                {
425
                                        FileLoader *fileLoader = new FileLoader(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
426
                                        int testResult = fileLoader->TestFile();
427
                                        delete fileLoader;
428
                                        if ((testResult != -1) && (testResult >= FORMATID_ODGIMPORT))
429
                                        {
430
                                                const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
431
                                                if( fmt )
432
                                                {
433
                                                        QImage im = fmt->readThumbnail(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
14715 fschmid 434
                                                        im = im.scaled(60, 60, Qt::KeepAspectRatio, Qt::SmoothTransformation);
14678 fschmid 435
                                                        pm = QPixmap::fromImage(im);
436
                                                }
437
                                        }
438
                                }
439
                                QFileInfo fi3(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
14715 fschmid 440
                                if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
441
                                        pm.save(QDir::cleanPath(QDir::convertSeparators(fi3.path()+"/"+fi3.baseName()+".png")), "PNG");
14678 fschmid 442
                        }
443
                }
444
        }
3 paul 445
}
446
 
4611 fschmid 447
void BibView::ReadOldContents(QString name, QString newName)
3 paul 448
{
6062 jghali 449
        bool isUtf8 = false;
3 paul 450
        QDomDocument docu("scridoc");
6062 jghali 451
        QString ff;
9535 fschmid 452
        QByteArray cf;
6062 jghali 453
        if (!loadRawText(name, cf))
3 paul 454
                return;
6062 jghali 455
        if( cf.left(17) == "<SCRIBUSSCRAPUTF8")
456
        {
457
                ff = QString::fromUtf8(cf.data());
458
                isUtf8 = true;
459
        }
460
        else
461
                ff = QString::fromLocal8Bit(cf.data());
3 paul 462
        if(!docu.setContent(ff))
463
                return;
464
        QDomElement elem=docu.documentElement();
465
        if ((elem.tagName() != "SCRIBUSSCRAP") && (elem.tagName() != "SCRIBUSSCRAPUTF8"))
466
                return;
467
        QDomNode DOC=elem.firstChild();
468
        while(!DOC.isNull())
248 Franz 469
        {
3 paul 470
                QDomElement dc=DOC.toElement();
471
                if (dc.tagName()=="OBJEKT")
248 Franz 472
                {
10398 cbradney 473
                        QFile fi(QDir::cleanPath(QDir::convertSeparators(newName + "/" + GetAttr(&dc, "NAME") + ".sce")));
8501 cbradney 474
                        if(!fi.open(QIODevice::WriteOnly))
4611 fschmid 475
                                continue ;
9818 fschmid 476
                        QDataStream s(&fi);
4611 fschmid 477
                        QString fn = GetAttr(&dc, "DATA");
10493 fschmid 478
                        cf = isUtf8? fn.toUtf8() : fn.toLocal8Bit();
10564 fschmid 479
                        s.writeRawData(cf.data(), cf.length());
4611 fschmid 480
                        fi.close();
481
                }
482
                DOC=DOC.nextSibling();
483
        }
484
}
485
 
486
void BibView::ReadContents(QString name)
487
{
488
        clear();
489
        objectMap.clear();
4708 fschmid 490
        QString nd;
491
        if (name.endsWith(QDir::convertSeparators("/")))
492
                nd = name.left(name.length()-1);
14716 fschmid 493
        int fileCount = 0;
494
        int readCount = 0;
4611 fschmid 495
        QDir d(name, "*.sce", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
14716 fschmid 496
                fileCount += d.count();
497
        QDir d2(name, "*.sml", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
498
                fileCount += d2.count();
499
        QDir d3(name, "*.shape", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
500
                fileCount += d3.count();
501
        QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_ODGIMPORT);
502
        for (int v = 0; v < vectorFiles.count(); v++)
503
        {
504
                QString ext = "*." + vectorFiles[v];
505
                QDir d4(name, ext, QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
506
                fileCount += d4.count();
507
        }
508
        QProgressDialog *pgDia = NULL;
509
        if (ScCore->initialized())
510
        {
511
                pgDia = new QProgressDialog("Reading Files...", QString(), 0, fileCount, this);
512
                pgDia->setWindowModality(Qt::WindowModal);
513
        }
4611 fschmid 514
        if ((d.exists()) && (d.count() != 0))
515
        {
516
                for (uint dc = 0; dc < d.count(); ++dc)
517
                {
14716 fschmid 518
                        if (pgDia)
519
                        {
520
                                pgDia->setValue(readCount);
521
                                readCount++;
522
                        }
4649 fschmid 523
                        QPixmap pm;
9535 fschmid 524
                        QByteArray cf;
10398 cbradney 525
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(name + "/" + d[dc])), cf))
4611 fschmid 526
                                continue;
10398 cbradney 527
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(name + "/" + d[dc])));
10564 fschmid 528
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4649 fschmid 529
                        if (fi2.exists())
10564 fschmid 530
                                pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4649 fschmid 531
                        else
532
                        {
6062 jghali 533
                                QString f;
534
                                if (cf.left(16) == "<SCRIBUSELEMUTF8")
535
                                        f = QString::fromUtf8(cf.data());
536
                                else
537
                                        f = cf.data();
4649 fschmid 538
                                ScPreview *pre = new ScPreview();
539
                                pm = pre->createPreview(f);
14715 fschmid 540
                                if ((canWrite) && (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews))
10564 fschmid 541
                                        pm.save(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")), "PNG");
4649 fschmid 542
                                delete pre;
543
                        }
10398 cbradney 544
                        AddObj(fi.baseName(), QDir::cleanPath(QDir::convertSeparators(name + "/" + d[dc])), pm);
248 Franz 545
                }
546
        }
4693 fschmid 547
        if ((d2.exists()) && (d2.count() != 0))
248 Franz 548
        {
4693 fschmid 549
                for (uint dc = 0; dc < d2.count(); ++dc)
550
                {
14716 fschmid 551
                        if (pgDia)
552
                        {
553
                                pgDia->setValue(readCount);
554
                                readCount++;
555
                        }
4693 fschmid 556
                        QPixmap pm;
9535 fschmid 557
                        QByteArray cf;
10398 cbradney 558
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(name + "/" + d2[dc])), cf))
4693 fschmid 559
                                continue;
10398 cbradney 560
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(name + "/" + d2[dc])));
10564 fschmid 561
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4693 fschmid 562
                        if (fi2.exists())
10564 fschmid 563
                                pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
4693 fschmid 564
                        else
565
                        {
6062 jghali 566
                                QString f = QString::fromUtf8(cf.data());
4693 fschmid 567
                                StencilReader *pre = new StencilReader();
568
                                pm = pre->createPreview(f);
14715 fschmid 569
                                if ((canWrite) && (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews))
10564 fschmid 570
                                        pm.save(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")), "PNG");
4693 fschmid 571
                                delete pre;
572
                        }
10398 cbradney 573
                        AddObj(fi.baseName(), QDir::cleanPath(QDir::convertSeparators(name + "/" + d2[dc])), pm);
4693 fschmid 574
                }
248 Franz 575
        }
5954 fschmid 576
        if ((d3.exists()) && (d3.count() != 0))
577
        {
578
                for (uint dc = 0; dc < d3.count(); ++dc)
579
                {
14716 fschmid 580
                        if (pgDia)
581
                        {
582
                                pgDia->setValue(readCount);
583
                                readCount++;
584
                        }
5954 fschmid 585
                        QPixmap pm;
9535 fschmid 586
                        QByteArray cf;
10398 cbradney 587
                        if (!loadRawText(QDir::cleanPath(QDir::convertSeparators(name + "/" + d3[dc])), cf))
5954 fschmid 588
                                continue;
10398 cbradney 589
                        QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(name + "/" + d3[dc])));
10564 fschmid 590
                        QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
591
                        QFileInfo fi2p(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".xpm")));
5958 fschmid 592
                        if ((fi2.exists()) || (fi2p.exists()))
593
                        {
594
                                if (fi2.exists())
10564 fschmid 595
                                        pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
5958 fschmid 596
                                else
10564 fschmid 597
                                        pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".xpm")));
5958 fschmid 598
                        }
5954 fschmid 599
                        else
600
                        {
6062 jghali 601
                                QString f = QString::fromUtf8(cf.data());
5954 fschmid 602
                                StencilReader *pre = new StencilReader();
6062 jghali 603
                                QString f2 = pre->createShape(f);
5954 fschmid 604
                                ScPreview *pre2 = new ScPreview();
605
                                pm = pre2->createPreview(f2);
14715 fschmid 606
                                if ((canWrite) && (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews))
10564 fschmid 607
                                        pm.save(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")), "PNG");
5954 fschmid 608
                                delete pre;
609
                                delete pre2;
610
                        }
10398 cbradney 611
                        AddObj(fi.baseName(), QDir::cleanPath(QDir::convertSeparators(name + "/" + d3[dc])), pm);
5954 fschmid 612
                }
8248 fschmid 613
        }
14678 fschmid 614
        for (int v = 0; v < vectorFiles.count(); v++)
615
        {
616
                QString ext = "*." + vectorFiles[v];
617
                QDir d4(name, ext, QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
618
                if ((d4.exists()) && (d4.count() != 0))
619
                {
620
                        for (uint dc = 0; dc < d4.count(); ++dc)
621
                        {
14716 fschmid 622
                                if (pgDia)
623
                                {
624
                                        pgDia->setValue(readCount);
625
                                        readCount++;
626
                                }
14678 fschmid 627
                                QPixmap pm;
628
                                QFileInfo fi(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
629
                                QFileInfo fi2(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
630
                                if (fi2.exists())
631
                                        pm.load(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")));
632
                                else
633
                                {
634
                                        FileLoader *fileLoader = new FileLoader(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
635
                                        int testResult = fileLoader->TestFile();
636
                                        delete fileLoader;
637
                                        if ((testResult != -1) && (testResult >= FORMATID_ODGIMPORT))
638
                                        {
639
                                                const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
640
                                                if( fmt )
641
                                                {
642
                                                        QImage im = fmt->readThumbnail(QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])));
14715 fschmid 643
                                                        im = im.scaled(60, 60, Qt::KeepAspectRatio, Qt::SmoothTransformation);
644
                                                        if ((canWrite) && (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews))
14678 fschmid 645
                                                                im.save(QDir::cleanPath(QDir::convertSeparators(fi.path()+"/"+fi.baseName()+".png")), "PNG");
646
                                                        pm = QPixmap::fromImage(im);
647
                                                }
648
                                        }
649
                                }
650
                                AddObj(fi.baseName(), QDir::cleanPath(QDir::convertSeparators(name + "/" + d4[dc])), pm);
651
                        }
652
                }
653
        }
14716 fschmid 654
        if (pgDia)
655
        {
656
                pgDia->setValue(fileCount);
657
                delete pgDia;
658
        }
3 paul 659
        QMap<QString,Elem>::Iterator itf;
2144 cbradney 660
        for (itf = objectMap.begin(); itf != objectMap.end(); ++itf)
248 Franz 661
        {
10516 cbradney 662
                if (itf.value().Preview.width() > 60)
663
                        itf.value().Preview = itf.value().Preview.scaledToWidth(60, Qt::SmoothTransformation);
664
                if (itf.value().Preview.height() > 60)
665
                        itf.value().Preview = itf.value().Preview.scaledToHeight(60, Qt::SmoothTransformation);
9819 fschmid 666
                QPixmap pm(60, 60);
10737 fschmid 667
                pm.fill(palette().color(QPalette::Base));
9819 fschmid 668
                QPainter p;
669
                p.begin(&pm);
10516 cbradney 670
                p.drawPixmap(30 - itf.value().Preview.width() / 2, 30 - itf.value().Preview.height() / 2, itf.value().Preview);
9819 fschmid 671
                p.end();
672
                new QListWidgetItem(QIcon(pm), itf.key(), this);
248 Franz 673
        }
9823 fschmid 674
        sortItems();
3 paul 675
}
4693 fschmid 676
 
3 paul 677
/* This is the main Dialog-Class for the Scrapbook */
2834 cbradney 678
Biblio::Biblio( QWidget* parent) : ScrPaletteBase( parent, "Sclib", false, 0 )
3 paul 679
{
1447 fschmid 680
        resize( 230, 190 );
9818 fschmid 681
        BiblioLayout = new QVBoxLayout( this );
248 Franz 682
        BiblioLayout->setSpacing( 0 );
1448 cbradney 683
        BiblioLayout->setMargin( 0 );
8336 fschmid 684
 
9818 fschmid 685
        buttonLayout = new QHBoxLayout;
5358 cbradney 686
        buttonLayout->setSpacing( 5 );
687
        buttonLayout->setMargin( 0 );
9818 fschmid 688
        newButton = new QToolButton(this);
689
        newButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
690
        newButton->setIcon(loadIcon("16/document-new.png"));
691
        newButton->setIconSize(QSize(16, 16));
692
        loadButton = new QToolButton(this);
693
        loadButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
694
        loadButton->setIcon(loadIcon("16/document-open.png"));
695
        loadButton->setIconSize(QSize(16, 16));
696
        saveAsButton = new QToolButton(this);
697
        saveAsButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
698
        saveAsButton->setIcon(loadIcon("16/document-save-as.png"));
699
        saveAsButton->setIconSize(QSize(16, 16));
10564 fschmid 700
        importButton = new QToolButton(this);
9818 fschmid 701
        importButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
702
        importButton->setIcon(loadIcon("compfile16.png"));
703
        importButton->setIconSize(QSize(16, 16));
10564 fschmid 704
        closeButton = new QToolButton(this);
9818 fschmid 705
        closeButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
706
        closeButton->setIcon(loadIcon("16/close.png"));
707
        closeButton->setIconSize(QSize(16, 16));
5358 cbradney 708
        buttonLayout->addWidget( newButton );
709
        buttonLayout->addWidget( loadButton );
710
        buttonLayout->addWidget( saveAsButton );
711
        buttonLayout->addWidget( importButton );
712
        buttonLayout->addWidget( closeButton );
9818 fschmid 713
        QSpacerItem* spacer = new QSpacerItem( 1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum );
5358 cbradney 714
        buttonLayout->addItem( spacer );
715
        BiblioLayout->addLayout( buttonLayout );
8295 fschmid 716
 
10564 fschmid 717
        Frame3 = new QToolBox( this );
4643 fschmid 718
        activeBView = new BibView(this);
8336 fschmid 719
        Frame3->addItem(activeBView, tr("Main"));
5760 fschmid 720
        tempBView = new BibView(this);
8336 fschmid 721
        Frame3->addItem(tempBView, tr("Copied Items"));
5787 fschmid 722
        tempCount = 0;
9819 fschmid 723
        actItem = 0;
248 Franz 724
        BiblioLayout->addWidget( Frame3 );
8336 fschmid 725
 
2191 cbradney 726
        languageChange();
8336 fschmid 727
 
728
        connect(newButton, SIGNAL(clicked()), this, SLOT(NewLib()));
729
        connect(loadButton, SIGNAL(clicked()), this, SLOT(Load()));
730
        connect(saveAsButton, SIGNAL(clicked()), this, SLOT(SaveAs()));
731
        connect(importButton, SIGNAL(clicked()), this, SLOT(Import()));
732
        connect(closeButton, SIGNAL(clicked()), this, SLOT(closeLib()));
733
        connect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
3 paul 734
}
2144 cbradney 735
 
4735 fschmid 736
void Biblio::setOpenScrapbooks(QStringList &fileNames)
737
{
9818 fschmid 738
        disconnect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 739
        disconnect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 740
        disconnect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 741
        disconnect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
11239 fschmid 742
        disconnect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
8571 jghali 743
        for (int rd = 0; rd < fileNames.count(); ++rd)
4735 fschmid 744
        {
745
                QString fileName = fileNames[rd];
746
                if (!fileName.isEmpty())
747
                {
748
                        QDir d(fileName);
749
                        activeBView = new BibView(this);
9819 fschmid 750
                        QFileInfo fd(fileName);
751
                        activeBView->canWrite = fd.isWritable();
752
                        activeBView->setAcceptDrops(activeBView->canWrite);
753
                        if (activeBView->canWrite)
754
                                Frame3->addItem(activeBView, d.dirName());
755
                        else
756
                                Frame3->addItem(activeBView, QIcon(loadIcon("16/lock.png")), d.dirName());
4735 fschmid 757
                        activeBView->ReadContents(fileName);
758
                        activeBView->ScFilename = fileName;
9823 fschmid 759
                        activeBView->scrollToTop();
4735 fschmid 760
                }
761
        }
10564 fschmid 762
        activeBView = (BibView*)Frame3->widget(0);
8336 fschmid 763
        Frame3->setCurrentIndex(0);
11239 fschmid 764
        connect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
9818 fschmid 765
        connect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 766
        connect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 767
        connect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 768
        connect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
4735 fschmid 769
}
770
 
771
QStringList Biblio::getOpenScrapbooks()
772
{
773
        QStringList ret;
774
        ret.clear();
5760 fschmid 775
        if (Frame3->count() > 2) // omit the first 2 Tabs since they contain the main and temp scrapbook
4735 fschmid 776
        {
5760 fschmid 777
                for (int a = 2; a < Frame3->count(); a++)
4735 fschmid 778
                {
10564 fschmid 779
                        BibView* bv = (BibView*)Frame3->widget(a);
4735 fschmid 780
                        ret.append(bv->ScFilename);
781
                }
782
        }
783
        return ret;
784
}
785
 
2144 cbradney 786
void Biblio::setScrapbookFileName(QString fileName)
1448 cbradney 787
{
4643 fschmid 788
        activeBView->ScFilename=fileName;
1448 cbradney 789
}
790
 
2144 cbradney 791
const QString Biblio::getScrapbookFileName()
1448 cbradney 792
{
4643 fschmid 793
        return activeBView->ScFilename;
1448 cbradney 794
}
795
 
2144 cbradney 796
const int Biblio::objectCount()
797
{
4643 fschmid 798
        return activeBView->objectMap.count();
2144 cbradney 799
}
4693 fschmid 800
 
4611 fschmid 801
void Biblio::readOldContents(QString fileName, QString newName)
802
{
4643 fschmid 803
        activeBView->ReadOldContents(fileName, newName);
9823 fschmid 804
        activeBView->scrollToTop();
4611 fschmid 805
}
806
 
2144 cbradney 807
void Biblio::readContents(QString fileName)
808
{
4643 fschmid 809
        activeBView->ReadContents(fileName);
2144 cbradney 810
}
811
 
5760 fschmid 812
void Biblio::readTempContents(QString fileName)
813
{
814
        tempBView->ReadContents(fileName);
815
        tempBView->ScFilename = fileName;
5787 fschmid 816
        tempCount = tempBView->objectMap.count();
5760 fschmid 817
}
818
 
8571 jghali 819
void Biblio::installEventFilter(QObject *filterObj)
2144 cbradney 820
{
821
        ScrPaletteBase::installEventFilter(filterObj);
4643 fschmid 822
        activeBView->installEventFilter(filterObj);
5760 fschmid 823
        tempBView->installEventFilter(filterObj);
2144 cbradney 824
}
825
 
4643 fschmid 826
void Biblio::NewLib()
3 paul 827
{
2856 cbradney 828
        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
11269 fschmid 829
        QString fileName = QFileDialog::getExistingDirectory(this, tr("Choose a Scrapbook Directory"), dirs->get("scrap_load", "."));
4643 fschmid 830
        if (!fileName.isEmpty())
248 Franz 831
        {
4643 fschmid 832
                for (int a = 0; a < Frame3->count(); a++)
833
                {
10564 fschmid 834
                        BibView* bv = (BibView*)Frame3->widget(a);
4643 fschmid 835
                        if (fileName == bv->ScFilename)
836
                                return;
837
                }
9818 fschmid 838
                disconnect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 839
                disconnect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 840
                disconnect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 841
                disconnect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
11239 fschmid 842
                disconnect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
4643 fschmid 843
                QDir d(fileName);
844
                activeBView = new BibView(this);
8336 fschmid 845
                Frame3->addItem(activeBView, d.dirName());
4643 fschmid 846
                activeBView->ScFilename = fileName;
10564 fschmid 847
                Frame3->setCurrentWidget(activeBView);
4649 fschmid 848
                d.cdUp();
10564 fschmid 849
                dirs->set("scrap_load", d.absolutePath());
11239 fschmid 850
                connect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
9818 fschmid 851
                connect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 852
                connect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 853
                connect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 854
                connect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
248 Franz 855
        }
3 paul 856
}
857
 
858
void Biblio::Load()
859
{
2856 cbradney 860
        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
11269 fschmid 861
        QString fileName = QFileDialog::getExistingDirectory(this, tr("Choose a Scrapbook Directory"), dirs->get("scrap_load", "."));
3 paul 862
        if (!fileName.isEmpty())
248 Franz 863
        {
4643 fschmid 864
                for (int a = 0; a < Frame3->count(); a++)
865
                {
10564 fschmid 866
                        BibView* bv = (BibView*)Frame3->widget(a);
4643 fschmid 867
                        if (fileName == bv->ScFilename)
868
                                return;
869
                }
9818 fschmid 870
                disconnect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 871
                disconnect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 872
                disconnect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 873
                disconnect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
11239 fschmid 874
                disconnect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
4643 fschmid 875
                QDir d(fileName);
876
                activeBView = new BibView(this);
9819 fschmid 877
                QFileInfo fd(fileName);
878
                activeBView->canWrite = fd.isWritable();
879
                activeBView->setAcceptDrops(activeBView->canWrite);
880
                if (activeBView->canWrite)
881
                        Frame3->addItem(activeBView, d.dirName());
882
                else
883
                        Frame3->addItem(activeBView, QIcon(loadIcon("16/lock.png")), d.dirName());
4643 fschmid 884
                activeBView->ReadContents(fileName);
885
                activeBView->ScFilename = fileName;
10564 fschmid 886
                Frame3->setCurrentWidget(activeBView);
4649 fschmid 887
                d.cdUp();
10564 fschmid 888
                dirs->set("scrap_load", d.absolutePath());
9823 fschmid 889
                activeBView->scrollToTop();
11239 fschmid 890
                connect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
9818 fschmid 891
                connect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 892
                connect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 893
                connect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 894
                connect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
248 Franz 895
        }
3 paul 896
}
897
 
5058 tsoots 898
void Biblio::Import()
899
{
900
        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
11269 fschmid 901
        QString s = QFileDialog::getOpenFileName(this,
902
                                                 tr("Choose a scrapbook file to import"),
903
                                                 dirs->get("old_scrap_load", "."),
904
                                                 tr("Scrapbook (*.scs *.SCS)"));
5058 tsoots 905
 
906
        if (!s.isEmpty())
907
        {
10427 cbradney 908
                dirs->set("old_scrap_load", s.left(s.lastIndexOf(QDir::convertSeparators("/"))));
5058 tsoots 909
 
910
                QString scrapbookFileO = s;
911
                QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
912
                if (scrapbookFileInfoO.exists())
913
                {
914
                        readOldContents(scrapbookFileO, activeBView->ScFilename);
915
                        readContents(activeBView->ScFilename);
916
                }
9823 fschmid 917
                activeBView->scrollToTop();
5058 tsoots 918
        }
919
}
920
 
4643 fschmid 921
void Biblio::SaveAs()
922
{
923
        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
11269 fschmid 924
        QString fn = QFileDialog::getExistingDirectory(this, tr("Choose a Directory"), dirs->get("scrap_saveas", "."));
4643 fschmid 925
        if (!fn.isEmpty())
926
        {
11269 fschmid 927
                for (int a = 0; a < Frame3->count(); a++)
928
                {
929
                        BibView* bv = (BibView*)Frame3->widget(a);
930
                        if (fn == bv->ScFilename)
931
                                return;
932
                }
4649 fschmid 933
                QDir d(fn);
4643 fschmid 934
                dirs->set("scrap_saveas", fn);
935
                activeBView->SaveContents(fn, activeBView->ScFilename);
4649 fschmid 936
                d.cdUp();
10564 fschmid 937
                dirs->set("scrap_saveas", d.absolutePath());
4643 fschmid 938
        }
939
}
940
 
941
void Biblio::closeLib()
942
{
5760 fschmid 943
        if (Frame3->count() == 2)
4643 fschmid 944
                close();
8336 fschmid 945
        if ((Frame3->currentIndex() == 0) || (Frame3->currentIndex() == 1))
5779 fschmid 946
                return;
4643 fschmid 947
        else
948
        {
9818 fschmid 949
                disconnect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 950
                disconnect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 951
                disconnect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 952
                disconnect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
11239 fschmid 953
                disconnect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
10564 fschmid 954
                Frame3->removeItem(Frame3->indexOf(activeBView));
11269 fschmid 955
                delete activeBView;  // currently disabled as the whole TabWidget vanishes when executing that delete????? -> seems to be fixed in Qt-4.3.3
10564 fschmid 956
                activeBView = (BibView*)Frame3->widget(0);
8336 fschmid 957
                Frame3->setCurrentIndex(0);
11239 fschmid 958
                connect(Frame3, SIGNAL(currentChanged(int)), this, SLOT(libChanged(int )));
9818 fschmid 959
                connect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 960
                connect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 961
                connect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 962
                connect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
4649 fschmid 963
        }
4643 fschmid 964
}
965
 
8336 fschmid 966
void Biblio::libChanged(int index)
4643 fschmid 967
{
9818 fschmid 968
        disconnect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 969
        disconnect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 970
        disconnect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 971
        disconnect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
10564 fschmid 972
        activeBView = (BibView*)Frame3->widget(index);
9818 fschmid 973
        connect(activeBView, SIGNAL(objDropped(QString)), this, SLOT(ObjFromMenu(QString)));
14715 fschmid 974
        connect(activeBView, SIGNAL(fileDropped(QString, int)), this, SLOT(ObjFromFile(QString, int)));
9819 fschmid 975
        connect(activeBView, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(HandleMouse(QPoint)));
11554 fschmid 976
        connect(activeBView, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(handleDoubleClick(QListWidgetItem *)));
4643 fschmid 977
}
3 paul 978
 
11554 fschmid 979
void Biblio::handleDoubleClick(QListWidgetItem *ite)
980
{
981
        emit pasteToActualPage(ite->text());
982
        activeBView->clearSelection();
983
        actItem = 0;
984
}
985
 
11557 fschmid 986
void Biblio::handlePasteToPage()
987
{
988
        emit pasteToActualPage(actItem->text());
989
        activeBView->clearSelection();
990
        actItem = 0;
991
}
992
 
9819 fschmid 993
void Biblio::HandleMouse(QPoint p)
3 paul 994
{
9819 fschmid 995
        QListWidgetItem *ite = activeBView->itemAt(p);
9818 fschmid 996
        if (ite != 0)
248 Franz 997
        {
9819 fschmid 998
                actItem = ite;
9818 fschmid 999
                QMenu *pmenu = new QMenu();
9819 fschmid 1000
                QAction* renAct;
1001
                QAction* delAct;
11557 fschmid 1002
                QAction* pasteAct = pmenu->addAction( tr("Paste to Page"));
1003
                connect(pasteAct, SIGNAL(triggered()), this, SLOT(handlePasteToPage()));
9819 fschmid 1004
                if (activeBView->canWrite)
1005
                {
1006
                        renAct = pmenu->addAction( tr("Rename"));
1007
                        connect(renAct, SIGNAL(triggered()), this, SLOT(renameObj()));
1008
                        delAct = pmenu->addAction( tr("Delete"));
1009
                        connect(delAct, SIGNAL(triggered()), this, SLOT(deleteObj()));
1010
                }
9818 fschmid 1011
                QSignalMapper *signalMapper = new QSignalMapper(this);
1012
                connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(copyObj(int)));
1013
                QMenu *pmenu2 = new QMenu( tr("Copy To:"));
9945 fschmid 1014
                QMenu *pmenu3 = new QMenu( tr("Move To:"));
1015
                QSignalMapper *signalMapper2 = new QSignalMapper(this);
1016
                connect(signalMapper2, SIGNAL(mapped(int)), this, SLOT(moveObj(int)));
5806 fschmid 1017
                for (int a = 0; a < Frame3->count(); a++)
1018
                {
10564 fschmid 1019
                        BibView* bv = (BibView*)Frame3->widget(a);
5806 fschmid 1020
                        if (bv != activeBView)
1021
                        {
9819 fschmid 1022
                                if (bv->canWrite)
1023
                                {
10564 fschmid 1024
                                QAction *action = pmenu2->addAction(Frame3->itemText(Frame3->indexOf(Frame3->widget(a))));
9819 fschmid 1025
                                        connect(action, SIGNAL(triggered()), signalMapper, SLOT(map()));
1026
                                        signalMapper->setMapping(action, a);
1027
                                        if (activeBView->canWrite)
1028
                                        {
10564 fschmid 1029
                                        QAction *action2 = pmenu3->addAction(Frame3->itemText(Frame3->indexOf(Frame3->widget(a))));
9819 fschmid 1030
                                                connect(action2, SIGNAL(triggered()), signalMapper2, SLOT(map()));
1031
                                                signalMapper2->setMapping(action2, a);
1032
                                        }
1033
                                }
5806 fschmid 1034
                        }
1035
                }
9818 fschmid 1036
                pmenu->addMenu(pmenu2);
9819 fschmid 1037
                if (activeBView->canWrite)
1038
                        pmenu->addMenu(pmenu3);
9380 fschmid 1039
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
9818 fschmid 1040
                pmenu->exec(QCursor::pos());
248 Franz 1041
                delete pmenu;
9818 fschmid 1042
                delete pmenu2;
1043
                delete signalMapper;
9819 fschmid 1044
                if (activeBView->canWrite)
1045
                {
1046
                        delete pmenu3;
1047
                        delete signalMapper2;
1048
                }
248 Franz 1049
        }
11239 fschmid 1050
        else
1051
        {
1052
                QMenu *pmenu = new QMenu();
1053
                QAction* delAct;
1054
                QAction* saveAct;
1055
                QAction* closeAct;
1056
                if (activeBView->objectMap.count() != 0)
1057
                {
1058
                        saveAct = pmenu->addAction( tr("Save as..."));
1059
                        connect(saveAct, SIGNAL(triggered()), this, SLOT(SaveAs()));
1060
                }
1061
                closeAct = pmenu->addAction( tr("Close"));
1062
                if ((activeBView->canWrite) && (activeBView->objectMap.count() != 0))
1063
                {
1064
                        delAct = pmenu->addAction( tr("Delete Contents"));
1065
                        connect(delAct, SIGNAL(triggered()), this, SLOT(deleteAllObj()));
1066
                }
1067
                connect(closeAct, SIGNAL(triggered()), this, SLOT(closeLib()));
1068
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1069
                pmenu->exec(QCursor::pos());
1070
                delete pmenu;
1071
        }
5806 fschmid 1072
        activeBView->clearSelection();
9819 fschmid 1073
        actItem = 0;
3 paul 1074
}
1075
 
5806 fschmid 1076
bool Biblio::copyObj(int id)
1077
{
9819 fschmid 1078
        QListWidgetItem *ite = actItem;
5806 fschmid 1079
        QString nam = ite->text();
10564 fschmid 1080
        BibView* bv = (BibView*)Frame3->widget(id);
5806 fschmid 1081
        if (bv->objectMap.contains(nam))
1082
        {
1083
                Query *dia = new Query(this, "tt", 1, 0, tr("&Name:"), tr("New Entry"));
1084
                dia->setEditText(nam, true);
14438 fschmid 1085
                dia->setTestList(activeBView->objectMap.keys());
5806 fschmid 1086
                if (dia->exec())
1087
                {
1088
                        nam = dia->getEditText();
1089
                }
1090
                else
1091
                {
1092
                        delete dia;
1093
                        return false;
1094
                }
1095
        }
1096
        QPixmap pm;
9535 fschmid 1097
        QByteArray cf;
10398 cbradney 1098
        if (!loadRawText(QDir::cleanPath(activeBView->objectMap[ite->text()].Data), cf))
5806 fschmid 1099
                return false;
1100
        pm = activeBView->objectMap[ite->text()].Preview;
6028 jghali 1101
        QString dt = activeBView->objectMap[ite->text()].Data;
5806 fschmid 1102
        QFileInfo fi(dt);
10564 fschmid 1103
        QFile f(QDir::cleanPath(QDir::convertSeparators(bv->ScFilename + "/" + nam + "." + fi.completeSuffix().toLower())));
8501 cbradney 1104
        if(!f.open(QIODevice::WriteOnly))
5806 fschmid 1105
                return false;
9818 fschmid 1106
        QDataStream s;
5806 fschmid 1107
        s.setDevice(&f);
10564 fschmid 1108
        s.writeRawData(cf.data(), cf.length());
5806 fschmid 1109
        f.close();
10564 fschmid 1110
        bv->AddObj(nam, QDir::cleanPath(QDir::convertSeparators(bv->ScFilename + "/" + nam + "." + fi.completeSuffix().toLower())), pm);
10398 cbradney 1111
        pm.save(QDir::cleanPath(QDir::convertSeparators(bv->ScFilename + "/" + nam +".png")), "PNG");
8295 fschmid 1112
        QFileInfo fiD(QDir::convertSeparators(activeBView->ScFilename + "/" + fi.baseName()));
1113
        if ((fiD.exists()) && (fiD.isDir()))
1114
        {
10398 cbradney 1115
                QDir dd = QDir(QDir::cleanPath(QDir::convertSeparators(bv->ScFilename)));
1116
                dd.mkdir(QDir::cleanPath(QDir::convertSeparators(bv->ScFilename + "/" + nam)));
8295 fschmid 1117
                QDir d(QDir::convertSeparators(activeBView->ScFilename + "/" + fi.baseName()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1118
                if ((d.exists()) && (d.count() != 0))
1119
                {
1120
                        for (uint dc = 0; dc < d.count(); ++dc)
1121
                        {
10398 cbradney 1122
                                QString source = QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + fi.baseName() + "/" + d[dc]));
1123
                                QString target = QDir::cleanPath(QDir::convertSeparators(bv->ScFilename + "/" + nam + "/" + d[dc]));
8295 fschmid 1124
                                copyFile(source, target);
1125
                        }
1126
                }
1127
                if (fiD.baseName() != nam)
10564 fschmid 1128
                        adjustReferences(QDir::convertSeparators(bv->ScFilename + "/" + nam + "." + fi.completeSuffix().toLower()));
8295 fschmid 1129
        }
9819 fschmid 1130
        if (pm.width() > 60)
1131
                pm = pm.scaledToWidth(60, Qt::SmoothTransformation);
1132
        if (pm.height() > 60)
1133
                pm = pm.scaledToHeight(60, Qt::SmoothTransformation);
1134
        QPixmap pm2(60, 60);
10737 fschmid 1135
        pm2.fill(palette().color(QPalette::Base));
9819 fschmid 1136
        QPainter p;
1137
        p.begin(&pm2);
1138
        p.drawPixmap(30 - pm.width() / 2, 30 - pm.height() / 2, pm);
1139
        p.end();
1140
        new QListWidgetItem(QIcon(pm), nam, bv);
5806 fschmid 1141
        if (bv == tempBView)
1142
        {
1143
                tempCount++;
13955 cbradney 1144
                if (tempBView->objectMap.count() > PrefsManager::instance()->appPrefs.scrapbookPrefs.numScrapbookCopies)
5806 fschmid 1145
                {
1146
                        QMap<QString,BibView::Elem>::Iterator it;
1147
                        it = tempBView->objectMap.begin();
10516 cbradney 1148
                        QFile f(it.value().Data);
5806 fschmid 1149
                        f.remove();
1150
                        QFileInfo fi(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1151
                        if (fi.exists())
1152
                        {
1153
                                QFile f2(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1154
                                f2.remove();
1155
                        }
8295 fschmid 1156
                        QFileInfo fiD(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1157
                        if ((fiD.exists()) && (fiD.isDir()))
1158
                        {
1159
                                QDir dd = QDir(QDir::convertSeparators(tempBView->ScFilename));
1160
                                QDir d(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1161
                                if ((d.exists()) && (d.count() != 0))
1162
                                {
1163
                                        for (uint dc = 0; dc < d.count(); ++dc)
1164
                                        {
1165
                                                QFile::remove(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1166
                                        }
1167
                                }
1168
                                dd.rmdir(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1169
                        }
9818 fschmid 1170
                        QString name = it.key();
10564 fschmid 1171
                        tempBView->objectMap.erase(it);
9818 fschmid 1172
                        QList<QListWidgetItem *> itL = tempBView->findItems(name, Qt::MatchExactly);
1173
                        if (itL.count() > 0)
1174
                        {
1175
                                ite = itL.at(0);
1176
                                delete tempBView->takeItem(tempBView->row(ite));
1177
                        }
1178
                        tempBView->sortItems();
5806 fschmid 1179
                }
1180
                emit updateRecentMenue();
1181
        }
1182
        return true;
1183
}
1184
 
1185
void Biblio::moveObj(int id)
1186
{
1187
        if (copyObj(id))
1188
        {
9818 fschmid 1189
                deleteObj();
5806 fschmid 1190
        }
1191
}
1192
 
9818 fschmid 1193
void Biblio::deleteObj()
3 paul 1194
{
9819 fschmid 1195
        if (!activeBView->canWrite)
1196
                return;
1197
        QListWidgetItem *ite = actItem;
9818 fschmid 1198
        QString name = ite->text();
8295 fschmid 1199
        QFile::remove(activeBView->objectMap[name].Data);
4649 fschmid 1200
        QFileInfo fi(QDir::convertSeparators(activeBView->ScFilename + "/" + name + ".png"));
1201
        if (fi.exists())
8295 fschmid 1202
                QFile::remove(QDir::convertSeparators(activeBView->ScFilename + "/" + name + ".png"));
1203
        QFileInfo fiD(QDir::convertSeparators(activeBView->ScFilename + "/" + name));
1204
        if ((fiD.exists()) && (fiD.isDir()))
4649 fschmid 1205
        {
8295 fschmid 1206
                QDir dd = QDir(QDir::convertSeparators(activeBView->ScFilename));
1207
                QDir d(QDir::convertSeparators(activeBView->ScFilename + "/" + name), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1208
                if ((d.exists()) && (d.count() != 0))
1209
                {
1210
                        for (uint dc = 0; dc < d.count(); ++dc)
1211
                        {
1212
                                QFile::remove(QDir::convertSeparators(activeBView->ScFilename + "/" + name + "/" + d[dc]));
1213
                        }
1214
                }
1215
                dd.rmdir(name);
4649 fschmid 1216
        }
4643 fschmid 1217
        activeBView->objectMap.remove(name);
9818 fschmid 1218
        delete activeBView->takeItem(activeBView->row(ite));
1219
        activeBView->sortItems();
5806 fschmid 1220
        if (activeBView == tempBView)
1221
                emit updateRecentMenue();
9819 fschmid 1222
        actItem = 0;
3 paul 1223
}
1224
 
11239 fschmid 1225
void Biblio::deleteAllObj()
1226
{
1227
        if (!activeBView->canWrite)
1228
                return;
1229
        int t = QMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to delete all entries?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
1230
        if (t == QMessageBox::No)
1231
                return;
1232
        QMap<QString,BibView::Elem>::Iterator it;
1233
        for (it = activeBView->objectMap.begin(); it != activeBView->objectMap.end(); ++it)
1234
        {
1235
                QFile f(it.value().Data);
1236
                f.remove();
1237
                QFileInfo fi(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key() + ".png"));
1238
                if (fi.exists())
1239
                {
1240
                        QFile f2(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key() + ".png"));
1241
                        f2.remove();
1242
                }
1243
                QFileInfo fiD(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key()));
1244
                if ((fiD.exists()) && (fiD.isDir()))
1245
                {
1246
                        QDir dd = QDir(QDir::convertSeparators(activeBView->ScFilename));
1247
                        QDir d(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1248
                        if ((d.exists()) && (d.count() != 0))
1249
                        {
1250
                                for (uint dc = 0; dc < d.count(); ++dc)
1251
                                {
1252
                                        QFile::remove(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1253
                                }
1254
                        }
1255
                        dd.rmdir(QDir::convertSeparators(activeBView->ScFilename + "/" + it.key()));
1256
                }
1257
        }
1258
        activeBView->clear();
1259
        activeBView->objectMap.clear();
1260
        if (activeBView == tempBView)
1261
                emit updateRecentMenue();
1262
        actItem = 0;
1263
}
1264
 
9819 fschmid 1265
void Biblio::renameObj()
291 Franz 1266
{
9819 fschmid 1267
        if (!activeBView->canWrite)
1268
                return;
1269
        QString nam;
291 Franz 1270
        QString ObjData;
1271
        QPixmap ObjPreview;
9819 fschmid 1272
        QListWidgetItem *ite = actItem;
1273
        QString OldName = ite->text();
1274
        Query *dia = new Query(this, "tt", 1, 0, tr("&Name:"), tr("New Name"));
1275
        dia->setEditText(ite->text(), true);
14438 fschmid 1276
        dia->setTestList(activeBView->objectMap.keys());
9819 fschmid 1277
        if (dia->exec())
291 Franz 1278
        {
9819 fschmid 1279
                nam = dia->getEditText();
291 Franz 1280
        }
9819 fschmid 1281
        else
1282
        {
1283
                delete dia;
1284
                return;
1285
        }
1286
        delete dia;
1287
        ite->setText(nam);
1288
        ObjData = activeBView->objectMap[OldName].Data;
1289
        ObjPreview = activeBView->objectMap[OldName].Preview;
1290
        QDir d = QDir();
10398 cbradney 1291
        d.rename(ObjData, QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + ite->text() + ".sce")));
9819 fschmid 1292
        QFileInfo fi(QDir::convertSeparators(activeBView->ScFilename + "/" + OldName + ".png"));
1293
        if (fi.exists())
10398 cbradney 1294
                d.rename(QDir::convertSeparators(activeBView->ScFilename + "/" + OldName + ".png"), QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + ite->text() + ".png")));
9819 fschmid 1295
        QFileInfo fiD(QDir::convertSeparators(activeBView->ScFilename + "/" + OldName));
1296
        if ((fiD.exists()) && (fiD.isDir()))
1297
        {
1298
                QDir d = QDir();
10398 cbradney 1299
                d.rename(QDir::convertSeparators(activeBView->ScFilename + "/" + OldName), QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + ite->text())));
1300
                adjustReferences(QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + ite->text() + ".sce")));
9819 fschmid 1301
        }
1302
        activeBView->objectMap.remove(OldName);
10398 cbradney 1303
        activeBView->AddObj(ite->text(), QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + ite->text() + ".sce")), ObjPreview);
9819 fschmid 1304
        activeBView->sortItems();
1305
        if (activeBView == tempBView)
1306
                emit updateRecentMenue();
291 Franz 1307
}
1308
 
8295 fschmid 1309
void Biblio::adjustReferences(QString nam)
1310
{
9535 fschmid 1311
        QByteArray cf;
8295 fschmid 1312
        if (loadRawText(nam, cf))
1313
        {
1314
                QString f;
1315
                if (cf.left(16) == "<SCRIBUSELEMUTF8")
1316
                        f = QString::fromUtf8(cf.data());
1317
                else
1318
                f = cf.data();
1319
                QDomDocument docu("scridoc");
1320
                docu.setContent(f);
1321
                QDomElement elem = docu.documentElement();
1322
                QDomNode DOC = elem.firstChild();
1323
                QFileInfo fid(nam);
1324
                while(!DOC.isNull())
1325
                {
1326
                        QDomElement pg = DOC.toElement();
1327
                        if(pg.tagName() == "ITEM")
1328
                        {
1329
                                PageItem::ItemType PType = static_cast<PageItem::ItemType>(pg.attribute("PTYPE").toInt());
1330
                                if ((PType == PageItem::ImageFrame) || (PType == PageItem::TextFrame))
1331
                                {
1332
                                        QString Pfile = pg.attribute("PFILE");
1333
                                        if (!Pfile.isEmpty())
1334
                                        {
1335
                                                QFileInfo fi(Pfile);
1336
                                                pg.setAttribute("PFILE", fid.baseName() + "/" + fi.fileName());
1337
                                        }
1338
                                        QString Pfile2 = pg.attribute("PFILE2","");
1339
                                        if (!Pfile2.isEmpty())
1340
                                        {
1341
                                                QFileInfo fi(Pfile2);
1342
                                                pg.setAttribute("PFILE2", fid.baseName() + "/" + fi.fileName());
1343
                                        }
1344
                                        QString Pfile3 = pg.attribute("PFILE3","");
1345
                                        if (!Pfile3.isEmpty())
1346
                                        {
1347
                                                QFileInfo fi(Pfile3);
1348
                                                pg.setAttribute("PFILE3", fid.baseName() + "/" + fi.fileName());
1349
                                        }
1350
                                        pg.setAttribute("relativePaths", 1);
1351
                                }
1352
                        }
1353
                        DOC = DOC.nextSibling();
1354
                }
1355
                QFile fl(nam);
8501 cbradney 1356
                if(!fl.open(QIODevice::WriteOnly))
8295 fschmid 1357
                        return ;
9818 fschmid 1358
                QDataStream s;
8571 jghali 1359
                QByteArray cs = docu.toByteArray();
8295 fschmid 1360
                s.setDevice(&fl);
10564 fschmid 1361
                s.writeRawData(cs.data(), cs.length());
8295 fschmid 1362
                fl.close();
1363
        }
1364
}
1365
 
11548 fschmid 1366
QString Biblio::getObjectName(QString &text)
1367
{
1368
        QDomDocument docu("scridoc");
1369
        docu.setContent(text);
1370
        QDomElement elem = docu.documentElement();
1371
        QDomNode DOC = elem.firstChild();
1372
        QString result = "";
1373
        while(!DOC.isNull())
1374
        {
1375
                QDomElement pg = DOC.toElement();
1376
                if(pg.tagName() == "ITEM")
1377
                {
1378
                        result = pg.attribute("ANNAME");
1379
                        break;
1380
                }
1381
                DOC = DOC.nextSibling();
1382
        }
1383
        return result;
1384
}
1385
 
14715 fschmid 1386
void Biblio::ObjFromFile(QString path, int testResult)
1387
{
1388
        if (!activeBView->canWrite)
1389
                return;
1390
        QString tmp;
1391
        QFileInfo fi(path);
1392
        if ( fi.exists() )
1393
        {
1394
                QString nam = "";
1395
                nam = fi.baseName();
1396
                if (Frame3->currentIndex() == 1)
1397
                {
1398
                        if (activeBView->objectMap.contains(nam))
1399
                                nam += "("+ tmp.setNum(tempCount) + ")";
1400
                        tempCount++;
1401
                }
1402
                else
1403
                {
1404
                        if (activeBView->objectMap.contains(nam))
1405
                                nam += "("+ tmp.setNum(tempCount) + ")";
1406
                }
1407
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1408
                Query *dia = new Query(this, "tt", 1, 0, tr("&Name:"), tr("New Entry"));
1409
                dia->setEditText(nam, true);
1410
                dia->setTestList(activeBView->objectMap.keys());
1411
                if (dia->exec())
1412
                        nam = dia->getEditText();
1413
                else
1414
                {
1415
                        delete dia;
1416
                        return;
1417
                }
1418
                const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
1419
                if( fmt )
1420
                {
1421
                        QImage im = fmt->readThumbnail(path);
1422
                        im = im.scaled(60, 60, Qt::KeepAspectRatio, Qt::SmoothTransformation);
1423
                        QByteArray cf;
1424
                        if (!loadRawText(path, cf))
1425
                                return;
1426
                        QPixmap pm = QPixmap::fromImage(im);
1427
                        QFile f(QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam + "." + fi.completeSuffix())));
1428
                        if(!f.open(QIODevice::WriteOnly))
1429
                                return;
1430
                        QDataStream s;
1431
                        s.setDevice(&f);
1432
                        s.writeRawData(cf.data(), cf.length());
1433
                        f.close();
1434
                        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
1435
                                im.save(QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam +".png")), "PNG");
1436
                        activeBView->AddObj(nam, QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam + "." + fi.completeSuffix())), pm);
1437
                        QPixmap pm2(60, 60);
1438
                        pm2.fill(palette().color(QPalette::Base));
1439
                        QPainter p;
1440
                        p.begin(&pm2);
1441
                        p.drawPixmap(30 - pm.width() / 2, 30 - pm.height() / 2, pm);
1442
                        p.end();
1443
                        new QListWidgetItem(QIcon(pm2), nam, activeBView);
1444
                        if (Frame3->currentIndex() == 1)
1445
                        {
1446
                                if (tempBView->objectMap.count() > PrefsManager::instance()->appPrefs.scrapbookPrefs.numScrapbookCopies)
1447
                                {
1448
                                        QMap<QString,BibView::Elem>::Iterator it;
1449
                                        it = tempBView->objectMap.begin();
1450
                                        QFile f(it.value().Data);
1451
                                        f.remove();
1452
                                        QFileInfo fi(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1453
                                        if (fi.exists())
1454
                                        {
1455
                                                QFile f2(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1456
                                                f2.remove();
1457
                                        }
1458
                                        QFileInfo fiD(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1459
                                        if ((fiD.exists()) && (fiD.isDir()))
1460
                                        {
1461
                                                QDir dd = QDir(QDir::convertSeparators(tempBView->ScFilename));
1462
                                                QDir d(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1463
                                                if ((d.exists()) && (d.count() != 0))
1464
                                                {
1465
                                                        for (uint dc = 0; dc < d.count(); ++dc)
1466
                                                        {
1467
                                                                QFile::remove(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1468
                                                        }
1469
                                                }
1470
                                                dd.rmdir(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1471
                                        }
1472
                                        QString name = it.key();
1473
                                        tempBView->objectMap.erase(it);
1474
                                        QList<QListWidgetItem *> itL = tempBView->findItems(name, Qt::MatchExactly);
1475
                                        if (itL.count() > 0)
1476
                                        {
1477
                                                QListWidgetItem *ite = itL.at(0);
1478
                                                delete tempBView->takeItem(tempBView->row(ite));
1479
                                        }
1480
                                        tempBView->sortItems();
1481
                                }
1482
                                emit updateRecentMenue();
1483
                        }
1484
                }
1485
        }
1486
}
1487
 
3 paul 1488
void Biblio::ObjFromMenu(QString text)
1489
{
11548 fschmid 1490
        QString nam = "";
1491
        QString tmp;
9819 fschmid 1492
        if (!activeBView->canWrite)
1493
                return;
11548 fschmid 1494
        nam = getObjectName(text);
8336 fschmid 1495
        if (Frame3->currentIndex() == 1)
5787 fschmid 1496
        {
11548 fschmid 1497
                if (nam.isEmpty())
1498
                        nam = tr("Object") + tmp.setNum(tempCount);
1499
                if (activeBView->objectMap.contains(nam))
1500
                        nam += "("+ tmp.setNum(tempCount) + ")";
5787 fschmid 1501
                tempCount++;
1502
        }
1503
        else
11548 fschmid 1504
        {
1505
                if (nam.isEmpty())
1506
                        nam = tr("Object") + tmp.setNum(activeBView->objectMap.count());
1507
                if (activeBView->objectMap.contains(nam))
1508
                        nam += "("+ tmp.setNum(tempCount) + ")";
1509
        }
11288 fschmid 1510
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
348 Franz 1511
        Query *dia = new Query(this, "tt", 1, 0, tr("&Name:"), tr("New Entry"));
702 cbradney 1512
        dia->setEditText(nam, true);
14438 fschmid 1513
        dia->setTestList(activeBView->objectMap.keys());
248 Franz 1514
        if (dia->exec())
1515
        {
702 cbradney 1516
                nam = dia->getEditText();
248 Franz 1517
        }
1518
        else
1519
        {
1520
                delete dia;
1521
                return;
1522
        }
1523
        delete dia;
6199 fschmid 1524
        QString ff = text;
11244 fschmid 1525
        activeBView->checkAndChange(ff, QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam + ".sce")), QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename)));
2834 cbradney 1526
        ScPreview *pre = new ScPreview();
30 Franz 1527
        QPixmap pm = pre->createPreview(ff);
10398 cbradney 1528
        activeBView->AddObj(nam, QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam + ".sce")), pm);
14715 fschmid 1529
        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
1530
                pm.save(QDir::cleanPath(QDir::convertSeparators(activeBView->ScFilename + "/" + nam +".png")), "PNG");
9819 fschmid 1531
        if (pm.width() > 60)
1532
                pm = pm.scaledToWidth(60, Qt::SmoothTransformation);
1533
        if (pm.height() > 60)
1534
                pm = pm.scaledToHeight(60, Qt::SmoothTransformation);
1535
        QPixmap pm2(60, 60);
10737 fschmid 1536
        pm2.fill(palette().color(QPalette::Base));
9819 fschmid 1537
        QPainter p;
1538
        p.begin(&pm2);
1539
        p.drawPixmap(30 - pm.width() / 2, 30 - pm.height() / 2, pm);
1540
        p.end();
9823 fschmid 1541
        new QListWidgetItem(QIcon(pm2), nam, activeBView);
30 Franz 1542
        delete pre;
8336 fschmid 1543
        if (Frame3->currentIndex() == 1)
5787 fschmid 1544
        {
13955 cbradney 1545
                if (tempBView->objectMap.count() > PrefsManager::instance()->appPrefs.scrapbookPrefs.numScrapbookCopies)
5787 fschmid 1546
                {
1547
                        QMap<QString,BibView::Elem>::Iterator it;
1548
                        it = tempBView->objectMap.begin();
10516 cbradney 1549
                        QFile f(it.value().Data);
5787 fschmid 1550
                        f.remove();
1551
                        QFileInfo fi(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1552
                        if (fi.exists())
1553
                        {
1554
                                QFile f2(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1555
                                f2.remove();
1556
                        }
8295 fschmid 1557
                        QFileInfo fiD(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1558
                        if ((fiD.exists()) && (fiD.isDir()))
1559
                        {
1560
                                QDir dd = QDir(QDir::convertSeparators(tempBView->ScFilename));
1561
                                QDir d(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1562
                                if ((d.exists()) && (d.count() != 0))
1563
                                {
1564
                                        for (uint dc = 0; dc < d.count(); ++dc)
1565
                                        {
1566
                                                QFile::remove(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1567
                                        }
1568
                                }
1569
                                dd.rmdir(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1570
                        }
9818 fschmid 1571
                        QString name = it.key();
10564 fschmid 1572
                        tempBView->objectMap.erase(it);
9818 fschmid 1573
                        QList<QListWidgetItem *> itL = tempBView->findItems(name, Qt::MatchExactly);
1574
                        if (itL.count() > 0)
1575
                        {
1576
                                QListWidgetItem *ite = itL.at(0);
1577
                                delete tempBView->takeItem(tempBView->row(ite));
1578
                        }
1579
                        tempBView->sortItems();
5787 fschmid 1580
                }
5806 fschmid 1581
                emit updateRecentMenue();
5787 fschmid 1582
        }
3 paul 1583
}
2191 cbradney 1584
 
11548 fschmid 1585
void Biblio::ObjFromCopyAction(QString text, QString name)
5760 fschmid 1586
{
11548 fschmid 1587
        QString nam = "";
1588
        QString tmp;
1589
        nam = name;
1590
        if (nam.isEmpty())
1591
                nam = tr("Object") + tmp.setNum(tempCount);
1592
        if (tempBView->objectMap.contains(nam))
1593
                nam += "("+ tmp.setNum(tempCount) + ")";
5787 fschmid 1594
        tempCount++;
5760 fschmid 1595
        QString ff = text;
11244 fschmid 1596
        tempBView->checkAndChange(ff, QDir::cleanPath(QDir::convertSeparators(tempBView->ScFilename + "/" + nam + ".sce")), QDir::cleanPath(QDir::convertSeparators(tempBView->ScFilename)));
5760 fschmid 1597
        ScPreview *pre = new ScPreview();
1598
        QPixmap pm = pre->createPreview(ff);
10398 cbradney 1599
        tempBView->AddObj(nam, QDir::cleanPath(QDir::convertSeparators(tempBView->ScFilename + "/" + nam + ".sce")), pm);
14715 fschmid 1600
        if (PrefsManager::instance()->appPrefs.scrapbookPrefs.writePreviews)
1601
                pm.save(QDir::cleanPath(QDir::convertSeparators(tempBView->ScFilename + "/" + nam +".png")), "PNG");
9819 fschmid 1602
        if (pm.width() > 60)
1603
                pm = pm.scaledToWidth(60, Qt::SmoothTransformation);
1604
        if (pm.height() > 60)
1605
                pm = pm.scaledToHeight(60, Qt::SmoothTransformation);
1606
        QPixmap pm2(60, 60);
10737 fschmid 1607
        pm2.fill(palette().color(QPalette::Base));
9819 fschmid 1608
        QPainter p;
1609
        p.begin(&pm2);
1610
        p.drawPixmap(30 - pm.width() / 2, 30 - pm.height() / 2, pm);
1611
        p.end();
9823 fschmid 1612
        new QListWidgetItem(QIcon(pm2), nam, tempBView);
5760 fschmid 1613
        delete pre;
13955 cbradney 1614
        if (tempBView->objectMap.count() > PrefsManager::instance()->appPrefs.scrapbookPrefs.numScrapbookCopies)
5787 fschmid 1615
        {
1616
                QMap<QString,BibView::Elem>::Iterator it;
1617
                it = tempBView->objectMap.begin();
10516 cbradney 1618
                QFile f(it.value().Data);
5787 fschmid 1619
                f.remove();
1620
                QFileInfo fi(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1621
                if (fi.exists())
1622
                {
1623
                        QFile f2(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1624
                        f2.remove();
1625
                }
8295 fschmid 1626
                QFileInfo fiD(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1627
                if ((fiD.exists()) && (fiD.isDir()))
1628
                {
1629
                        QDir dd = QDir(QDir::convertSeparators(tempBView->ScFilename));
1630
                        QDir d(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1631
                        if ((d.exists()) && (d.count() != 0))
1632
                        {
1633
                                for (uint dc = 0; dc < d.count(); ++dc)
1634
                                {
1635
                                        QFile::remove(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1636
                                }
1637
                        }
1638
                        dd.rmdir(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1639
                }
9818 fschmid 1640
                QString name = it.key();
10564 fschmid 1641
                tempBView->objectMap.erase(it);
9818 fschmid 1642
                QList<QListWidgetItem *> itL = tempBView->findItems(name, Qt::MatchExactly);
1643
                if (itL.count() > 0)
1644
                {
1645
                        QListWidgetItem *ite = itL.at(0);
1646
                        delete tempBView->takeItem(tempBView->row(ite));
1647
                }
1648
                tempBView->sortItems();
5787 fschmid 1649
        }
5760 fschmid 1650
}
1651
 
1652
void Biblio::CleanUpTemp()
1653
{
1654
        QMap<QString,BibView::Elem>::Iterator it;
1655
        for (it = tempBView->objectMap.begin(); it != tempBView->objectMap.end(); ++it)
1656
        {
10516 cbradney 1657
                QFile f(it.value().Data);
5760 fschmid 1658
                f.remove();
1659
                QFileInfo fi(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1660
                if (fi.exists())
1661
                {
1662
                        QFile f2(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + ".png"));
1663
                        f2.remove();
1664
                }
8295 fschmid 1665
                QFileInfo fiD(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1666
                if ((fiD.exists()) && (fiD.isDir()))
1667
                {
1668
                        QDir dd = QDir(QDir::convertSeparators(tempBView->ScFilename));
1669
                        QDir d(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()), "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1670
                        if ((d.exists()) && (d.count() != 0))
1671
                        {
1672
                                for (uint dc = 0; dc < d.count(); ++dc)
1673
                                {
1674
                                        QFile::remove(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key() + "/" + d[dc]));
1675
                                }
1676
                        }
1677
                        dd.rmdir(QDir::convertSeparators(tempBView->ScFilename + "/" + it.key()));
1678
                }
5760 fschmid 1679
        }
1680
}
1681
 
10859 cbradney 1682
void Biblio::changeEvent(QEvent *e)
1683
{
1684
        if (e->type() == QEvent::LanguageChange)
1685
                languageChange();
10903 cbradney 1686
        else
1687
                QWidget::changeEvent(e);
10859 cbradney 1688
}
1689
 
2191 cbradney 1690
void Biblio::languageChange()
1691
{
9818 fschmid 1692
        setWindowTitle( tr( "Scrapbook" ) );
10397 cbradney 1693
        newButton->setToolTip( tr( "Create a new scrapbook page" ) );
1694
        loadButton->setToolTip( tr( "Load an existing scrapbook" ) );
1695
        saveAsButton->setToolTip( tr( "Save the selected scrapbook" ) );
1696
        importButton->setToolTip( tr( "Import an scrapbook file from Scribus <=1.3.2" ) );
1697
        closeButton->setToolTip( tr( "Close the selected scrapbook" ) );
2191 cbradney 1698
}