Subversion Repositories Scribus

Rev

Rev 14037 | Rev 15730 | 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
*/
181 Franz 7
/***************************************************************************
14037 subik 8
                                                          guidemanager.cpp
9
                                                         -------------------
10
        begin                      : Fri Jan 30 2004
11
        copyright                  : (C) 2004 by Alessandro Rimoldi
12
        copyright                  : (C) by Franz Schmid
13
        e-mail                   : http://www.ideale.ch/contact
181 Franz 14
 ***************************************************************************/
15
 
16
/***************************************************************************
14037 subik 17
 *                                                                                                                                         *
181 Franz 18
 *   This program is free software; you can redistribute it and/or modify  *
19
 *   it under the terms of the GNU General Public License as published by  *
14037 subik 20
 *   the Free Software Foundation; either version 2 of the License, or   *
21
 *   (at your option) any later version.                                                                   *
22
 *                                                                                                                                         *
181 Franz 23
 ***************************************************************************/
24
 
5901 subik 25
#include "guidemanager.h"
10181 cbradney 26
#include "commonstrings.h"
27
#include "page.h"
28
#include "scinputdialog.h"
5901 subik 29
#include "scribuscore.h"
30
#include "scribusdoc.h"
10181 cbradney 31
#include "selection.h"
32
#include "undomanager.h"
5901 subik 33
#include "units.h"
34
#include "util.h"
10205 subik 35
#include "guidesmodel.h"
36
#include "guidesdelegate.h"
2164 subik 37
 
181 Franz 38
 
5087 subik 39
GuideManager::GuideManager(QWidget* parent) :
8524 subik 40
                ScrPaletteBase(parent, "GuideManager"),
5909 subik 41
                m_Doc(0),
6747 subik 42
                currentPage(0),
9069 subik 43
                m_drawGuides(true)
3 paul 44
{
8524 subik 45
        setupUi(this);
6001 subik 46
        tabWidget->setEnabled(false);
8664 subik 47
        horizontalAutoGapSpin->setMinimum(0.0);
12807 subik 48
        horizontalAutoGapSpin->setMaximum(10000.0);
8664 subik 49
        verticalAutoGapSpin->setMinimum(0.0);
12807 subik 50
        verticalAutoGapSpin->setMaximum(10000.0);
2143 subik 51
 
10205 subik 52
        // MVC
53
        horizontalModel = new GuidesModel(this);
54
        verticalModel = new GuidesModel(this);
12177 subik 55
        GuidesHDelegate * hdelegate = new GuidesHDelegate();
56
        GuidesVDelegate * vdelegate = new GuidesVDelegate();
57
        horizontalView->setItemDelegateForColumn(0, hdelegate);
58
        verticalView->setItemDelegateForColumn(0, vdelegate);
10205 subik 59
        horizontalView->setModel(horizontalModel);
60
        verticalView->setModel(verticalModel);
61
 
62
        connect(addHorButton, SIGNAL(clicked()), this, SLOT(addHorButton_clicked()));
63
        connect(delHorButton, SIGNAL(clicked()), this, SLOT(delHorButton_clicked()));
13583 subik 64
        connect(horizontalView, SIGNAL(deleteKeyPressed()), this, SLOT(delHorButton_clicked()));
10205 subik 65
        connect(addVerButton, SIGNAL(clicked()), this, SLOT(addVerButton_clicked()));
66
        connect(delVerButton, SIGNAL(clicked()), this, SLOT(delVerButton_clicked()));
13583 subik 67
        connect(verticalView, SIGNAL(deleteKeyPressed()), this, SLOT(delVerButton_clicked()));
12748 subik 68
        connect(horizontalView->selectionModel(),
69
                         SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
70
                         this, SLOT(forceDrawGuides(const QItemSelection &, const QItemSelection &)));
71
        connect(verticalView->selectionModel(),
72
                         SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
73
                         this, SLOT(forceDrawGuides(const QItemSelection &, const QItemSelection &)));
74
 
10205 subik 75
        connect(applyToAllStdButton, SIGNAL(clicked()),
76
                        this, SLOT(applyToAllStdButton_clicked()));
77
        connect(horizontalAutoCountSpin, SIGNAL(valueChanged(int)),
78
                        this, SLOT(horizontalAutoCountSpin_valueChanged(int)));
79
        connect(verticalAutoCountSpin, SIGNAL(valueChanged(int)),
80
                        this, SLOT(verticalAutoCountSpin_valueChanged(int)));
81
        connect(horizontalAutoGapCheck, SIGNAL(stateChanged(int)),
82
                        this, SLOT(horizontalAutoGapCheck_stateChanged(int)));
83
        connect(verticalAutoGapCheck, SIGNAL(stateChanged(int)),
84
                        this, SLOT(verticalAutoGapCheck_stateChanged(int)));
85
        connect(horizontalAutoGapSpin, SIGNAL(valueChanged(double)),
86
                        this, SLOT(horizontalAutoGapSpin_valueChanged(double)));
87
        connect(verticalAutoGapSpin, SIGNAL(valueChanged(double)),
88
                        this, SLOT(verticalAutoGapSpin_valueChanged(double)));
10224 subik 89
 
90
        connect(horizontalPageAutoButton, SIGNAL(toggled(bool)),
91
                        this, SLOT(horizontalPageAutoButton_toggled(bool)));
92
        connect(horizontalMarginsAutoButton, SIGNAL(toggled(bool)),
93
                        this, SLOT(horizontalMarginsAutoButton_toggled(bool)));
94
        connect(horizontalSelectionAutoButton, SIGNAL(toggled(bool)),
95
                        this, SLOT(horizontalSelectionAutoButton_toggled(bool)));
96
        connect(verticalPageAutoButton, SIGNAL(toggled(bool)),
97
                        this, SLOT(verticalPageAutoButton_toggled(bool)));
98
        connect(verticalMarginsAutoButton, SIGNAL(toggled(bool)),
99
                        this, SLOT(verticalMarginsAutoButton_toggled(bool)));
100
        connect(verticalSelectionAutoButton, SIGNAL(toggled(bool)),
101
                        this, SLOT(verticalSelectionAutoButton_toggled(bool)));
12177 subik 102
 
10205 subik 103
        connect(applyToAllAutoButton, SIGNAL(clicked()),
104
                        this, SLOT(applyToAllAutoButton_clicked()));
105
        connect(deletePageButton, SIGNAL(clicked()),
106
                        this, SLOT(deletePageButton_clicked()));
107
        connect(deleteAllGuides, SIGNAL(clicked()),
108
                        this, SLOT(deleteAllGuides_clicked()));
109
 
11983 subik 110
        connect(lockCheck, SIGNAL(stateChanged(int)),
111
                        this, SLOT(lockCheck_stateChanged(int)));
112
 
10206 subik 113
        connect(horizontalModel, SIGNAL(valueChanged()), this, SLOT(horizontalModel_valueChanged()));
114
        connect(verticalModel, SIGNAL(valueChanged()), this, SLOT(verticalModel_valueChanged()));
5087 subik 115
}
116
 
