Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
5088 subik 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
10223 cbradney 8
#include <QPen>
9
#include <QTabWidget>
5088 subik 10
#include "guidemanagercore.h"
11
#include "scpainter.h"
12
#include "page.h"
13
#include "fpoint.h"
14
#include "undomanager.h"
15
#include "undostate.h"
16
#include "guidemanager.h"
13464 cbradney 17
#include "scclocale.h"
5781 cbradney 18
#include "scribuscore.h"
6203 subik 19
#include "pagestructs.h"
20
#include "selection.h"
5088 subik 21
 
22
 
5104 subik 23
GuideManagerCore::GuideManagerCore():
6747 subik 24
        undoManager(UndoManager::instance()),
25
        m_page(0),
14732 jghali 26
        gx(0), gy(0), gw(0), gh(0),
6747 subik 27
        m_horizontalAutoGap(0.0),
28
        m_verticalAutoGap(0.0),
29
        m_horizontalAutoCount(0),
30
        m_verticalAutoCount(0),
31
        m_horizontalAutoRefer(0),
32
        m_verticalAutoRefer(0)
5104 subik 33
{
9087 avox 34
        verticalStdG.clear();
35
        verticalAutoG.clear();
36
        horizontalStdG.clear();
37
        horizontalAutoG.clear();
5104 subik 38
}
39
 
5088 subik 40
GuideManagerCore::GuideManagerCore(Page *parentPage):
6747 subik 41
        undoManager(UndoManager::instance()),
42
        m_page(parentPage),
43
        m_horizontalAutoGap(0.0),
44
        m_verticalAutoGap(0.0),
45
        m_horizontalAutoCount(0),
46
        m_verticalAutoCount(0),
47
        m_horizontalAutoRefer(0),
48
        m_verticalAutoRefer(0)
5088 subik 49
{
9087 avox 50
        verticalStdG.clear();
51
        verticalAutoG.clear();
52
        horizontalStdG.clear();
53
        horizontalAutoG.clear();
5088 subik 54
}
55
 
56
GuideManagerCore::~GuideManagerCore()
57
{
58
}
59
 
5104 subik 60
void GuideManagerCore::setPage(Page *p)
61
{
5199 subik 62
        m_page = p;
5104 subik 63
}
64
 
5088 subik 65
void GuideManagerCore::addHorizontal(double value, GuideType type)
66
{
67
        switch (type)
68
        {
69
                case Standard:
7514 fschmid 70
                        if (!horizontalStdG.contains(value))
5088 subik 71
                        {
7514 fschmid 72
                                horizontalStdG.append(value);
73
                                if (UndoManager::undoEnabled())
74
                                {
75
                                        SimpleState* ss = new SimpleState(Um::AddVGuide, 0, Um::IGuides);
76
                                        ss->set("ADD_H", value);
77
                                        undoManager->action(m_page, ss);
78
                                }
5088 subik 79
                        }
80
                        break;
81
                case Auto:
82
                        break;
83
        }
84
}
85
 
86
void GuideManagerCore::addHorizontals(Guides values, GuideType type)
87
{
7514 fschmid 88
        Guides::iterator it;
5088 subik 89
        switch (type)
90
        {
91
                case Standard:
7514 fschmid 92
                        for (it = values.begin(); it != values.end(); ++it)
93
                        {
94
                                if (!horizontalStdG.contains((*it)))
95
                                        horizontalStdG.append((*it));
96
                        }
5088 subik 97
                        break;
98
                case Auto:
7713 subik 99
                        horizontalAutoG.clear();
100
                        for (it = values.begin(); it != values.end(); ++it)
101
                                horizontalAutoG.append((*it));
5088 subik 102
                        break;
103
        }
104
}
105
 
