Subversion Repositories Scribus

Rev

Rev 19215 | Rev 19562 | 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
                          page.cpp  -  description
9
                             -------------------
10
    begin                : Sat Apr 7 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
12063 cbradney 24
#include <QDebug>
10862 cbradney 25
#include <QPixmap>
26
 
19067 craig 27
#include "appmodes.h"
16729 fschmid 28
#include "scpage.h"
1115 tsoots 29
#include "scribus.h"
19080 craig 30
#include "scribusdoc.h"
19093 craig 31
#include "scribusview.h"
4702 cbradney 32
#include "selection.h"
1190 tsoots 33
#include "undomanager.h"
34
#include "undostate.h"
10200 cbradney 35
#include "util_icon.h"
128 Franz 36
 
16736 jghali 37
#include "ui/guidemanager.h"
38
#include "ui/nodeeditpalette.h"
39
 
16729 fschmid 40
ScPage::ScPage(const double x, const double y, const double b, const double h) :
3987 craig 41
        UndoObject(QObject::tr("Page")),
16729 fschmid 42
        SingleObservable<ScPage>(NULL),
3987 craig 43
        Margins(40,40,40,40),
44
        initialMargins(40,40,40,40),
45
        LeftPg(0),
46
        MPageNam(""),
47
        FromMaster(),
48
        undoManager(UndoManager::instance()),
49
        m_xOffset(x),
50
        m_yOffset(y),
51
        m_width(b),
52
        m_height(h),
53
        m_initialWidth(b),
4738 cbradney 54
        m_initialHeight(h),
5685 cbradney 55
        m_PageName(""),
5104 subik 56
        m_Doc(NULL)
3 paul 57
{
5104 subik 58
        guides.setPage(this);
12334 fschmid 59
        marginPreset = 0;
18394 fschmid 60
        PresentVals.pageEffectDuration = 1;
61
        PresentVals.pageViewDuration = 1;
62
        PresentVals.effectType = 0;
63
        PresentVals.Dm = 0;
64
        PresentVals.M = 0;
65
        PresentVals.Di = 0;
3 paul 66
}
1115 tsoots 67
 
16729 fschmid 68
ScPage::~ScPage()
4069 craig 69
{
70
        // Clean up any modified template items (unused)
9856 fschmid 71
//      for (PageItem *currItem = FromMaster.first(); currItem; currItem = FromMaster.next())
72
//      {
73
//              if (currItem->ChangedMasterItem)
74
//              {
75
//                      FromMaster.remove(currItem);
76
//                      delete currItem;
77
//              }
78
//      }
4069 craig 79
        FromMaster.clear();
80
}
81
 
16729 fschmid 82
void ScPage::setDocument(ScribusDoc *doc)
1115 tsoots 83
{
4738 cbradney 84
        m_Doc=doc;
10532 avox 85
        setMassObservable(doc? doc->pagesChanged() : NULL);
4738 cbradney 86
}
87
 
16729 fschmid 88
void ScPage::setPageNr(int pageNr)
4738 cbradney 89
{
3200 cbradney 90
        m_pageNr = pageNr;
5685 cbradney 91
        if (m_PageName.isEmpty())
92
                setUName(QString(QObject::tr("Page") + " %1").arg(m_Doc->FirstPnum + m_pageNr));
1199 tsoots 93
        else
5685 cbradney 94
                setUName(m_PageName);
1115 tsoots 95
}
96
 
16729 fschmid 97
void ScPage::setPageName(const QString& newName)
1199 tsoots 98
{
5685 cbradney 99
        m_PageName = newName;
2877 cbradney 100
        if (!newName.isEmpty())
2093 cbradney 101
                setUName(QObject::tr("Master Page ") + newName);
1199 tsoots 102
}
103
 