5781 cbradney 117
void GuideManager::setDoc(ScribusDoc* doc)
118
{
119
        m_Doc=doc;
12177 subik 120
        qobject_cast<GuidesHDelegate*>(horizontalView->itemDelegateForColumn(0))->setDoc(doc);
121
        qobject_cast<GuidesVDelegate*>(verticalView->itemDelegateForColumn(0))->setDoc(doc);
6270 tsoots 122
        if (!m_Doc)
123
                currentPage = 0;
6001 subik 124
        tabWidget->setEnabled(doc ? true : false);
5781 cbradney 125
}
126
 
5087 subik 127
void GuideManager::setupPage()
128
{
5781 cbradney 129
        if (!m_Doc)
130
                return;
6203 subik 131
        m_drawGuides = false;
5087 subik 132
        setEnabled(true);
5996 subik 133
        // store old values for current page (=page to leave)
10685 subik 134
        if (currentPage)
135
                storePageValues(currentPage);
136
 
5781 cbradney 137
        currentPage = m_Doc->currentPage();
5087 subik 138
        unitChange();
9069 subik 139
        setupGui();
140
}
6203 subik 141
 
9069 subik 142
void GuideManager::setupGui()
143
{
10685 subik 144
        disconnect(horizontalAutoGapCheck, SIGNAL(stateChanged(int)),
145
                        this, SLOT(horizontalAutoGapCheck_stateChanged(int)));
146
        disconnect(verticalAutoGapCheck, SIGNAL(stateChanged(int)),
147
                        this, SLOT(verticalAutoGapCheck_stateChanged(int)));
148
 
5909 subik 149
        // restore values from new page
5341 subik 150
        clearRestoreHorizontalList();
151
        clearRestoreVerticalList();
5909 subik 152
        // restore: brand "auto guides into GUI restore algorithm"
153
        bool enable = currentPage->guides.horizontalAutoGap() > 0.0 ? true : false;
154
        horizontalAutoGapCheck->setChecked(enable);
155
        horizontalAutoGapSpin->setEnabled(enable);
5996 subik 156
        horizontalAutoGapSpin->setValue(pts2value(currentPage->guides.horizontalAutoGap(), docUnitIndex));
5909 subik 157
        horizontalAutoCountSpin->setValue(currentPage->guides.horizontalAutoCount());
5972 subik 158
        if (horizontalAutoCountSpin->value()==0)
159
        {
160
                horizontalAutoGapSpin->setEnabled(false);
161
                horizontalAutoGapCheck->setEnabled(false);
162
        }
10224 subik 163
        setHorizontalRefer(currentPage->guides.horizontalAutoRefer());
6747 subik 164
        // allow the selection radio button?
7715 subik 165
        horizontalSelectionAutoButton->setEnabled(!m_Doc->m_Selection->isEmpty());
6212 subik 166
 
5909 subik 167
        // verticals
168
        enable = currentPage->guides.verticalAutoGap() > 0.0 ? true : false;
169
        verticalAutoGapCheck->setChecked(enable);
170
        verticalAutoGapSpin->setEnabled(enable);
5996 subik 171
        verticalAutoGapSpin->setValue(pts2value(currentPage->guides.verticalAutoGap(), docUnitIndex));
5909 subik 172
        verticalAutoCountSpin->setValue(currentPage->guides.verticalAutoCount());
5972 subik 173
        if (verticalAutoCountSpin->value()==0)
174
        {
175
                verticalAutoGapSpin->setEnabled(false);
176
                verticalAutoGapCheck->setEnabled(false);
177
        }
10224 subik 178
        setVerticalRefer(currentPage->guides.verticalAutoRefer());
6203 subik 179
        // allow the selection radio button?
7715 subik 180
        verticalSelectionAutoButton->setEnabled(!m_Doc->m_Selection->isEmpty());
6747 subik 181
 
10685 subik 182
        connect(horizontalAutoGapCheck, SIGNAL(stateChanged(int)),
183
                        this, SLOT(horizontalAutoGapCheck_stateChanged(int)));
184
        connect(verticalAutoGapCheck, SIGNAL(stateChanged(int)),
185
                        this, SLOT(verticalAutoGapCheck_stateChanged(int)));
186
 
6203 subik 187
        m_drawGuides = true;
12820 pierre 188
//      drawGuides(); let Canvas::DrawPageMarks take care of it and avoid a costly ScribusView::DrawNew()
5087 subik 189
}
190
 