106
void GuideManagerCore::addVertical(double value, GuideType type)
107
{
108
        switch (type)
109
        {
110
                case Standard:
7514 fschmid 111
                        if (!verticalStdG.contains(value))
5088 subik 112
                        {
7514 fschmid 113
                                verticalStdG.append(value);
114
                                if (UndoManager::undoEnabled())
115
                                {
116
                                        SimpleState* ss = new SimpleState(Um::AddVGuide, 0, Um::IGuides);
117
                                        ss->set("ADD_V", value);
118
                                        undoManager->action(m_page, ss);
119
                                }
5088 subik 120
                        }
121
                        break;
122
                case Auto:
123
                        break;
124
        }
125
}
126
 
127
void GuideManagerCore::addVerticals(Guides values, GuideType type)
128
{
7514 fschmid 129
        Guides::iterator it;
5088 subik 130
        switch (type)
131
        {
132
                case Standard:
7514 fschmid 133
                        for (it = values.begin(); it != values.end(); ++it)
134
                        {
135
                                if (!verticalStdG.contains((*it)))
136
                                        verticalStdG.append((*it));
137
                        }
5088 subik 138
                        break;
139
                case Auto:
7713 subik 140
                        verticalAutoG.clear();
141
                        for (it = values.begin(); it != values.end(); ++it)
142
                                verticalAutoG.append((*it));
5088 subik 143
                        break;
144
        }
145
}
146
 
147
void GuideManagerCore::deleteHorizontal(double value, GuideType type)
148
{
149
        switch (type)
150
        {
151
                case Standard:
10500 cbradney 152
                        horizontalStdG.removeAt(horizontalStdG.indexOf(value));
5088 subik 153
                        if (UndoManager::undoEnabled())
154
                        {
155
                                SimpleState* ss = new SimpleState(Um::DelVGuide, 0, Um::IGuides);
156
                                ss->set("REMOVE_H", value);
5199 subik 157
                                undoManager->action(m_page, ss);
5088 subik 158
                        }
159
                        break;
160
                case Auto:
161
                        break;
162
        }
163
}
164
 
165
void GuideManagerCore::deleteVertical(double value, GuideType type)
166
{
167
        switch (type)
168
        {
169
                case Standard:
10500 cbradney 170
                        verticalStdG.removeAt(verticalStdG.indexOf(value));
5088 subik 171
                        if (UndoManager::undoEnabled())
172
                        {
173
                                SimpleState* ss = new SimpleState(Um::DelVGuide, 0, Um::IGuides);
174
                                ss->set("REMOVE_V", value);
5199 subik 175
                                undoManager->action(m_page, ss);
5088 subik 176
                        }
177
                        break;
178
                case Auto:
179
                        break;
180
        }
181
}
182
 
183
Guides GuideManagerCore::horizontals(GuideType type)
184
{
185
        switch (type)
186
        {
187
                case Standard:
188
                        return horizontalStdG;
189
                        break;
190
                case Auto:
7713 subik 191
                        return horizontalAutoG;
5088 subik 192
                        break;
193
        }
194
        // just to prevent the compiler warnings
195
        return horizontalStdG;
196
}
197
 
198
Guides GuideManagerCore::verticals(GuideType type)
199
{
200
        switch (type)
201
        {
202
                case Standard:
203
                        return verticalStdG;
204
                        break;
205
                case Auto:
7713 subik 206
                        return verticalAutoG;
5088 subik 207
                        break;
208
        }
209
        return verticalStdG;
210
}
211
 
212
double GuideManagerCore::horizontal(uint ix, GuideType type)
213
{
214
        switch (type)
215
        {
216
                case Standard:
217
                        return horizontalStdG[ix];
218
                        break;
219
                case Auto:
220
                        break;
221
        }
222
        return -1.0; // just for compiler warning
223
}
224
 
225
double GuideManagerCore::vertical(uint ix, GuideType type)
226
{
227
        switch (type)
228
        {
229
                case Standard:
230
                        return verticalStdG[ix];
231
                        break;
232
                case Auto:
233
                        break;
234
        }
235
        return -1.0; // just for compiler warning
236
}
237
 