16729 fschmid 104
void ScPage::restore(UndoState* state, bool isUndo)
1115 tsoots 105
{
106
        SimpleState* ss = dynamic_cast<SimpleState*>(state);
107
        if (ss)
108
        {
13350 cbradney 109
//              int stateCode = ss->transactionCode;
1115 tsoots 110
                if (ss->contains("ADD_V"))
111
                {
112
                        double position = ss->getDouble("ADD_V");
113
                        if (isUndo)
5087 subik 114
                                guides.deleteVertical(position, GuideManagerCore::Standard);//removeXGuide(position);
1115 tsoots 115
                        else
5087 subik 116
                                guides.addVertical(position, GuideManagerCore::Standard);//addXGuide(position);
9069 subik 117
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 118
                }
119
                else if (ss->contains("ADD_H"))
120
                {
121
                        double position = ss->getDouble("ADD_H");
122
                        if (isUndo)
5087 subik 123
                                guides.deleteHorizontal(position, GuideManagerCore::Standard);//removeYGuide(position);
1115 tsoots 124
                        else
5087 subik 125
                                guides.addHorizontal(position, GuideManagerCore::Standard);//addYGuide(position);
9069 subik 126
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 127
                }
128
                else if (ss->contains("REMOVE_V"))
129
                {
130
                        double position = ss->getDouble("REMOVE_V");
131
                        if (isUndo)
5087 subik 132
                                guides.addVertical(position, GuideManagerCore::Standard);//addXGuide(position);
1115 tsoots 133
                        else
5087 subik 134
                                guides.deleteVertical(position, GuideManagerCore::Standard);//removeXGuide(position);
9069 subik 135
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 136
                }
137
                else if (ss->contains("REMOVE_H"))
138
                {
139
                        double position = ss->getDouble("REMOVE_H");
140
                        if (isUndo)
5087 subik 141
                                guides.addHorizontal(position, GuideManagerCore::Standard);//addYGuide(position);
1115 tsoots 142
                        else
5087 subik 143
                                guides.deleteHorizontal(position, GuideManagerCore::Standard);//removeYGuide(position);
9069 subik 144
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 145
                }
5087 subik 146
                else if (ss->contains("MOVE_H_FROM"))
1115 tsoots 147
                {
5087 subik 148
                        double from = ss->getDouble("MOVE_H_FROM");
149
                        double to   = ss->getDouble("MOVE_H_TO");
1115 tsoots 150
                        if (isUndo)
151
                        {
5087 subik 152
                                guides.deleteHorizontal(to, GuideManagerCore::Standard);//removeYGuide(position);
153
                                guides.addHorizontal(from, GuideManagerCore::Standard);//addYGuide(position);
1115 tsoots 154
                        }
155
                        else
156
                        {
5087 subik 157
                                guides.deleteHorizontal(from, GuideManagerCore::Standard);//removeYGuide(position);
158
                                guides.addHorizontal(to, GuideManagerCore::Standard);//addYGuide(position);
1115 tsoots 159
                        }
9069 subik 160
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 161
                }
5087 subik 162
                else if (ss->contains("MOVE_V_FROM"))
1115 tsoots 163
                {
5087 subik 164
                        double from = ss->getDouble("MOVE_V_FROM");
165
                        double to   = ss->getDouble("MOVE_V_TO");
1115 tsoots 166
                        if (isUndo)
167
                        {
5087 subik 168
                                guides.deleteVertical(to, GuideManagerCore::Standard);//removeXGuide(position);
169
                                guides.addVertical(from, GuideManagerCore::Standard);//removeXGuide(position);
1115 tsoots 170
                        }
171
                        else
172
                        {
5087 subik 173
                                guides.deleteVertical(from, GuideManagerCore::Standard);//removeXGuide(position);
174
                                guides.addVertical(to, GuideManagerCore::Standard);//removeXGuide(position);
1115 tsoots 175
                        }
9069 subik 176
                        m_Doc->scMW()->guidePalette->setupGui();
1115 tsoots 177
                }
9069 subik 178
                // automatic guides
179
                else if (ss->contains("REMOVE_HA_GAP"))
180
                {
181
                        if (isUndo)
182
                        {
183
                                guides.setHorizontalAutoCount(ss->getInt("REMOVE_HA_COUNT"));
184
                                guides.setHorizontalAutoGap(ss->getDouble("REMOVE_HA_GAP"));
185
                                guides.setHorizontalAutoRefer(ss->getInt("REMOVE_HA_REFER"));
186
                        }
187
                        else
188
                        {
189
                                guides.setHorizontalAutoCount(0);
190
                                guides.setHorizontalAutoGap(0.0);
191
                                guides.setHorizontalAutoRefer(0);
192
                        }
193
                        m_Doc->scMW()->guidePalette->setupGui();
194
                }
195
                else if (ss->contains("REMOVE_VA_GAP"))
196
                {
197
                        if (isUndo)
198
                        {
199
                                guides.setVerticalAutoCount(ss->getInt("REMOVE_VA_COUNT"));
200
                                guides.setVerticalAutoGap(ss->getDouble("REMOVE_VA_GAP"));
201
                                guides.setVerticalAutoRefer(ss->getInt("REMOVE_VA_REFER"));
202
                        }
203
                        else
204
                        {
205
                                guides.setVerticalAutoCount(0);
206
                                guides.setVerticalAutoGap(0.0);
207
                                guides.setVerticalAutoRefer(0);
208
                        }
209
                        m_Doc->scMW()->guidePalette->setupGui();
210
                }
1341 tsoots 211
                else if (ss->contains("CREATE_ITEM"))
16729 fschmid 212
                        restorePageItemCreation(dynamic_cast<ScItemState<PageItem*>*>(ss), isUndo);
1340 tsoots 213
                else if (ss->contains("DELETE_ITEM"))
16729 fschmid 214
                        restorePageItemDeletion(dynamic_cast<ScItemState< QList<PageItem*> >*>(ss), isUndo);
3670 cbradney 215
                else if (ss->contains("CONVERT_ITEM"))
16729 fschmid 216
                        restorePageItemConversion(dynamic_cast<ScItemState<std::pair<PageItem*, PageItem*> >*>(ss), isUndo);
17640 craig 217
                else if (ss->contains("PAGE_ATTRS"))
218
                        restorePageAttributes(ss, isUndo);
1115 tsoots 219
        }
220
}
1238 tsoots 221
 