5996 subik 191
void GuideManager::storePageValues(Page *page)
5909 subik 192
{
5996 subik 193
        if (!page || !m_Doc)
5909 subik 194
                return;
195
 
196
        double gapValue = 0.0;
197
        if (horizontalAutoGapCheck->isChecked())
5996 subik 198
                gapValue = value2pts(horizontalAutoGapSpin->value(), docUnitIndex);
8856 subik 199
        page->guides.setHorizontalAutoGap(gapValue);
5996 subik 200
        page->guides.setHorizontalAutoCount(horizontalAutoCountSpin->value());
10224 subik 201
        page->guides.setHorizontalAutoRefer(horizontalRefer());
14037 subik 202
        page->guides.addHorizontals(getAutoHorizontals(page), GuideManagerCore::Auto);
5909 subik 203
 
204
        gapValue = 0.0;
205
        if (verticalAutoGapCheck->isChecked())
5996 subik 206
                gapValue = value2pts(verticalAutoGapSpin->value(), docUnitIndex);
8856 subik 207
        page->guides.setVerticalAutoGap(gapValue);
5996 subik 208
        page->guides.setVerticalAutoCount(verticalAutoCountSpin->value());
10224 subik 209
        page->guides.setVerticalAutoRefer(verticalRefer());
14037 subik 210
        page->guides.addVerticals(getAutoVerticals(page), GuideManagerCore::Auto);
5909 subik 211
}
212
 
10903 cbradney 213
void GuideManager::changeEvent(QEvent *e)
214
{
215
        if (e->type() == QEvent::LanguageChange)
216
        {
217
                languageChange();
218
        }
219
        else
220
                QWidget::changeEvent(e);
221
}
222
 