14732 jghali 238
Guides GuideManagerCore::getAutoHorizontals(Page* page)
239
{
240
        Guides guides;
241
        double rowSize;
242
        int value = m_horizontalAutoCount;
243
        double offset = 0.0;
244
        double newPageHeight = page->height();
245
 
246
        if (page == NULL)
247
                page = m_page;
248
        if (page == NULL)
249
                return guides;
250
 
251
        if (m_horizontalAutoCount == 0)
252
                return guides;
253
        ++value;
254
 
255
        if (m_horizontalAutoRefer == 1)
256
        {
257
                newPageHeight = newPageHeight - page->Margins.Top - page->Margins.Bottom;
258
                offset = page->Margins.Top;
259
        }
260
        else if (m_horizontalAutoRefer == 2)
261
        {
262
                if (qRound(page->guides.gy) != 0.0)
263
                {
264
                        offset = page->guides.gy;
265
                        newPageHeight = page->guides.gh;
266
                }
267
        }
268
 
269
        if (page->guides.horizontalAutoGap() > 0.0)
270
                rowSize = (newPageHeight - (value - 1) * page->guides.horizontalAutoGap()) / value;
271
        else
272
                rowSize = newPageHeight / value;
273
 
274
        for (int i = 1, gapCount = 0; i < value; ++i)
275
        {
276
                if (page->guides.horizontalAutoGap() > 0.0)
277
                {
278
                        guides.append(offset + i * rowSize + gapCount * page->guides.horizontalAutoGap());
279
                        ++gapCount;
280
                        guides.append(offset + i * rowSize + gapCount * page->guides.horizontalAutoGap());
281
                }
282
                else
283
                        guides.append(offset + rowSize * i);
284
        }
285
        return guides;
286
}
287
 
288
Guides GuideManagerCore::getAutoVerticals(Page* page)
289
{
290
        Guides guides;
291
        double columnSize;
292
        int value = m_verticalAutoCount;
293
        double offset = 0.0;
294
        double newPageWidth = page->width();
295
 
296
        if (page == NULL)
297
                page = m_page;
298
        if (page == NULL)
299
                return guides;
300
 
301
        if (m_verticalAutoCount == 0)
302
                return guides;
303
        ++value;
304
 
305
        if (m_horizontalAutoRefer == 1)
306
        {
307
                newPageWidth = newPageWidth - page->Margins.Left - page->Margins.Right;
308
                offset = page->Margins.Left;
309
        }
310
        else if (m_horizontalAutoRefer == 2)
311
        {
312
                if (qRound(page->guides.gx) != 0)
313
                {
314
                        offset = page->guides.gx;
315
                        newPageWidth = page->guides.gw;
316
                }
317
        }
318
 
319
        if (page->guides.verticalAutoGap() > 0.0)
320
                columnSize = (newPageWidth - (value - 1) * page->guides.verticalAutoGap()) / value;
321
        else
322
                columnSize = newPageWidth / value;
323
 
324
        for (int i = 1, gapCount = 0; i < value; ++i)
325
        {
326
                if (page->guides.verticalAutoGap() > 0.0)
327
                {
328
                        guides.append(offset + i * columnSize + gapCount * page->guides.verticalAutoGap());
329
                        ++gapCount;
330
                        guides.append(offset + i * columnSize + gapCount * page->guides.verticalAutoGap());
331
                }
332
                else
333
                        guides.append(offset + columnSize * i);
334
        }
335
        return guides;
336
}
337
 