17640 craig 222
void ScPage::restorePageAttributes(SimpleState *state, bool isUndo)
223
{
224
        int left_old = state->getInt("LEFT_OLD");
225
        QString name_old = state->get("NAME_OLD");
226
        int orientation_old = state->getInt("ORIENTATION_OLD");
227
        QString size_old =state->get("SIZE_OLD");
228
        double width_old = state->getDouble("WIDTH_OLD");
229
        double height_old = state->getDouble("HEIGHT_OLD");
230
        double init_height_old = state->getDouble("INIT_HEIGHT_OLD");
231
        double init_width_old = state->getDouble("INIT_WIDTH_OLD");
232
        double init_margin_top_old = state->getDouble("INIT_MARGINTOP_OLD");
233
        double init_margin_bottom_old = state->getDouble("INIT_MARGINBOTTOM_OLD");
234
        double init_margin_right_old = state->getDouble("INIT_MARGINRIGHT_OLD");
235
        double init_margin_left_old = state->getDouble("INIT_MARGINLEFT_OLD");
236
        double margin_top_old = state->getDouble("MARGINTOP_OLD");
237
        double margin_bottom_old = state->getDouble("MARGINBOTTOM_OLD");
238
        int margin_preset_old = state->getInt("MARGINPRESET_OLD");
239
        int left = state->getInt("LEFT");
240
        QString name = state->get("NAME");
241
        int orientation = state->getInt("ORIENTATION");
242
        QString size =state->get("SIZE");
243
        double width = state->getDouble("WIDTH");
244
        double height = state->getDouble("HEIGHT");
245
        double init_height = state->getDouble("INIT_HEIGHT");
246
        double init_width = state->getDouble("INIT_WIDTH");
247
        double init_margin_top = state->getDouble("INIT_MARGINTOP");
248
        double init_margin_bottom = state->getDouble("INIT_MARGINBOTTOM");
249
        double init_margin_right = state->getDouble("INIT_MARGINRIGHT");
250
        double init_margin_left = state->getDouble("INIT_MARGINLEFT");
251
        double margin_top = state->getDouble("MARGINTOP");
252
        double margin_bottom = state->getDouble("MARGINBOTTOM");
253
        int margin_preset = state->getInt("MARGINPRESET");
254
        double horizontal_autogap_old = state->getDouble("HORIZONTAL_AUTOGAP");
255
        double vertical_autogap_old = state->getDouble("VERTICAL_AUTOGAP");
256
        double horizontal_autocount_old = state->getDouble("HORIZONTAL_AUTOCOUNT");
257
        double vertical_autocount_old = state->getDouble("VERTICAL_AUTOCOUNT");
258
        double horizontal_autorefer_old = state->getDouble("HORIZONTAL_AUTOREFER");
259
        double vertical_autorefer_old = state->getDouble("VERTICAL_AUTOREFER");
260
        double horizontal_autogap = state->getDouble("HORIZONTAL_AUTOGAP");
261
        double vertical_autogap = state->getDouble("VERTICAL_AUTOGAP");
262
        double horizontal_autocount = state->getDouble("HORIZONTAL_AUTOCOUNT");
263
        double vertical_autocount = state->getDouble("VERTICAL_AUTOCOUNT");
264
        double horizontal_autorefer = state->getDouble("HORIZONTAL_AUTOREFER");
265
        double vertical_autorefer = state->getDouble("VERTICAL_AUTOREFER");
266
 
267
        if (isUndo)
268
        {
269
                this->LeftPg = left_old;
270
                this->setPageName(name_old);
271
                this->m_pageSize = size_old;
272
                this->setOrientation(orientation_old);
273
                this->setWidth(width_old);
274
                this->setHeight(height_old);
275
                this->setInitialHeight(init_height_old);
276
                this->setInitialWidth(init_width_old);
277
                this->initialMargins.Top    = init_margin_top_old;
278
                this->initialMargins.Bottom = init_margin_bottom_old;
279
                this->initialMargins.Left   = init_margin_left_old;
280
                this->initialMargins.Right  = init_margin_right_old;
281
                this->marginPreset = margin_preset_old;
282
                this->Margins.Top = margin_top_old;
283
                this->Margins.Bottom = margin_bottom_old;
284
                this->guides.setHorizontalAutoGap(horizontal_autogap_old);
285
                this->guides.setVerticalAutoGap(vertical_autogap_old);
286
                this->guides.setHorizontalAutoCount(horizontal_autocount_old);
287
                this->guides.setVerticalAutoCount(vertical_autocount_old);
288
                this->guides.setHorizontalAutoRefer(horizontal_autorefer_old);
289
                this->guides.setVerticalAutoRefer(vertical_autorefer_old);
290
        }
291
        else
292
        {
293
                this->LeftPg = left;
294
                this->setPageName(name);
295
                this->m_pageSize = size;
296
                this->setOrientation(orientation);
297
                this->setWidth(width);
298
                this->setHeight(height);
299
                this->setInitialHeight(init_height);
300
                this->setInitialWidth(init_width);
301
                this->initialMargins.Top    = init_margin_top;
302
                this->initialMargins.Bottom = init_margin_bottom;
303
                this->initialMargins.Left   = init_margin_left;
304
                this->initialMargins.Right  = init_margin_right;
305
                this->marginPreset = margin_preset;
306
                this->Margins.Top = margin_top;
307
                this->Margins.Bottom = margin_bottom;
308
                this->guides.setHorizontalAutoGap(horizontal_autogap);
309
                this->guides.setVerticalAutoGap(vertical_autogap);
310
                this->guides.setHorizontalAutoCount(horizontal_autocount);
311
                this->guides.setVerticalAutoCount(vertical_autocount);
312
                this->guides.setHorizontalAutoRefer(horizontal_autorefer);
313
                this->guides.setVerticalAutoRefer(vertical_autorefer);
314
        }
315
}
316
 