223
void GuideManager::languageChange()
224
{
225
        setWindowTitle( tr("Guide Manager") );
226
        tabWidget->setTabText(0, tr( "&Single") );
227
        tabWidget->setTabText(1, tr( "&Column/Row") );
228
        tabWidget->setTabText(2, tr( "&Misc") );
229
        horizontalGroupBox->setTitle( tr("Horizontals") );
230
        verticalGroupBox->setTitle( tr("Verticals") );
231
        addHorButton->setText( tr("&Add") );
232
        delHorButton->setText( tr("D&elete") );
233
        addVerButton->setText( tr("A&dd") );
234
        delVerButton->setText( tr("De&lete") );
235
        lockCheck->setText( tr("&Lock Guides") );
236
        applyToAllStdButton->setText( tr("Appl&y to All Pages") );
237
        horizontalAutoGroup->setTitle( tr("Horizontals") );
238
        verticalAutoGroup->setTitle( tr("Verticals") );
239
        textLabel1->setText( tr("&Number:") );
240
        textLabel1_2->setText( tr("Nu&mber:") );
241
        horizontalAutoGapCheck->setText( tr("U&se Gap:") );
242
        verticalAutoGapCheck->setText( tr("Use &Gap:") );
13032 cbradney 243
        groupBox->setTitle( tr("Refer to") );
244
        groupBox_2->setTitle( tr("Refer to") );
10903 cbradney 245
        horizontalPageAutoButton->setText( tr("&Page") );
246
        horizontalMarginsAutoButton->setText( tr("M&argins") );
247
        horizontalSelectionAutoButton->setText( tr("S&election") );
248
        verticalPageAutoButton->setText( tr("&Page") );
249
        verticalMarginsAutoButton->setText( tr("M&argins") );
250
        verticalSelectionAutoButton->setText( tr("S&election") );
251
        applyToAllAutoButton->setText( tr("Appl&y to All Pages") );
252
        deletePageButton->setText( tr("Delete Guides from Current &Page") );
253
        deleteAllGuides->setText( tr("Delete Guides from &All Pages") );
12208 cbradney 254
        //tooltips
255
        addHorButton->setToolTip( tr("Add a new horizontal guide") );
256
        delHorButton->setToolTip( tr("Delete the selected horizontal guide") );
257
        addVerButton->setToolTip( tr("Add a new vertical guide") );
258
        delVerButton->setToolTip( tr("Delete the selected vertical guide") );
259
        lockCheck->setToolTip( tr("Lock the guides") );
260
        applyToAllStdButton->setToolTip( tr("Apply to all pages") );
261
        horizontalAutoCountSpin->setToolTip( tr("Number of horizontal guides to create") );
262
        verticalAutoCountSpin->setToolTip( tr("Number of vertical guides to create") );
263
        horizontalAutoGapCheck->setToolTip( tr("Create rows with guides, with an additional gap between the rows") );
264
        verticalAutoGapCheck->setToolTip( tr("Create columns with guides, with an additional gap between the columns") );
265
        horizontalPageAutoButton->setToolTip( tr("Create the selected number of horizontal guides relative to the current page") );
266
        horizontalMarginsAutoButton->setToolTip( tr("Create the selected number of horizontal guides relative to the current page's margins") );
267
        horizontalSelectionAutoButton->setToolTip( tr("Create the selected number of horizontal guides relative to the current selection of items") );
268
        verticalPageAutoButton->setToolTip( tr("Create the selected number of vertical guides relative to the current page") );
269
        verticalMarginsAutoButton->setToolTip( tr("Create the selected number of vertical guides relative to the current page's margins") );
270
        verticalSelectionAutoButton->setToolTip( tr("Create the selected number of vertical guides relative to the current selection of items") );
271
        applyToAllAutoButton->setToolTip( tr("Apply the shown guides to all pages in the document") );
272
        deletePageButton->setToolTip( tr("Delete all guides shown on the current page") );
273
        deleteAllGuides->setToolTip( tr("Delete all guides from all pages") );
10903 cbradney 274
}
275
 
5087 subik 276
void GuideManager::unitChange()
277
{
5781 cbradney 278
        if (!m_Doc)
279
                return;
6219 subik 280
        // a little bit magic to get Verticals (unit) into group boxes
10394 cbradney 281
        horizontalGroupBox->setTitle(horizontalGroupBox->title().remove(" ("+suffix.trimmed()+")"));
282
        verticalGroupBox->setTitle(verticalGroupBox->title().remove(" ("+suffix.trimmed()+")"));
5781 cbradney 283
        docUnitIndex = m_Doc->unitIndex();
10229 subik 284
        int docUnitDecimals = unitGetPrecisionFromIndex(docUnitIndex);
12177 subik 285
 
4185 subik 286
        suffix = unitGetSuffixFromIndex(docUnitIndex);
12807 subik 287
        horizontalAutoGapSpin->setNewUnit(docUnitIndex);
288
        verticalAutoGapSpin->setNewUnit(docUnitIndex);
289
 
10394 cbradney 290
        horizontalGroupBox->setTitle(horizontalGroupBox->title() + " ("+suffix.trimmed()+")");
291
        verticalGroupBox->setTitle(verticalGroupBox->title() + " ("+suffix.trimmed()+")");
10229 subik 292
        // models display
293
        horizontalModel->unitChange(docUnitIndex, docUnitDecimals);
294
        verticalModel->unitChange(docUnitIndex, docUnitDecimals);
12177 subik 295
        qobject_cast<GuidesHDelegate*>(horizontalView->itemDelegateForColumn(0))->setDoc(m_Doc);
296
        qobject_cast<GuidesVDelegate*>(verticalView->itemDelegateForColumn(0))->setDoc(m_Doc);
4185 subik 297
}
2143 subik 298
 