5088 subik 338
void GuideManagerCore::clearHorizontals(GuideType type)
339
{
340
        switch (type)
341
        {
342
                case Standard:
7896 tsoots 343
                        if (undoManager->undoEnabled())
344
                        {
8547 cbradney 345
                                for (int i = 0; i < horizontalStdG.count(); ++i)
7896 tsoots 346
                                {
347
                                        SimpleState* ss = new SimpleState(Um::DelVGuide, 0, Um::IGuides);
348
                                        ss->set("REMOVE_H", horizontalStdG[i]);
349
                                        undoManager->action(m_page, ss);
350
                                }
351
                        }
5088 subik 352
                        horizontalStdG.clear();
353
                        break;
354
                case Auto:
9069 subik 355
                        if (undoManager->undoEnabled())
356
                        {
357
                                SimpleState * ss = new SimpleState(Um::DelHAGuide, 0, Um::IGuides);
358
                                ss->set("REMOVE_HA_GAP", m_horizontalAutoGap);
359
                                ss->set("REMOVE_HA_COUNT", m_horizontalAutoCount);
360
                                ss->set("REMOVE_HA_REFER", m_horizontalAutoRefer);
361
                                undoManager->action(m_page, ss);
362
                        }
363
 
6212 subik 364
                        m_horizontalAutoGap = 0.0;
365
                        m_horizontalAutoCount= 0;
6747 subik 366
                        m_horizontalAutoRefer = 0;
7713 subik 367
                        horizontalAutoG.clear();
5088 subik 368
                        break;
369
        }
370
}
371
 
372
void GuideManagerCore::clearVerticals(GuideType type)
373
{
374
        switch (type)
375
        {
376
                case Standard:
7896 tsoots 377
                        if (undoManager->undoEnabled())
378
                        {
8547 cbradney 379
                                for (int i = 0; i < verticalStdG.count(); ++i)
7896 tsoots 380
                                {
381
                                        SimpleState* ss = new SimpleState(Um::DelVGuide, 0, Um::IGuides);
382
                                        ss->set("REMOVE_V", verticalStdG[i]);
383
                                        undoManager->action(m_page, ss);
384
                                }
385
                        }
5088 subik 386
                        verticalStdG.clear();
387
                        break;
388
                case Auto:
9069 subik 389
                        if (undoManager->undoEnabled())
390
                        {
391
                                SimpleState * ss = new SimpleState(Um::DelVAGuide, 0, Um::IGuides);
392
                                ss->set("REMOVE_VA_GAP", m_verticalAutoGap);
393
                                ss->set("REMOVE_VA_COUNT", m_verticalAutoCount);
394
                                ss->set("REMOVE_VA_REFER", m_verticalAutoRefer);
395
                                undoManager->action(m_page, ss);
396
                        }
397
 
6212 subik 398
                        m_verticalAutoGap = 0.0;
399
                        m_verticalAutoCount = 0;
6747 subik 400
                        m_verticalAutoRefer = 0;
7713 subik 401
                        verticalAutoG.clear();
5088 subik 402
                        break;
403
        }
404
}
405
void GuideManagerCore::moveHorizontal(double from, double to, GuideType type)
406
{
407
        switch (type)
408
        {
409
                case Standard:
10500 cbradney 410
                        horizontalStdG.removeAt(horizontalStdG.indexOf(from));
5088 subik 411
                        horizontalStdG.append(to);
412
                        if (UndoManager::undoEnabled())
413
                        {
414
                                SimpleState* ss = new SimpleState(Um::MoveVGuide, 0, Um::IGuides);
415
                                ss->set("MOVE_H_FROM", from);
416
                                ss->set("MOVE_H_TO", to);
5199 subik 417
                                undoManager->action(m_page, ss);
5088 subik 418
                        }
419
                        break;
420
                case Auto:
421
                        break;
422
        }
423
}
424
 
425
void GuideManagerCore::moveVertical(double from, double to, GuideType type)
426
{
427
        switch (type)
428
        {
429
                case Standard:
10500 cbradney 430
                        verticalStdG.removeAt(verticalStdG.indexOf(from));
5088 subik 431
                        verticalStdG.append(to);
432
                        if (UndoManager::undoEnabled())
433
                        {
434
                                SimpleState* ss = new SimpleState(Um::MoveVGuide, 0, Um::IGuides);
435
                                ss->set("MOVE_V_FROM", from);
436
                                ss->set("MOVE_V_TO", to);
5199 subik 437
                                undoManager->action(m_page, ss);
5088 subik 438
                        }
439
                        break;
440
                case Auto:
441
                        break;
442
        }
443
}
444
 
445
void GuideManagerCore::copy(GuideManagerCore *target)
446
{
7715 subik 447
        copy(target, Standard);
448
        copy(target, Auto);
5088 subik 449
}
450
 