16729 fschmid 317
void ScPage::restorePageItemCreation(ScItemState<PageItem*> *state, bool isUndo)
1238 tsoots 318
{
1341 tsoots 319
        if (!state)
320
                return;
13312 fschmid 321
        int stateCode = state->transactionCode;
1518 tsoots 322
        PageItem *ite = state->getItem();
5781 cbradney 323
        bool oldMPMode=m_Doc->masterPageMode();
19215 jghali 324
        m_Doc->setMasterPageMode(!ite->OnMasterPage.isEmpty());
325
        if (m_Doc->appMode == modeEditClip) // switch off from edit shape
326
                m_Doc->scMW()->nodePalette->EndEdit();
13331 jghali 327
        m_Doc->m_Selection->delaySignalsOn();
1238 tsoots 328
        if (isUndo)
329
        {
5781 cbradney 330
                if (m_Doc->m_Selection->findItem(ite)!=-1)
4888 cbradney 331
                {
18295 jghali 332
                        if (m_Doc->appMode == modeEdit || m_Doc->appMode == modeEditTable)
12767 jghali 333
                                m_Doc->view()->requestMode(modeNormal);
5781 cbradney 334
                        m_Doc->m_Selection->removeItem(ite);
4888 cbradney 335
                }
13312 fschmid 336
                if ((stateCode == 0) || (stateCode == 1))
337
                        m_Doc->view()->Deselect(true);
13359 jghali 338
                Selection tmpSelection(m_Doc, false);
339
                tmpSelection.addItem(ite);
340
                m_Doc->itemSelection_DeleteItem(&tmpSelection);
1238 tsoots 341
        }
342
        else
343
        {
13312 fschmid 344
                if ((stateCode == 0) || (stateCode == 1))
345
                        m_Doc->view()->Deselect(true);
5781 cbradney 346
                m_Doc->Items->append(ite);
17640 craig 347
                ite->OwnPage = m_Doc->OnPage(ite);
1238 tsoots 348
        }
18876 craig 349
        if ((stateCode == 0) || (stateCode == 2))
18788 jghali 350
                update();
5781 cbradney 351
        m_Doc->setMasterPageMode(oldMPMode);
13331 jghali 352
        m_Doc->m_Selection->delaySignalsOff();
1238 tsoots 353
}
354
 