5087 subik 299
void GuideManager::delHorButton_clicked()
4215 subik 300
{
12748 subik 301
        QModelIndexList indexes = horizontalView->selectionModel()->selectedRows(0);
302
        QModelIndex ix;
303
        Guides v;
304
 
305
        foreach(ix, indexes)
12756 subik 306
                // here *must* go EditRole due truncations in DisplayRole
307
                // see GuidesModel::data()
308
                v.append(horizontalModel->data(ix, Qt::EditRole).toDouble());
12748 subik 309
 
310
        horizontalModel->removeValues(v);
311
 
10205 subik 312
        currentPage->guides.clearHorizontals(GuideManagerCore::Standard);
313
        currentPage->guides.addHorizontals(horizontalModel->values(), GuideManagerCore::Standard);
10206 subik 314
        drawGuides();
4215 subik 315
}
316
 
5087 subik 317
void GuideManager::delVerButton_clicked()
4185 subik 318
{
12748 subik 319
        QModelIndexList indexes = verticalView->selectionModel()->selectedRows(0);
320
        QModelIndex ix;
321
        Guides v;
322
 
323
        foreach(ix, indexes)
12756 subik 324
                // here *must* go EditRole due truncations in DisplayRole
325
                // see GuidesModel::data()
326
                v.append(verticalModel->data(ix, Qt::EditRole).toDouble());
12748 subik 327
 
328
        verticalModel->removeValues(v);
329
 
10205 subik 330
        currentPage->guides.clearVerticals(GuideManagerCore::Standard);
331
        currentPage->guides.addVerticals(verticalModel->values(), GuideManagerCore::Standard);
10206 subik 332
        drawGuides();
2143 subik 333
}
2237 subik 334
 
5087 subik 335
void GuideManager::addHorButton_clicked()
4198 subik 336
{
10205 subik 337
        horizontalModel->insertRow();
12965 subik 338
        horizontalView->setCurrentIndex(horizontalModel->index(0, 0, QModelIndex()));
339
        horizontalView->edit(horizontalView->currentIndex());
4198 subik 340
}
341
 
5087 subik 342
void GuideManager::addVerButton_clicked()
3 paul 343
{
10205 subik 344
        verticalModel->insertRow();
12965 subik 345
        verticalView->setCurrentIndex(verticalModel->index(0, 0, QModelIndex()));
346
        verticalView->edit(verticalView->currentIndex());
3 paul 347
}
2143 subik 348
 
5087 subik 349
void GuideManager::lockCheck_stateChanged( int )
4215 subik 350
{
5781 cbradney 351
        m_Doc->lockGuides(lockCheck->isChecked());
5087 subik 352
}
353
 
354
void GuideManager::copyGuidesToAllPages(GuideManagerCore::GuideType t)
355
{
10013 cbradney 356
        QListIterator<Page*> it(*m_Doc->Pages);
5087 subik 357
        Page *tmpPage;
10013 cbradney 358
        while (it.hasNext())
5087 subik 359
        {
10013 cbradney 360
                tmpPage=it.next();
5087 subik 361
                if (tmpPage->pageNr() == currentPage->pageNr())
362
                        continue;
363
                tmpPage->guides.clearHorizontals(t);
364
                tmpPage->guides.clearVerticals(t);
14037 subik 365
                switch (t)
366
                {
367
                        case GuideManagerCore::Standard:
368
                                currentPage->guides.copy(&tmpPage->guides, t);
369
                                break;
370
                        case GuideManagerCore::Auto:
371
                                storePageValues(tmpPage);
372
                                break;
373
                }
5087 subik 374
        }
375
        drawGuides();
376
}
377
 
378
void GuideManager::applyToAllStdButton_clicked()
379
{
380
        copyGuidesToAllPages(GuideManagerCore::Standard);
381
}
382
 
383
void GuideManager::applyToAllAutoButton_clicked()
384
{
385
        copyGuidesToAllPages(GuideManagerCore::Auto);
386
}
387
 
5902 subik 388
void GuideManager::horizontalAutoCountSpin_valueChanged(int val)
5087 subik 389
{
5972 subik 390
        bool enable = (val == 0) ? false : true;
5902 subik 391
        horizontalAutoGapCheck->setEnabled(enable);
392
        if (enable && horizontalAutoGapCheck->isChecked())
393
                horizontalAutoGapSpin->setEnabled(true);
394
        else
395
                horizontalAutoGapSpin->setEnabled(false);
6203 subik 396
        currentPage->guides.setHorizontalAutoCount(val);
397
        drawGuides();
5087 subik 398
}
399
 
8687 cbradney 400
void GuideManager::horizontalAutoGapSpin_valueChanged(double)
5087 subik 401
{
6203 subik 402
        currentPage->guides.setHorizontalAutoGap(value2pts(horizontalAutoGapSpin->value(), docUnitIndex));
403
        drawGuides();
5087 subik 404
}
405
 
406
void GuideManager::horizontalAutoGapCheck_stateChanged( int )
407
{
408
        horizontalAutoGapSpin->setEnabled(horizontalAutoGapCheck->isChecked());
6203 subik 409
        if (horizontalAutoGapCheck->isChecked())
410
                currentPage->guides.setHorizontalAutoGap(value2pts(horizontalAutoGapSpin->value(), docUnitIndex));
411
        else
12807 subik 412
                currentPage->guides.setHorizontalAutoGap(0.0);
6203 subik 413
        drawGuides();
5087 subik 414
}
415
 