451
void GuideManagerCore::copy(GuideManagerCore *target, GuideType type)
452
{
453
        switch (type)
454
        {
455
                case Standard:
456
                        target->addHorizontals(horizontalStdG, Standard);
457
                        target->addVerticals(verticalStdG, Standard);
458
                        break;
459
                case Auto:
6203 subik 460
                        target->setHorizontalAutoCount(m_horizontalAutoCount);
461
                        target->setVerticalAutoCount(m_verticalAutoCount);
462
                        target->setHorizontalAutoGap(m_horizontalAutoGap);
463
                        target->setVerticalAutoGap(m_verticalAutoGap);
6747 subik 464
                        target->setHorizontalAutoRefer(m_horizontalAutoRefer);
465
                        target->setVerticalAutoRefer(m_verticalAutoRefer);
7931 subik 466
                        target->addHorizontals(horizontalAutoG, Auto);
467
                        target->addVerticals(verticalAutoG, Auto);
7715 subik 468
                        target->gx = gx;
469
                        target->gy = gy;
470
                        target->gw = gw;
471
                        target->gh = gh;
5088 subik 472
                        break;
473
        }
474
}
475
 
476
void GuideManagerCore::drawPage(ScPainter *p, ScribusDoc *doc, double lineWidth)
477
{
478
        Guides::iterator it;
479
        QColor color(doc->guidesSettings.guideColor);
480
 
9855 jghali 481
        if (!m_page || ScCore->primaryMainWindow()->guidePalette->pageNr() < 0)
482
                return;
483
 
13073 subik 484
        // real painting margins including bleeds
485
        double verticalFrom = 0.0 - doc->bleeds.Top;
486
        double verticalTo = m_page->height() + doc->bleeds.Bottom;
487
        double horizontalFrom = 0.0 - doc->bleeds.Left;
488
        double horizontalTo = m_page->width() + doc->bleeds.Right;
489
 
5088 subik 490
        // all standard
491
        p->setPen(color, lineWidth, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin);
492
        for (it = verticalStdG.begin(); it != verticalStdG.end(); ++it)
13073 subik 493
//              if ((*it) >= 0 && (*it) <= m_page->width())
494
//                      p->drawLine(FPoint((*it), 0), FPoint((*it), m_page->height()));
495
                p->drawLine(FPoint((*it), verticalFrom), FPoint((*it), verticalTo));
5088 subik 496
        for (it = horizontalStdG.begin(); it != horizontalStdG.end(); ++it)
13073 subik 497
//              if ((*it) >= 0 && (*it) <= m_page->height())
498
//                      p->drawLine(FPoint(0, (*it)), FPoint(m_page->width(), (*it)));
499
                p->drawLine(FPoint(horizontalFrom, (*it)), FPoint(horizontalTo, (*it)));
5088 subik 500
        // highlight selected standards
10394 cbradney 501
        if (ScCore->primaryMainWindow()->guidePalette->currentIndex() == 0
5781 cbradney 502
                   && m_page->pageNr() == ScCore->primaryMainWindow()->guidePalette->pageNr())
5088 subik 503
        {
504
                p->setPen(Qt::red, lineWidth, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin);
5781 cbradney 505
                Guides highlight = ScCore->primaryMainWindow()->guidePalette->selectedVerticals();
5088 subik 506
                for (it = highlight.begin(); it != highlight.end(); ++it)
13073 subik 507
//                      if ((*it) >= 0 && (*it) <= m_page->width())
508
//                              p->drawLine(FPoint((*it), 0), FPoint((*it), m_page->height()));
509
                        p->drawLine(FPoint((*it), verticalFrom), FPoint((*it), verticalTo));
5781 cbradney 510
                highlight = ScCore->primaryMainWindow()->guidePalette->selectedHorizontals();
5088 subik 511
                for (it = highlight.begin(); it != highlight.end(); ++it)
13073 subik 512
//                      if ((*it) >= 0 && (*it) <= m_page->height())
513
//                              p->drawLine(FPoint(0, (*it)), FPoint(m_page->width(), (*it)));
514
                        p->drawLine(FPoint(horizontalFrom, (*it)), FPoint(horizontalTo, (*it)));
5088 subik 515
        }
516
        // all auto
10394 cbradney 517
        if (ScCore->primaryMainWindow()->guidePalette->currentIndex() == 1)
5088 subik 518
                color = Qt::red;
519
        else
520
                color = doc->guidesSettings.guideColor;
521
        p->setPen(color, lineWidth, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin);
7713 subik 522
 
5088 subik 523
        for (it = verticalAutoG.begin(); it != verticalAutoG.end(); ++it)
13073 subik 524
//              if ((*it) >= 0 && (*it) <= m_page->width())
525
//                      p->drawLine(FPoint((*it), 0), FPoint((*it), m_page->height()));
526
                p->drawLine(FPoint((*it), verticalFrom), FPoint((*it), verticalTo));
5088 subik 527
        for (it = horizontalAutoG.begin(); it != horizontalAutoG.end(); ++it)
13073 subik 528
//              if ((*it) >= 0 && (*it) <= m_page->height())
529
//                      p->drawLine(FPoint(0, (*it)), FPoint(m_page->width(), (*it)));
530
                p->drawLine(FPoint(horizontalFrom, (*it)), FPoint(horizontalTo, (*it)));
5088 subik 531
}
532
 