16729 fschmid 355
void ScPage::restorePageItemDeletion(ScItemState< QList<PageItem*> > *state, bool isUndo)
1340 tsoots 356
{
357
        if (!state)
358
                return;
18872 craig 359
        int stateCode = state->transactionCode;
13451 jghali 360
        QList<PageItem*> itemList = state->getItem();
16943 fschmid 361
        int id = state->getInt("ITEMID");
17640 craig 362
        int id2 = state->getInt("ID");
13451 jghali 363
        if (itemList.count() <= 0)
364
                return;
13315 fschmid 365
        m_Doc->view()->Deselect(true);
19374 jghali 366
        bool oldMPMode = m_Doc->masterPageMode();
13451 jghali 367
        m_Doc->setMasterPageMode(!itemList.at(0)->OnMasterPage.isEmpty());
13315 fschmid 368
        if (m_Doc->appMode == modeEditClip) // switch off from edit shape
369
                m_Doc->scMW()->nodePalette->EndEdit();
370
        m_Doc->m_Selection->delaySignalsOn();
1340 tsoots 371
        if (isUndo)
372
        {
7687 cbradney 373
                //CB #3373 reinsert at old position and renumber items
17640 craig 374
                PageItem* ite = itemList.at(id2);
19374 jghali 375
                if (ite->Parent && ite->Parent->isGroup())
376
                        ite->Parent->asGroupFrame()->groupItemList.insert(id, ite);
377
                else
378
                        m_Doc->Items->insert(id, ite);
13451 jghali 379
                for (int i = 0; i < itemList.count(); ++i)
380
                {
381
                        PageItem* ite = itemList.at(i);
17640 craig 382
                        m_Doc->view()->SelectItem(ite);
13451 jghali 383
                }
1340 tsoots 384
        }
385
        else
386
        {
13451 jghali 387
                Selection tmpSelection(m_Doc, false);
17640 craig 388
                PageItem* ite = itemList.at(id2);
389
                if (m_Doc->m_Selection->findItem(ite)!=-1)
4888 cbradney 390
                {
18295 jghali 391
                        if (m_Doc->appMode == modeEdit || m_Doc->appMode == modeEditTable)
17640 craig 392
                                m_Doc->view()->requestMode(modeNormal);
393
                        m_Doc->m_Selection->removeItem(ite);
4888 cbradney 394
                }
17640 craig 395
                tmpSelection.addItem(ite);
13359 jghali 396
                m_Doc->itemSelection_DeleteItem(&tmpSelection);
1340 tsoots 397
        }
18872 craig 398
        if ((stateCode == 0) || (stateCode == 2))
399
                update();
400
        m_Doc->setMasterPageMode(oldMPMode);
13315 fschmid 401
        m_Doc->m_Selection->delaySignalsOff();
1340 tsoots 402
}
3200 cbradney 403
 