5902 subik 416
void GuideManager::verticalAutoCountSpin_valueChanged(int val)
5087 subik 417
{
5972 subik 418
        bool enable = (val == 0) ? false : true;
5902 subik 419
        verticalAutoGapCheck->setEnabled(enable);
420
        if (enable && verticalAutoGapCheck->isChecked())
421
                verticalAutoGapSpin->setEnabled(true);
422
        else
423
                verticalAutoGapSpin->setEnabled(false);
6203 subik 424
        currentPage->guides.setVerticalAutoCount(val);
425
        drawGuides();
5087 subik 426
}
427
 
8687 cbradney 428
void GuideManager::verticalAutoGapSpin_valueChanged(double)
5087 subik 429
{
6203 subik 430
        currentPage->guides.setVerticalAutoGap(value2pts(verticalAutoGapSpin->value(), docUnitIndex));
431
        drawGuides();
5087 subik 432
}
433
 
434
void GuideManager::verticalAutoGapCheck_stateChanged( int )
435
{
436
        verticalAutoGapSpin->setEnabled(verticalAutoGapCheck->isChecked());
6203 subik 437
        if (verticalAutoGapCheck->isChecked())
438
                currentPage->guides.setVerticalAutoGap(value2pts(verticalAutoGapSpin->value(), docUnitIndex));
5078 subik 439
        else
12807 subik 440
                currentPage->guides.setVerticalAutoGap(0.0);
5087 subik 441
        drawGuides();
2143 subik 442
}
443
 
7715 subik 444
void GuideManager::tabWidget_currentChanged(QWidget *)
3 paul 445
{
5087 subik 446
        drawGuides();
10394 cbradney 447
        if (tabWidget->currentIndex() == 1)
5340 subik 448
        {
449
                horizontalAutoGapSpin->setEnabled(horizontalAutoGapCheck->isChecked());
450
                verticalAutoGapSpin->setEnabled(verticalAutoGapCheck->isChecked());
451
        }
3 paul 452
}
2143 subik 453
 
5087 subik 454
Guides GuideManager::selectedHorizontals()
2200 subik 455
{
10206 subik 456
        QModelIndex i;
457
        QModelIndexList selectedIndexes = horizontalView->selectionModel()->selectedIndexes();
458
        Guides ret;
459
        Guides curr = horizontalModel->values();
460
        foreach (i , selectedIndexes)
4185 subik 461
        {
10206 subik 462
                ret.append(curr.at(i.row()));
463
        }
464
        return ret;
4185 subik 465
}
466
 
5087 subik 467
Guides GuideManager::selectedVerticals()
4185 subik 468
{
10206 subik 469
        QModelIndex i;
470
        QModelIndexList selectedIndexes = verticalView->selectionModel()->selectedIndexes();
471
        Guides ret;
472
        Guides curr = verticalModel->values();
473
        foreach (i , selectedIndexes)
474
        {
475
                ret.append(curr.at(i.row()));
476
        }
477
        return ret;
4185 subik 478
}
479
 
12748 subik 480
void GuideManager::forceDrawGuides(const QItemSelection &, const QItemSelection &)
481
{
482
        drawGuides();
483
}
484
 
5087 subik 485
void GuideManager::drawGuides()
4215 subik 486
{
6203 subik 487
        if (!m_Doc || !m_drawGuides)
6000 subik 488
                return;
7713 subik 489
 
14037 subik 490
        currentPage->guides.addHorizontals(getAutoHorizontals(currentPage), GuideManagerCore::Auto);
491
        currentPage->guides.addVerticals(getAutoVerticals(currentPage), GuideManagerCore::Auto);
5781 cbradney 492
        ScCore->primaryMainWindow()->view->DrawNew();
4215 subik 493
}
5339 subik 494
 
495
void GuideManager::clearRestoreHorizontalList()
496
{
10205 subik 497
        horizontalModel->setValues(currentPage->guides.horizontals(GuideManagerCore::Standard));
10206 subik 498
        drawGuides();
5339 subik 499
}
500
 
501
void GuideManager::clearRestoreVerticalList()
502
{
10205 subik 503
        verticalModel->setValues(currentPage->guides.verticals(GuideManagerCore::Standard));
10206 subik 504
        drawGuides();
5339 subik 505
}
6212 subik 506
 