11190 avox 533
int GuideManagerCore::isMouseOnHorizontal(double low, double high, GuideType type)
5088 subik 534
{
535
        Guides tmp;
536
        Guides::iterator it;
537
 
538
        switch (type)
539
        {
540
                case Standard:
541
                        tmp = horizontalStdG;
542
                        break;
543
                case Auto:
7713 subik 544
                        tmp = horizontalAutoG;
5088 subik 545
                        break;
546
        }
547
        for (it = tmp.begin(); it != tmp.end(); ++it)
548
        {
5199 subik 549
                double guideOffset = (*it) + m_page->yOffset();
5088 subik 550
                if (guideOffset < low && guideOffset > high)
11190 avox 551
                        return it - tmp.begin();
5088 subik 552
        }
11190 avox 553
        return -1;
5088 subik 554
}
555
 
11190 avox 556
int GuideManagerCore::isMouseOnVertical(double low, double high, GuideType type)
5088 subik 557
{
558
        Guides tmp;
559
        Guides::iterator it;
560
 
561
        switch (type)
562
        {
563
                case Standard:
564
                        tmp = verticalStdG;
565
                        break;
566
                case Auto:
7713 subik 567
                        tmp = horizontalAutoG;
5088 subik 568
                        break;
569
        }
570
        for (it = tmp.begin(); it != tmp.end(); ++it)
571
        {
5199 subik 572
                double guideOffset = (*it) + m_page->xOffset();
5088 subik 573
                if (guideOffset < low && guideOffset > high)
11190 avox 574
                        return it - tmp.begin();
5088 subik 575
        }
11190 avox 576
        return -1;
5088 subik 577
}
5164 tsoots 578
 
6203 subik 579
QPair<double, double> GuideManagerCore::topLeft(double x, double y)// const
5164 tsoots 580
{
581
        return QPair<double, double>(closestVertLeft(x), closestHorAbove(y));
582
}
583
 
6203 subik 584
QPair<double, double> GuideManagerCore::topRight(double x, double y)// const
5164 tsoots 585
{
586
        return QPair<double, double>(closestVertRight(x), closestHorAbove(y));
587
}
588
 
6203 subik 589
QPair<double, double> GuideManagerCore::bottomLeft(double x, double y)// const
5164 tsoots 590
{
591
        return QPair<double, double>(closestVertLeft(x), closestHorBelow(y));
592
}
593
 
6203 subik 594
QPair<double, double> GuideManagerCore::bottomRight(double x, double y)// const
5164 tsoots 595
{
596
        return QPair<double, double>(closestVertRight(x), closestHorBelow(y));
597
}
598
 
