Subversion Repositories Scribus

Rev

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