507
void GuideManager::deletePageButton_clicked()
508
{
11576 avox 509
        UndoTransaction trans(UndoManager::instance()->beginTransaction(currentPage->getUName(),
510
                                                                                                                                currentPage->getUPixmap(),
511
                                                                                                                                Um::RemoveAllPageGuides, "",
512
                                                                                                                                Um::IGuides));
6212 subik 513
        currentPage->guides.clearHorizontals(GuideManagerCore::Standard);
514
        currentPage->guides.clearVerticals(GuideManagerCore::Standard);
7713 subik 515
        currentPage->guides.clearHorizontals(GuideManagerCore::Auto);
516
        currentPage->guides.clearVerticals(GuideManagerCore::Auto);
6219 subik 517
        clearRestoreHorizontalList();
518
        clearRestoreVerticalList();
519
 
6212 subik 520
        currentPage->guides.setHorizontalAutoCount(0);
521
        currentPage->guides.setVerticalAutoCount(0);
522
        currentPage->guides.setHorizontalAutoGap(0.0);
523
        currentPage->guides.setVerticalAutoGap(0.0);
6747 subik 524
        currentPage->guides.setHorizontalAutoRefer(0);
525
        currentPage->guides.setVerticalAutoRefer(0);
6212 subik 526
        horizontalAutoCountSpin->setValue(0);
527
        verticalAutoCountSpin->setValue(0);
11576 avox 528
        trans.commit();
6219 subik 529
 
6212 subik 530
        drawGuides();
531
}
532
 
533
void GuideManager::deleteAllGuides_clicked()
534
{
11576 avox 535
        UndoTransaction trans(UndoManager::instance()->beginTransaction(m_Doc->getUName(),
536
                                                                                                                                m_Doc->getUPixmap(),
537
                                                                                                                                Um::RemoveAllGuides, "",
538
                                                                                                                                Um::IGuides));
6212 subik 539
        m_drawGuides = false;
540
        deletePageButton_clicked();
541
        copyGuidesToAllPages(GuideManagerCore::Standard);
542
        copyGuidesToAllPages(GuideManagerCore::Auto);
543
        m_drawGuides = true;
11576 avox 544
        trans.commit();
6212 subik 545
        drawGuides();
546
}
7710 subik 547
 
548
void GuideManager::windowActivationChange(bool oldActive)
549
{
7713 subik 550
        if (m_Doc)
551
        {
552
                bool enable = !m_Doc->m_Selection->isEmpty();
553
                horizontalSelectionAutoButton->setEnabled(enable);
554
                verticalSelectionAutoButton->setEnabled(enable);
555
        }
7710 subik 556
        QDialog::windowActivationChange( oldActive );
557
}
7713 subik 558
 
14733 jghali 559
Guides GuideManager::getAutoVerticals(Page * page)
7713 subik 560
{
14733 jghali 561
        GuideManagerCore guides;
7713 subik 562
 
14733 jghali 563
        double gapValue = 0.0;
564
        if (horizontalAutoGapCheck->isChecked())
565
                gapValue = value2pts(horizontalAutoGapSpin->value(), docUnitIndex);
566
        guides.setHorizontalAutoGap(gapValue);
567
        guides.setHorizontalAutoCount(horizontalAutoCountSpin->value());
568
        guides.setHorizontalAutoRefer(horizontalRefer());
7713 subik 569
 
14733 jghali 570
        gapValue = 0.0;
571
        if (verticalAutoGapCheck->isChecked())
572
                gapValue = value2pts(verticalAutoGapSpin->value(), docUnitIndex);
573
        guides.setVerticalAutoGap(gapValue);
574
        guides.setVerticalAutoCount(verticalAutoCountSpin->value());
575
        guides.setVerticalAutoRefer(verticalRefer());
7713 subik 576
 
14733 jghali 577
        return guides.getAutoVerticals(page);
7713 subik 578
}
579
 
14733 jghali 580
Guides GuideManager::getAutoHorizontals(Page * page)
7713 subik 581
{
14733 jghali 582
        GuideManagerCore guides;
7713 subik 583
 
14733 jghali 584
        double gapValue = 0.0;
585
        if (horizontalAutoGapCheck->isChecked())
586
                gapValue = value2pts(horizontalAutoGapSpin->value(), docUnitIndex);
587
        guides.setHorizontalAutoGap(gapValue);
588
        guides.setHorizontalAutoCount(horizontalAutoCountSpin->value());
589
        guides.setHorizontalAutoRefer(horizontalRefer());
7713 subik 590
 
14733 jghali 591
        gapValue = 0.0;
592
        if (verticalAutoGapCheck->isChecked())
593
                gapValue = value2pts(verticalAutoGapSpin->value(), docUnitIndex);
594
        guides.setVerticalAutoGap(gapValue);
595
        guides.setVerticalAutoCount(verticalAutoCountSpin->value());
596
        guides.setVerticalAutoRefer(verticalRefer());
7713 subik 597
 
14733 jghali 598
        return guides.getAutoHorizontals(page);
7713 subik 599
}
600
 