16729 fschmid 404
void ScPage::restorePageItemConversion(ScItemState<std::pair<PageItem*, PageItem*> >*state, bool isUndo)
3670 cbradney 405
{
406
        if (!state)
407
                return;
408
 
409
        PageItem *oldItem=state->getItem().first;
410
        PageItem *newItem=state->getItem().second;
5781 cbradney 411
        bool oldMPMode=m_Doc->masterPageMode();
412
        m_Doc->setMasterPageMode(!oldItem->OnMasterPage.isEmpty());
3670 cbradney 413
        if (isUndo)
414
        {
16943 fschmid 415
                m_Doc->Items->replace(m_Doc->Items->indexOf(newItem), oldItem);
4688 cbradney 416
                oldItem->updatePolyClip();
7736 cbradney 417
                m_Doc->AdjustItemSize(oldItem);
3670 cbradney 418
        }
419
        else
420
        {
16943 fschmid 421
                m_Doc->Items->replace(m_Doc->Items->indexOf(oldItem), newItem);
3670 cbradney 422
        }
5781 cbradney 423
        m_Doc->setMasterPageMode(oldMPMode);
3670 cbradney 424
}
425
 
16729 fschmid 426
void ScPage::setXOffset(const double newCanvasXOffset)
3200 cbradney 427
{
428
        m_xOffset = newCanvasXOffset;
429
}
430
 
16729 fschmid 431
void ScPage::setYOffset(const double newCanvasYOffset)
3200 cbradney 432
{
433
        m_yOffset = newCanvasYOffset;
434
}
435
 
16729 fschmid 436
void ScPage::setWidth(const double newWidth)
3200 cbradney 437
{
438
        m_width = newWidth;
439
}
440
 
16729 fschmid 441
void ScPage::setHeight(const double newHeight)
3200 cbradney 442
{
443
        m_height = newHeight;
444
}
445
 
16729 fschmid 446
void ScPage::setInitialWidth(const double newInitialWidth)
3200 cbradney 447
{
448
        m_initialWidth = newInitialWidth;
449
}
450
 
16729 fschmid 451
void ScPage::setInitialHeight(const double newInitialHeight)
3200 cbradney 452
{
453
        m_initialHeight = newInitialHeight;
454
}
4242 craig 455
 
16729 fschmid 456
void ScPage::setOrientation(int ori)
13731 cbradney 457
{
458
        m_orientation = ori;
459
}
460
 
16729 fschmid 461
void ScPage::setPageSectionNumber(const QString& newPageSectionNumber)
4242 craig 462
{
463
        m_pageSectionNumber=newPageSectionNumber;
464
}
465
 
16729 fschmid 466
void ScPage::copySizingProperties(ScPage* sourcePage, const MarginStruct& pageMargins)
4568 cbradney 467
{
468
        if (sourcePage==NULL)
469
                return;
5789 cbradney 470
        m_pageSize = sourcePage->m_pageSize;
13731 cbradney 471
        m_orientation = sourcePage->m_orientation;
4568 cbradney 472
        m_width=sourcePage->m_width;
473
        m_height=sourcePage->m_height;
474
        m_initialWidth = sourcePage->m_initialWidth;
475
        m_initialHeight = sourcePage->m_initialHeight;
5104 subik 476
 
14781 jghali 477
        Margins.Top    = pageMargins.Top;
4568 cbradney 478
        Margins.Bottom = pageMargins.Bottom;
14781 jghali 479
        Margins.Left   = pageMargins.Left;//todo fix for layouts
480
        Margins.Right  = pageMargins.Right;
481
        // #8859 do not get initialMargins from pageMargins otherwise
482
        // margins may be inverted when applying master pages
483
        initialMargins.Top    = sourcePage->initialMargins.Top;
484
        initialMargins.Bottom = sourcePage->initialMargins.Bottom;
485
        initialMargins.Left   = sourcePage->initialMargins.Left;
486
        initialMargins.Right  = sourcePage->initialMargins.Right;
4568 cbradney 487
}