6203 subik 599
double GuideManagerCore::closestHorAbove(double y)// const
5164 tsoots 600
{
601
        double closest = 0.0;
8547 cbradney 602
        for (int i = 0; i < horizontalStdG.size(); ++i)
5164 tsoots 603
        {
604
                if (horizontalStdG[i] < y && horizontalStdG[i] > closest)
605
                        closest = horizontalStdG[i];
606
        }
607
 
8547 cbradney 608
        for (int i = 0; i < horizontalAutoG.size(); ++i)
5167 tsoots 609
        {
610
                if (horizontalAutoG[i] < y && horizontalAutoG[i] > closest)
611
                        closest = horizontalAutoG[i];
612
        }
7572 fschmid 613
 
8504 cbradney 614
        if (m_page->Margins.Top < y && m_page->Margins.Top > closest)
5199 subik 615
                closest = m_page->Margins.Top;
8547 cbradney 616
        if (m_page->height() - m_page->Margins.Bottom < y && m_page->height() - m_page->Margins.Bottom > closest)
5199 subik 617
                closest = m_page->height() - m_page->Margins.Bottom;
7572 fschmid 618
 
5164 tsoots 619
        return closest;
620
}
621
 
6203 subik 622
double GuideManagerCore::closestHorBelow(double y)// const
5164 tsoots 623
{
5199 subik 624
        double closest = m_page->height();
8547 cbradney 625
        for (int i = 0; i < horizontalStdG.size(); ++i)
5164 tsoots 626
        {
627
                if (horizontalStdG[i] > y && horizontalStdG[i] < closest)
628
                        closest = horizontalStdG[i];
629
        }
630
 
8547 cbradney 631
        for (int i = 0; i < horizontalAutoG.size(); ++i)
5167 tsoots 632
        {
633
                if (horizontalAutoG[i] > y && horizontalAutoG[i] < closest)
634
                        closest = horizontalAutoG[i];
635
        }
7572 fschmid 636
 
5199 subik 637
        if (m_page->Margins.Top > y && m_page->Margins.Top < closest)
638
                closest = m_page->Margins.Top;
639
        if (m_page->height() - m_page->Margins.Bottom > y && m_page->height() - m_page->Margins.Bottom < closest)
640
                closest = m_page->height() - m_page->Margins.Bottom;
7572 fschmid 641
 
5164 tsoots 642
        return closest;
643
}
644
 
6203 subik 645
double GuideManagerCore::closestVertLeft(double x)// const
5164 tsoots 646
{
647
        double closest = 0.0;
8547 cbradney 648
        for (int i = 0; i < verticalStdG.size(); ++i)
5164 tsoots 649
        {
650
                if (verticalStdG[i] < x && verticalStdG[i] > closest)
651
                        closest = verticalStdG[i];
652
        }
653
 
8547 cbradney 654
        for (int i = 0; i < verticalAutoG.size(); ++i)
5167 tsoots 655
        {
656
                if (verticalAutoG[i] < x && verticalAutoG[i] > closest)
657
                        closest = verticalAutoG[i];
658
        }
7572 fschmid 659
 
8554 subik 660
        if (m_page->Margins.Left < x && m_page->Margins.Left > closest)
5199 subik 661
                closest = m_page->Margins.Left;
8547 cbradney 662
        if (m_page->width() - m_page->Margins.Right < x && m_page->width() - m_page->Margins.Right > closest)
5199 subik 663
                closest = m_page->width() - m_page->Margins.Right;
7572 fschmid 664
 
5164 tsoots 665
        return closest;
666
}
667
 