7715 subik 601
void GuideManager::resetSelectionForPage()
7713 subik 602
{
603
        int docSelectionCount = currentPage->doc()->m_Selection->count();
604
 
7715 subik 605
        currentPage->guides.gx = currentPage->guides.gy = currentPage->guides.gw = currentPage->guides.gh = 0.0;
7713 subik 606
 
607
        // multiselection
608
        if (docSelectionCount > 1)
609
        {
610
                double x, y;
7715 subik 611
                m_Doc->m_Selection->getGroupRect(&x, &y, &currentPage->guides.gw, &currentPage->guides.gh);
612
                currentPage->guides.gx = x - currentPage->xOffset();
613
                currentPage->guides.gy = y - currentPage->yOffset();
7713 subik 614
        }
615
        // only one item selected
616
        else if (docSelectionCount == 1)
617
        {
618
                PageItem *currItem = m_Doc->m_Selection->itemAt(0);
7715 subik 619
                currentPage->guides.gx = currItem->xPos() - currentPage->xOffset();
620
                currentPage->guides.gy = currItem->yPos() - currentPage->yOffset();
621
                currentPage->guides.gw = currItem->width();
622
                currentPage->guides.gh = currItem->height();
7713 subik 623
        }
624
}
10206 subik 625
 
626
void GuideManager::verticalModel_valueChanged()
627
{
628
        currentPage->guides.clearVerticals(GuideManagerCore::Standard);
629
        currentPage->guides.addVerticals(verticalModel->values(), GuideManagerCore::Standard);
630
        drawGuides();
631
}
632
 
633
void GuideManager::horizontalModel_valueChanged()
634
{
635
        currentPage->guides.clearHorizontals(GuideManagerCore::Standard);
636
        currentPage->guides.addHorizontals(horizontalModel->values(), GuideManagerCore::Standard);
637
        drawGuides();
638
}
10224 subik 639
 
640
void GuideManager::setHorizontalRefer(int button)
641
{
642
        switch (button)
643
        {
644
                case 0 :
645
                        horizontalPageAutoButton->setChecked(true);
646
                        break;
647
                case 1 :
648
                        horizontalMarginsAutoButton->setChecked(true);
649
                        break;
650
                case 2 :
651
                        horizontalSelectionAutoButton->setChecked(true);
652
        }
653
}
654
 
655
int GuideManager::horizontalRefer()
656
{
657
        if (horizontalPageAutoButton->isChecked())
658
                return 0;
659
        if (horizontalMarginsAutoButton->isChecked())
660
                return 1;
661
        if (horizontalSelectionAutoButton->isChecked())
662
                return 2;
663
        return 0;
664
}
665
 
666
void GuideManager::setVerticalRefer(int button)
667
{
668
        switch (button)
669
        {
670
                case 0 :
671
                        verticalPageAutoButton->setChecked(true);
672
                        break;
673
                case 1 :
674
                        verticalMarginsAutoButton->setChecked(true);
675
                        break;
676
                case 2 :
677
                        verticalSelectionAutoButton->setChecked(true);
678
        }
679
}
680
 
681
int GuideManager::verticalRefer()
682
{
683
        if (verticalPageAutoButton->isChecked())
684
                return 0;
685
        if (verticalMarginsAutoButton->isChecked())
686
                return 1;
687
        if (verticalSelectionAutoButton->isChecked())
688
                return 2;
689
        return 0;
690
}
691
 
692
void GuideManager::horizontalPageAutoButton_toggled(bool state)
693
{
694
        if (!state)
695
                return;
696
        currentPage->guides.setHorizontalAutoRefer(0);
697
        drawGuides();
698
}
699
 
700
void GuideManager::horizontalMarginsAutoButton_toggled(bool state)
701
{
702
        if (!state)
703
                return;
704
        currentPage->guides.setHorizontalAutoRefer(1);
705
        drawGuides();
706
}
707
 
708
void GuideManager::horizontalSelectionAutoButton_toggled(bool state)
709
{
710
        if (!state)
711
                return;
712
        currentPage->guides.setHorizontalAutoRefer(2);
713
        if (horizontalSelectionAutoButton->isEnabled())
714
                resetSelectionForPage();
715
        drawGuides();
716
}
717
 
718
void GuideManager::verticalPageAutoButton_toggled(bool state)
719
{
720
        if (!state)
721
                return;
722
        currentPage->guides.setVerticalAutoRefer(0);
723
        drawGuides();
724
}
725
 
726
void GuideManager::verticalMarginsAutoButton_toggled(bool state)
727
{
728
        if (!state)
729
                return;
730
        currentPage->guides.setVerticalAutoRefer(1);
731
        drawGuides();
732
}
733
 
734
void GuideManager::verticalSelectionAutoButton_toggled(bool state)
735
{
736
        if (!state)
737
                return;
738
        currentPage->guides.setVerticalAutoRefer(2);
739
        if (verticalSelectionAutoButton->isEnabled())
740
                resetSelectionForPage();
741
        drawGuides();
742
}