6203 subik 668
double GuideManagerCore::closestVertRight(double x)// const
5164 tsoots 669
{
5199 subik 670
        double closest = m_page->width();
8547 cbradney 671
        for (int i = 0; i < verticalStdG.size(); ++i)
5164 tsoots 672
        {
673
                if (verticalStdG[i] > x && verticalStdG[i] < closest)
674
                        closest = verticalStdG[i];
675
        }
676
 
8547 cbradney 677
        for (int i = 0; i < verticalAutoG.size(); ++i)
5167 tsoots 678
        {
679
                if (verticalAutoG[i] > x && verticalAutoG[i] < closest)
680
                        closest = verticalAutoG[i];
681
        }
7572 fschmid 682
 
5199 subik 683
        if (m_page->Margins.Left > x  && m_page->Margins.Left < closest)
684
                closest = m_page->Margins.Left;
685
        if (m_page->width() - m_page->Margins.Right > x && m_page->width() - m_page->Margins.Right < closest)
686
                closest = m_page->width() - m_page->Margins.Right;
7572 fschmid 687
 
5164 tsoots 688
        return closest;
689
}
5199 subik 690
 
6203 subik 691
 
7682 subik 692
void GuideManagerIO::readVerticalGuides(const QString guideString, Page *page, GuideManagerCore::GuideType type, bool useOldGuides)
693
{
10603 fschmid 694
        QStringList gVal(guideString.split(' ', QString::SkipEmptyParts));
7682 subik 695
        for (QStringList::Iterator it = gVal.begin(); it != gVal.end(); ++it )
696
                useOldGuides ?
13464 cbradney 697
                        page->guides.addHorizontal(ScCLocale::toDoubleC((*it)), type) :
698
                        page->guides.addVertical(ScCLocale::toDoubleC((*it)), type);
7682 subik 699
}
700
 
701
void GuideManagerIO::readHorizontalGuides(const QString guideString, Page *page, GuideManagerCore::GuideType type, bool useOldGuides)
702
{
10603 fschmid 703
        QStringList gVal(guideString.split(' ', QString::SkipEmptyParts));
7682 subik 704
        for (QStringList::Iterator it = gVal.begin(); it != gVal.end(); ++it )
705
                useOldGuides ?
13464 cbradney 706
                        page->guides.addVertical(ScCLocale::toDoubleC((*it)), type):
707
                        page->guides.addHorizontal(ScCLocale::toDoubleC((*it)), type);
7682 subik 708
}
709
 
710
QString GuideManagerIO::writeHorizontalGuides(Page *page, GuideManagerCore::GuideType type)
711
{
712
        Guides::iterator it;
713
        QString retval;
714
        QString tmp;
715
        Guides tmpGuides = page->guides.horizontals(type);
716
        for (it = tmpGuides.begin(); it != tmpGuides.end(); ++it)
717
        {
718
                tmp = tmp.setNum((*it));
719
                retval += tmp + " ";
720
        }
721
        return retval;
722
}
723
 
724
QString GuideManagerIO::writeVerticalGuides(Page *page, GuideManagerCore::GuideType type)
725
{
726
        Guides::iterator it;
727
        QString retval;
728
        QString tmp;
729
        Guides tmpGuides = page->guides.verticals(type);
730
        for (it = tmpGuides.begin(); it != tmpGuides.end(); ++it)
731
        {
732
                tmp = tmp.setNum((*it));
733
                retval += tmp + " ";
734
        }
735
        return retval;
736
}
7715 subik 737
 
738
QString GuideManagerIO::writeSelection(Page *page)
739
{
740
        return QString("%1 %2 %3 %4").arg(page->guides.gx).arg(page->guides.gy).arg(page->guides.gw).arg(page->guides.gh);
741
}
742
 
743
void GuideManagerIO::readSelection(const QString guideString, Page *page)
744
{
9070 subik 745
        // TODO: examine this check in 134vs.134qt4 - PV
746
        if (guideString.isNull() || guideString.isEmpty())
747
                return;
10603 fschmid 748
        QStringList gVal(guideString.split(' ', QString::SkipEmptyParts));
13464 cbradney 749
        page->guides.gx = ScCLocale::toDoubleC(gVal[0]);
750
        page->guides.gy = ScCLocale::toDoubleC(gVal[1]);
751
        page->guides.gw = ScCLocale::toDoubleC(gVal[2]);
752
        page->guides.gh = ScCLocale::toDoubleC(gVal[3]);
7715 subik 753
}