← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to kword/part/tests/TestFrameLayout.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-10-27 17:52:57 UTC
  • mfrom: (0.12.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20101027175257-s04zqqk5bs8ckm9o
Tags: 1:2.2.83-0ubuntu1
* Merge with Debian git remaining changes:
 - Add build-deps on librcps-dev, opengtl-dev, libqtgtl-dev, freetds-dev,
   create-resources, libspnav-dev
 - Remove needless build-dep on libwv2-dev
 - koffice-libs recommends create-resources
 - krita recommends pstoedit
 - Keep our patches
* New upstream release 2.3 beta 3
  - Remove debian/patches fixed by upstream
  - Update install files

Show diffs side-by-side

added added

removed removed

Lines of Context:
kword/part/tests/TestFrameLayout.cpp
 
1
#include "TestFrameLayout.h"
 
2
#include "TestDocumentLayout.h"
 
3
 
 
4
#include "../KWPageManager.h"
 
5
#include "../KWPage.h"
 
6
#include "../KWPageStyle.h"
 
7
#include "../frames/KWFrameLayout.h"
 
8
#include "../frames/KWCopyShape.h"
 
9
#include "../frames/KWTextFrameSet.h"
 
10
#include "../frames/KWTextFrame.h"
 
11
#include "../KWord.h"
 
12
#include <MockShapes.h>
 
13
#include <MockTextShape.h>
 
14
 
 
15
#include <KoTextDocumentLayout.h>
 
16
#include <KoColorBackground.h>
 
17
#include <QTextCursor>
 
18
 
 
19
#include <kcomponentdata.h>
 
20
 
 
21
class Helper
 
22
{
 
23
public:
 
24
    Helper() {
 
25
        pageManager = new KWPageManager();
 
26
        KWPage page = pageManager->appendPage();
 
27
        KoPageLayout pageLayout = page.pageStyle().pageLayout();
 
28
        pageLayout.width = 200;
 
29
        pageLayout.height = 200;
 
30
        page.pageStyle().setPageLayout(pageLayout);
 
31
        pageStyle = page.pageStyle();
 
32
    }
 
33
    ~Helper() {
 
34
        delete pageManager;
 
35
    }
 
36
 
 
37
    KWPageManager *pageManager;
 
38
    KWPageStyle pageStyle;
 
39
};
 
40
 
 
41
TestFrameLayout::TestFrameLayout()
 
42
{
 
43
    new KComponentData("TestFrameLayout");
 
44
}
 
45
 
 
46
void TestFrameLayout::testGetOrCreateFrameSet()
 
47
{
 
48
    Helper helper;
 
49
    m_frames.clear();
 
50
    KWPage page = helper.pageManager->page(1);
 
51
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
52
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
53
 
 
54
    KWTextFrameSet *fs = bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page);
 
55
    QVERIFY(fs);
 
56
    QCOMPARE(fs->textFrameSetType(), KWord::OddPagesHeaderTextFrameSet);
 
57
 
 
58
    KWTextFrameSet *fs2 = bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page);
 
59
    QVERIFY(fs2);
 
60
    QCOMPARE(fs, fs2);
 
61
    QVERIFY(m_frames.contains(fs2));
 
62
 
 
63
    KWTextFrameSet *main = new KWTextFrameSet(0, KWord::MainTextFrameSet);
 
64
    m_frames.append(main);
 
65
    bfl.m_setup = false;
 
66
    KWTextFrameSet *main2 = bfl.getOrCreate(KWord::MainTextFrameSet, page);
 
67
    QVERIFY(main2);
 
68
    QCOMPARE(main, main2);
 
69
    QCOMPARE(main->textFrameSetType(), KWord::MainTextFrameSet);
 
70
}
 
71
 
 
72
void TestFrameLayout::testCreateNewFramesForPage()
 
73
{
 
74
    Helper helper;
 
75
    m_frames.clear();
 
76
    QVERIFY(m_frames.count() == 0);
 
77
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
78
    KWPage page = helper.pageManager->page(1);
 
79
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
80
 
 
81
    KWTextFrameSet *main = bfl.getOrCreate(KWord::MainTextFrameSet, page);
 
82
    QVERIFY(main);
 
83
    QVERIFY(bfl.frameOn(main, 1) == 0);
 
84
 
 
85
    KoShape *shape = new MockTextShape();
 
86
    new KWTextFrame(shape, main);
 
87
    QCOMPARE(main->frameCount(), 1);
 
88
 
 
89
    QVERIFY(bfl.frameOn(main, 1));
 
90
 
 
91
    bfl.createNewFramesForPage(1);
 
92
    QCOMPARE(main->frameCount(), 1);
 
93
}
 
94
 
 
95
void TestFrameLayout::testShouldHaveHeaderOrFooter()
 
96
{
 
97
    Helper helper;
 
98
    m_frames.clear();
 
99
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
100
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
101
 
 
102
    // test the first page
 
103
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeNone);
 
104
    helper.pageStyle.setFooterPolicy(KWord::HFTypeNone);
 
105
    KWord::TextFrameSetType origin;
 
106
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, true, &origin), false);  // header
 
107
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, false, &origin), false); // footer
 
108
 
 
109
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeEvenOdd);
 
110
    helper.pageStyle.setFooterPolicy(KWord::HFTypeUniform);
 
111
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, true, &origin), true);
 
112
    QCOMPARE(origin, KWord::OddPagesHeaderTextFrameSet);
 
113
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, false, &origin), true);
 
114
    QCOMPARE(origin, KWord::OddPagesFooterTextFrameSet);
 
115
 
 
116
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeUniform);
 
117
    helper.pageStyle.setFooterPolicy(KWord::HFTypeEvenOdd);
 
118
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, true, &origin), true);
 
119
    QCOMPARE(origin, KWord::OddPagesHeaderTextFrameSet);
 
120
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, false, &origin), true);
 
121
    QCOMPARE(origin, KWord::OddPagesFooterTextFrameSet);
 
122
 
 
123
    // append the second page, same pageStyle like the first
 
124
    helper.pageManager->appendPage();
 
125
    QVERIFY(helper.pageManager->page(1).pageStyle() == helper.pageManager->page(2).pageStyle());
 
126
 
 
127
    // append the theird page with another pagesettings
 
128
    KWPageStyle pagesettings3("Page3PageStyle");
 
129
    helper.pageManager->addPageStyle(pagesettings3);
 
130
    helper.pageManager->appendPage(pagesettings3);
 
131
    QVERIFY(helper.pageManager->page(3).pageStyle() == pagesettings3);
 
132
 
 
133
    // test the second page
 
134
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeNone);
 
135
    helper.pageStyle.setFooterPolicy(KWord::HFTypeNone);
 
136
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(2, true, &origin), false);
 
137
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(2, false, &origin), false);
 
138
 
 
139
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeEvenOdd);
 
140
    helper.pageStyle.setFooterPolicy(KWord::HFTypeUniform);
 
141
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(2, true, &origin), true);
 
142
    QCOMPARE(origin, KWord::EvenPagesHeaderTextFrameSet);
 
143
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(2, false, &origin), true);
 
144
    QCOMPARE(origin, KWord::OddPagesFooterTextFrameSet);
 
145
 
 
146
    // test the 3rd page
 
147
    pagesettings3.setHeaderPolicy(KWord::HFTypeEvenOdd);
 
148
    pagesettings3.setFooterPolicy(KWord::HFTypeUniform);
 
149
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(3, true, &origin), true);
 
150
    QCOMPARE(origin, KWord::OddPagesHeaderTextFrameSet);
 
151
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(3, false, &origin), true);
 
152
    QCOMPARE(origin, KWord::OddPagesFooterTextFrameSet);
 
153
 
 
154
    pagesettings3.setHeaderPolicy(KWord::HFTypeNone);
 
155
    pagesettings3.setFooterPolicy(KWord::HFTypeNone);
 
156
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(3, true, &origin), false);
 
157
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(3, false, &origin), false);
 
158
 
 
159
    // test the first and the second pages again to be sure they still have there prev values
 
160
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(1, true, &origin), true);
 
161
    QCOMPARE(bfl.shouldHaveHeaderOrFooter(2, true, &origin), true);
 
162
}
 
163
 
 
164
void TestFrameLayout::headerPerPage()
 
165
{
 
166
    Helper helper;
 
167
    m_frames.clear();
 
168
    KWPage page = helper.pageManager->begin();
 
169
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
170
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
171
 
 
172
    KWPageStyle myStyle("myStyle");
 
173
    myStyle.setHeaderPolicy(KWord::HFTypeUniform);
 
174
    helper.pageManager->addPageStyle(myStyle);
 
175
    KWPage page2 = helper.pageManager->appendPage(myStyle);
 
176
    QVERIFY(page.pageStyle() != page2.pageStyle());
 
177
    QCOMPARE(bfl.m_pageStyles.count(), 0);
 
178
 
 
179
    KWTextFrameSet *fs = bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page);
 
180
    QVERIFY(fs);
 
181
    QCOMPARE(fs->textFrameSetType(), KWord::OddPagesHeaderTextFrameSet);
 
182
 
 
183
    QCOMPARE(bfl.m_pageStyles.count(), 1);
 
184
    QVERIFY(bfl.m_pageStyles.contains(page.pageStyle()));
 
185
    KWFrameLayout::FrameSets fsets = bfl.m_pageStyles[page.pageStyle()];
 
186
    QCOMPARE(fsets.oddHeaders, fs);
 
187
    QCOMPARE(fsets.evenHeaders, (void*) 0);
 
188
    QCOMPARE(fsets.oddFooters, (void*) 0);
 
189
    QCOMPARE(fsets.evenFooters, (void*) 0);
 
190
 
 
191
    KWTextFrameSet *fs2 = bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page2);
 
192
    QVERIFY(fs2);
 
193
    QCOMPARE(fs2->textFrameSetType(), KWord::OddPagesHeaderTextFrameSet);
 
194
 
 
195
    QVERIFY(fs != fs2);
 
196
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page2), fs2);
 
197
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page), fs);
 
198
 
 
199
    QCOMPARE(bfl.m_pageStyles.count(), 2);
 
200
    QVERIFY(bfl.m_pageStyles.contains(page.pageStyle()));
 
201
    QVERIFY(bfl.m_pageStyles.contains(page2.pageStyle()));
 
202
    fsets = bfl.m_pageStyles[page.pageStyle()];
 
203
    QCOMPARE(fsets.oddHeaders, fs);
 
204
    QCOMPARE(fsets.evenHeaders, (void*) 0);
 
205
    QCOMPARE(fsets.oddFooters, (void*) 0);
 
206
    QCOMPARE(fsets.evenFooters, (void*) 0);
 
207
    KWFrameLayout::FrameSets fsets2 = bfl.m_pageStyles[page2.pageStyle()];
 
208
    QCOMPARE(fsets2.oddHeaders, fs2);
 
209
    QCOMPARE(fsets2.evenHeaders, (void*) 0);
 
210
    QCOMPARE(fsets2.oddFooters, (void*) 0);
 
211
    QCOMPARE(fsets2.evenFooters, (void*) 0);
 
212
}
 
213
 
 
214
void TestFrameLayout::testFrameCreation()
 
215
{
 
216
    Helper helper;
 
217
    m_frames.clear();
 
218
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
219
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
220
 
 
221
    KWPageStyle style = helper.pageManager->defaultPageStyle();
 
222
    style.setHeaderPolicy(KWord::HFTypeUniform);
 
223
    style.setHasMainTextFrame(true);
 
224
 
 
225
    bfl.createNewFramesForPage(1);
 
226
    QVERIFY(bfl.m_maintext != 0);
 
227
    QCOMPARE(bfl.m_maintext->frameCount(), 1);
 
228
 
 
229
    KWFrameLayout::FrameSets frameSets = bfl.m_pageStyles.value(style);
 
230
    QVERIFY(frameSets.oddHeaders != 0);
 
231
    QCOMPARE(frameSets.oddHeaders->frameCount(), 1);
 
232
    QVERIFY(frameSets.evenHeaders == 0);
 
233
    QVERIFY(frameSets.oddFooters == 0);
 
234
    QVERIFY(frameSets.evenFooters == 0);
 
235
 
 
236
    KoColumns columns = style.columns();
 
237
    columns.columns = 2;
 
238
    style.setColumns(columns);
 
239
 
 
240
    removeAllFrames();
 
241
    bfl.createNewFramesForPage(1);
 
242
    QCOMPARE(bfl.m_maintext->frameCount(), 2);
 
243
 
 
244
    frameSets = bfl.m_pageStyles.value(style);
 
245
    QVERIFY(frameSets.oddHeaders != 0);
 
246
    QCOMPARE(frameSets.oddHeaders->frameCount(), 1);
 
247
    QVERIFY(frameSets.evenHeaders == 0);
 
248
    QVERIFY(frameSets.oddFooters == 0);
 
249
    QVERIFY(frameSets.evenFooters == 0);
 
250
}
 
251
 
 
252
void TestFrameLayout::testCreateNewFrameForPage_data()
 
253
{
 
254
    // tests void KWFrameLayout::createNewFrameForPage(KWTextFrameSet *fs, int pageNumber)
 
255
    QTest::addColumn<QStringList>("pages");
 
256
    QTest::addColumn<int>("frameSetType");
 
257
    QTest::addColumn<int>("pageNumber");
 
258
    QTest::addColumn<int>("expectedFrameCount");
 
259
 
 
260
    QTest::newRow("noFooter1") << (QStringList() << QString("style1") << QString("style2")) <<
 
261
        (int) KWord::OddPagesFooterTextFrameSet << 1 << 0;
 
262
    QTest::newRow("noFooter2") << (QStringList() << QString("style1") << QString("style2")) <<
 
263
        (int) KWord::EvenPagesFooterTextFrameSet << 1 << 0;
 
264
    QTest::newRow("noFooter3") << (QStringList() << QString("style1") << QString("style2")) <<
 
265
        (int) KWord::EvenPagesFooterTextFrameSet << 2 << 0;
 
266
 
 
267
    QTest::newRow("noHeader1") << (QStringList() << QString("style1") << QString("style2")) <<
 
268
        (int) KWord::OddPagesHeaderTextFrameSet << 1 << 0;
 
269
    QTest::newRow("noHeader2") << (QStringList() << QString("style1") << QString("style2")) <<
 
270
        (int) KWord::OddPagesHeaderTextFrameSet << 2 << 0;
 
271
    QTest::newRow("noHeader3") << (QStringList() << QString("style1") << QString("style2")) <<
 
272
        (int) KWord::EvenPagesHeaderTextFrameSet << 1 << 0;
 
273
 
 
274
    QTest::newRow("oddHeader1") << (QStringList() << QString("style2") << QString("style2")) <<
 
275
        (int) KWord::OddPagesHeaderTextFrameSet << 1 << 1;
 
276
    QTest::newRow("oddHeader2") << (QStringList() << QString("style2") << QString("style2")) <<
 
277
        (int) KWord::OddPagesHeaderTextFrameSet << 2 << 0;
 
278
    QTest::newRow("evenHeader1") << (QStringList() << QString("style2") << QString("style2")) <<
 
279
        (int) KWord::EvenPagesHeaderTextFrameSet << 1 << 0;
 
280
    QTest::newRow("evenHeader2") << (QStringList() << QString("style2") << QString("style2")) <<
 
281
        (int) KWord::EvenPagesHeaderTextFrameSet << 2 << 1;
 
282
 
 
283
    QTest::newRow("main1") << (QStringList() << QString("style1") << QString("style3") << QString("style4")) <<
 
284
        (int) KWord::MainTextFrameSet << 1 << 1;
 
285
    QTest::newRow("main2") << (QStringList() << QString("style1") << QString("style3") << QString("style4")) <<
 
286
        (int) KWord::MainTextFrameSet << 2 << 0;
 
287
    QTest::newRow("main3") << (QStringList() << QString("style1") << QString("style3") << QString("style4")) <<
 
288
        (int) KWord::MainTextFrameSet << 3 << 2;
 
289
    QTest::newRow("main4") << (QStringList() << QString("style5")) <<
 
290
        (int) KWord::MainTextFrameSet << 1 << 0;
 
291
 
 
292
    QTest::newRow("footer1") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
293
        (int) KWord::EvenPagesFooterTextFrameSet << 1 << 0; // uniform goes to the odd
 
294
    QTest::newRow("footer2") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
295
        (int) KWord::EvenPagesFooterTextFrameSet << 2 << 0;
 
296
    QTest::newRow("footer3") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
297
        (int) KWord::EvenPagesFooterTextFrameSet << 3 << 0; // uniform goes to the odd
 
298
 
 
299
    QTest::newRow("footer4") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
300
        (int) KWord::OddPagesFooterTextFrameSet << 1 << 1;
 
301
    QTest::newRow("footer5") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
302
        (int) KWord::OddPagesFooterTextFrameSet << 2 << 0;
 
303
    QTest::newRow("footer6") << (QStringList() << QString("style3") << QString("style5") << QString("style2")) <<
 
304
        (int) KWord::OddPagesFooterTextFrameSet << 3 << 1;
 
305
}
 
306
 
 
307
void TestFrameLayout::testCreateNewFrameForPage()
 
308
{
 
309
    QFETCH(QStringList, pages);
 
310
    QFETCH(int, frameSetType);
 
311
    QFETCH(int, pageNumber);
 
312
    QFETCH(int, expectedFrameCount);
 
313
 
 
314
    QHash<QString, KWPageStyle> styles;
 
315
    KWPageStyle style1("style1");
 
316
    style1.setHeaderPolicy(KWord::HFTypeNone);
 
317
    style1.setHasMainTextFrame(true);
 
318
    style1.setFooterPolicy(KWord::HFTypeNone);
 
319
    styles.insert(style1.name(), style1);
 
320
 
 
321
    KWPageStyle style2("style2");
 
322
    style2.setHeaderPolicy(KWord::HFTypeEvenOdd);
 
323
    style2.setHasMainTextFrame(true);
 
324
    style2.setFooterPolicy(KWord::HFTypeUniform);
 
325
    styles.insert(style2.name(), style2);
 
326
 
 
327
    KWPageStyle style3("style3"); // weird
 
328
    style3.setHeaderPolicy(KWord::HFTypeEvenOdd);
 
329
    style3.setHasMainTextFrame(false);
 
330
    style3.setFooterPolicy(KWord::HFTypeUniform);
 
331
    styles.insert(style3.name(), style3);
 
332
 
 
333
    KWPageStyle style4("style4");
 
334
    style4.setHeaderPolicy(KWord::HFTypeUniform);
 
335
    style4.setHasMainTextFrame(true);
 
336
    style4.setFooterPolicy(KWord::HFTypeEvenOdd);
 
337
    KoColumns columns;
 
338
    columns.columns = 2;
 
339
    columns.columnSpacing = 4;
 
340
    style4.setColumns(columns);
 
341
    styles.insert(style4.name(), style4);
 
342
 
 
343
    KWPageStyle style5("style5"); // blank
 
344
    style5.setHeaderPolicy(KWord::HFTypeNone);
 
345
    style5.setHasMainTextFrame(false);
 
346
    style5.setFooterPolicy(KWord::HFTypeNone);
 
347
    style5.setColumns(columns);
 
348
    styles.insert(style5.name(), style5);
 
349
 
 
350
    KWPageManager manager;
 
351
    foreach (const QString &styleName, pages) {
 
352
        QVERIFY(styles.contains(styleName));
 
353
        manager.appendPage(styles[styleName]);
 
354
    }
 
355
 
 
356
    m_frames.clear();
 
357
    KWTextFrameSet tfs(0, (KWord::TextFrameSetType) frameSetType);
 
358
    m_frames << &tfs;
 
359
    KWFrameLayout frameLayout(&manager, m_frames);
 
360
    connect(&frameLayout, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
361
 
 
362
    KWPage page = manager.page(pageNumber);
 
363
    QVERIFY(page.isValid());
 
364
    tfs.setPageStyle(page.pageStyle());
 
365
 
 
366
    frameLayout.createNewFramesForPage(pageNumber);
 
367
    QCOMPARE(tfs.frameCount(), expectedFrameCount);
 
368
    foreach(KWFrame *frame, tfs.frames()) {
 
369
        QVERIFY (page.rect().contains(frame->shape()->position()));
 
370
    }
 
371
}
 
372
 
 
373
void TestFrameLayout::testCopyFramesForPage()
 
374
{
 
375
    Helper helper;
 
376
    m_frames.clear();
 
377
    KWPage page = helper.pageManager->begin();
 
378
 
 
379
    // copyShape
 
380
    MockShape *copyShape = new MockShape();
 
381
    copyShape->setPosition(QPointF(9, 13));
 
382
    KWFrameSet *copyShapeFrameSet = new KWFrameSet();
 
383
    KWFrame *frame = new KWFrame(copyShape, copyShapeFrameSet);
 
384
    frame->setNewFrameBehavior(KWord::CopyNewFrame);
 
385
    m_frames << copyShapeFrameSet;
 
386
 
 
387
    // copyShapeOdd
 
388
    MockShape *copyShapeOdd = new MockShape();
 
389
    copyShapeOdd->setPosition(QPointF(7, 12));
 
390
    KWFrameSet *copyShapeOddFrameSet = new KWFrameSet();
 
391
    frame = new KWFrame(copyShapeOdd, copyShapeOddFrameSet);
 
392
    frame->setNewFrameBehavior(KWord::CopyNewFrame);
 
393
    frame->setFrameOnBothSheets(false);
 
394
    m_frames << copyShapeOddFrameSet;
 
395
 
 
396
    // textshapePlain
 
397
    MockTextShape *textshapePlain = new MockTextShape();
 
398
    textshapePlain->setPosition(QPointF(11, 15));
 
399
    KWTextFrameSet *textshapePlainFS = new KWTextFrameSet(0, KWord::OtherTextFrameSet);
 
400
    KWTextFrame *tFrame = new KWTextFrame(textshapePlain, textshapePlainFS);
 
401
    tFrame->setNewFrameBehavior(KWord::ReconnectNewFrame);
 
402
    m_frames << textshapePlainFS;
 
403
 
 
404
    // textShapeRotated
 
405
    MockTextShape *textShapeRotated = new MockTextShape();
 
406
    textShapeRotated->setPosition(QPointF(13, 107));
 
407
    KWTextFrameSet *textshapeRotFS = new KWTextFrameSet(0, KWord::OtherTextFrameSet);
 
408
    tFrame = new KWTextFrame(textShapeRotated, textshapeRotFS);
 
409
    tFrame->setNewFrameBehavior(KWord::ReconnectNewFrame);
 
410
    tFrame->shape()->rotate(90);
 
411
    m_frames << textshapeRotFS;
 
412
 
 
413
    // textShapeGeometryProtected
 
414
    MockTextShape *textShapeGeometryProtected = new MockTextShape();
 
415
    textShapeGeometryProtected->setPosition(QPointF(3, 14));
 
416
    KWTextFrameSet *textshapeGeometryProtectedFS = new KWTextFrameSet(0, KWord::OtherTextFrameSet);
 
417
    tFrame = new KWTextFrame(textShapeGeometryProtected, textshapeGeometryProtectedFS);
 
418
    tFrame->setNewFrameBehavior(KWord::ReconnectNewFrame);
 
419
    tFrame->shape()->setGeometryProtected(true);
 
420
    m_frames << textshapeGeometryProtectedFS;
 
421
 
 
422
    // textShapeContentProtected
 
423
    MockTextShape *textShapeContentProtected = new MockTextShape();
 
424
    textShapeContentProtected->setPosition(QPointF(19, 23));
 
425
    KWTextFrameSet *textshapeContentProtectedFS = new KWTextFrameSet(0, KWord::OtherTextFrameSet);
 
426
    tFrame = new KWTextFrame(textShapeContentProtected, textshapeContentProtectedFS);
 
427
    tFrame->setNewFrameBehavior(KWord::ReconnectNewFrame);
 
428
    tFrame->shape()->setContentProtected(true);
 
429
    m_frames << textshapeContentProtectedFS;
 
430
 
 
431
    // textShapeUnselectable
 
432
    MockTextShape *textShapeUnselectable = new MockTextShape();
 
433
    textShapeUnselectable->setPosition(QPointF(7, 24));
 
434
    KWTextFrameSet *textshapeUnselectableFS = new KWTextFrameSet(0, KWord::OtherTextFrameSet);
 
435
    tFrame = new KWTextFrame(textShapeUnselectable, textshapeUnselectableFS);
 
436
    tFrame->setNewFrameBehavior(KWord::ReconnectNewFrame);
 
437
    tFrame->shape()->setSelectable(false);
 
438
    m_frames << textshapeUnselectableFS;
 
439
 
 
440
    // layouter
 
441
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
442
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
443
    // new page
 
444
    KWPage page2 = helper.pageManager->appendPage();
 
445
    bfl.createNewFramesForPage(page2.pageNumber());
 
446
 
 
447
    QCOMPARE(copyShapeFrameSet->frameCount(), 2);
 
448
    KWCopyShape *copy = dynamic_cast<KWCopyShape*>(copyShapeFrameSet->frames()[1]->shape());
 
449
    QVERIFY(copy);
 
450
    QCOMPARE(copy->position().x(), 9.);
 
451
    QCOMPARE(copy->position().y(), 13. + page2.offsetInDocument());
 
452
 
 
453
    // copyShapeOddFrameSet is not copied
 
454
    QCOMPARE(copyShapeOddFrameSet->frameCount(), 1);
 
455
 
 
456
    // textshapePlain
 
457
    QCOMPARE(textshapePlainFS->frameCount(), 2);
 
458
    QVERIFY(!textshapePlainFS->frames()[1]->isCopy());
 
459
    KoShape *shape = textshapePlainFS->frames()[1]->shape();
 
460
    QCOMPARE(shape->position().x(), 11.);
 
461
    QCOMPARE(shape->position().y(), 15. + page2.offsetInDocument());
 
462
    // TODO test sizing
 
463
 
 
464
    // textShapeRotated
 
465
    QCOMPARE(textshapeRotFS->frameCount(), 2);
 
466
    QVERIFY(!textshapeRotFS->frames()[1]->isCopy());
 
467
    shape = textshapeRotFS->frames()[1]->shape();
 
468
    QCOMPARE(shape->position().x(), 13.);
 
469
    QCOMPARE(shape->position().y(), 107. + page2.offsetInDocument());
 
470
    QCOMPARE(shape->absolutePosition(KoFlake::TopRightCorner), QPointF(13 + 50, 107 + 50
 
471
        + page2.offsetInDocument())); // 90° around center moves the top-right down
 
472
 
 
473
    // textShapeGeometryProtected
 
474
    QCOMPARE(textshapeGeometryProtectedFS->frameCount(), 2);
 
475
    QVERIFY(!textshapeGeometryProtectedFS->frames()[1]->isCopy());
 
476
    shape = textshapeGeometryProtectedFS->frames()[1]->shape();
 
477
    QCOMPARE(shape->position().x(), 3.);
 
478
    QCOMPARE(shape->position().y(), 14. + page2.offsetInDocument());
 
479
    QCOMPARE(shape->isGeometryProtected(), true);
 
480
    QCOMPARE(shape->isContentProtected(), false);
 
481
    QCOMPARE(shape->isSelectable(), true);
 
482
 
 
483
    // textShapeContentProtected
 
484
    QCOMPARE(textshapeContentProtectedFS->frameCount(), 2);
 
485
    QVERIFY(!textshapeContentProtectedFS->frames()[1]->isCopy());
 
486
    shape = textshapeContentProtectedFS->frames()[1]->shape();
 
487
    QCOMPARE(shape->isGeometryProtected(), false);
 
488
    QCOMPARE(shape->isContentProtected(), true);
 
489
    QCOMPARE(shape->isSelectable(), true);
 
490
 
 
491
    // textShapeUnselectable
 
492
    QCOMPARE(textshapeUnselectableFS->frameCount(), 2);
 
493
    QVERIFY(!textshapeUnselectableFS->frames()[1]->isCopy());
 
494
    shape = textshapeUnselectableFS->frames()[1]->shape();
 
495
    QCOMPARE(shape->isGeometryProtected(), false);
 
496
    QCOMPARE(shape->isContentProtected(), false);
 
497
    QCOMPARE(shape->isSelectable(), false);
 
498
}
 
499
 
 
500
void TestFrameLayout::testLargeHeaders()
 
501
{
 
502
    // create a header with waaaaaaay to much text and do one page layout.
 
503
    // Check if the header has been trunkated and no new page has been requested.
 
504
    Helper helper;
 
505
    m_frames.clear();
 
506
    KWPage page = helper.pageManager->begin();
 
507
    helper.pageStyle.setHeaderPolicy(KWord::HFTypeUniform);
 
508
 
 
509
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
510
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
511
 
 
512
    KWTextFrameSet *fs = bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page);
 
513
    QVERIFY(fs);
 
514
    QCOMPARE(fs->frameCount(), 0);
 
515
    bfl.createNewFramesForPage(page.pageNumber());
 
516
    QCOMPARE(fs->frameCount(), 1);
 
517
 
 
518
    // now we have to make sure the header looks pretty full
 
519
    KWTextFrame *tf = dynamic_cast<KWTextFrame*>(fs->frames().at(0));
 
520
    QVERIFY(tf);
 
521
    tf->setMinimumFrameHeight(300);
 
522
    bfl.layoutFramesOnPage(page.pageNumber());
 
523
    QCOMPARE(fs->frameCount(), 1);
 
524
 
 
525
    KoShape *shape = fs->frames()[0]->shape();
 
526
    QVERIFY(shape->size().width() <= 200);
 
527
    // the header can never be bigger than a page.
 
528
    QVERIFY(shape->size().height() < 180);
 
529
 
 
530
    // the header can never force the main text fs to get too small
 
531
    KWTextFrameSet *mfs = bfl.getOrCreate(KWord::MainTextFrameSet, page);
 
532
    QVERIFY(mfs);
 
533
    QCOMPARE(mfs->frameCount(), 1);
 
534
    shape = mfs->frames()[0]->shape();
 
535
    QVERIFY(shape->size().height() >= 10);
 
536
}
 
537
 
 
538
void TestFrameLayout::testLayoutPageSpread()
 
539
{
 
540
    Helper helper;
 
541
    m_frames.clear();
 
542
 
 
543
    //set up as a page spread;
 
544
    KoPageLayout pageLayout = helper.pageStyle.pageLayout();
 
545
    pageLayout.leftMargin = -1;
 
546
    pageLayout.rightMargin = -1;
 
547
    pageLayout.pageEdge = 20;
 
548
    pageLayout.bindingSide = 25;
 
549
    pageLayout.topMargin = 21;
 
550
    pageLayout.bottomMargin = 22;
 
551
    helper.pageStyle.setPageLayout(pageLayout);
 
552
 
 
553
    KWPage spread = helper.pageManager->appendPage();
 
554
    QCOMPARE(spread.pageSide(), KWPage::PageSpread);
 
555
    QCOMPARE(spread.pageNumber(), 2);
 
556
 
 
557
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
558
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
559
 
 
560
    bfl.createNewFramesForPage(spread.pageNumber());
 
561
    KWTextFrameSet *fs = bfl.getOrCreate(KWord::MainTextFrameSet, spread);
 
562
    QCOMPARE(fs->frameCount(), 2);
 
563
    bfl.layoutFramesOnPage(spread.pageNumber());
 
564
    QCOMPARE(fs->frames()[0]->shape()->position(), QPointF(20, 221)); // left
 
565
    QCOMPARE(fs->frames()[0]->shape()->size(), QSizeF(155, 157));
 
566
    QCOMPARE(fs->frames()[1]->shape()->position(), QPointF(225, 221)); // right
 
567
    QCOMPARE(fs->frames()[1]->shape()->size(), QSizeF(155, 157));
 
568
}
 
569
 
 
570
void TestFrameLayout::testPageStyle()
 
571
{
 
572
    // on different page styles i want different framesets.
 
573
    // changing a page (in a sequence) to get a different style should
 
574
    // thus delete all auto-generated frames on that page and force
 
575
    // new ones to be created.
 
576
 
 
577
    Helper helper;
 
578
    m_frames.clear();
 
579
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
580
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
581
 
 
582
    KWPage page1 = helper.pageManager->page(1);
 
583
    page1.pageStyle().setHeaderPolicy(KWord::HFTypeUniform);
 
584
 
 
585
    KWPageStyle style2 = page1.pageStyle();
 
586
    style2.detach("Style2"); // make it a copy of first style, but with new name
 
587
    helper.pageManager->addPageStyle(style2);
 
588
    KWPage page2 = helper.pageManager->appendPage();
 
589
    QCOMPARE(page1.pageStyle(), page2.pageStyle());
 
590
    KWPage page3 = helper.pageManager->appendPage(style2);
 
591
    QCOMPARE(page3.pageStyle(), style2);
 
592
    KWPage page4 = helper.pageManager->appendPage();
 
593
    QCOMPARE(page1.pageStyle(), page2.pageStyle());
 
594
    QCOMPARE(page3.pageStyle(), style2);
 
595
    QCOMPARE(page4.pageStyle(), style2);
 
596
 
 
597
    bfl.createNewFramesForPage(1);
 
598
    // mainFs is special; there is only one across all page styles
 
599
    QVERIFY(bfl.m_maintext);
 
600
    KWTextFrameSet *mainFs = bfl.getOrCreate(KWord::MainTextFrameSet, page1);
 
601
    QCOMPARE(bfl.m_maintext, mainFs);
 
602
    bfl.createNewFramesForPage(2);
 
603
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page2), mainFs);
 
604
    QVERIFY(!bfl.m_pageStyles.contains(style2));
 
605
    bfl.createNewFramesForPage(3);
 
606
    QVERIFY(bfl.m_pageStyles.contains(style2));
 
607
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page3), mainFs);
 
608
    bfl.createNewFramesForPage(4);
 
609
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page1), mainFs);
 
610
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page2), mainFs);
 
611
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page3), mainFs);
 
612
    QCOMPARE(bfl.getOrCreate(KWord::MainTextFrameSet, page4), mainFs);
 
613
 
 
614
    KWFrameLayout::FrameSets fsets1 = bfl.m_pageStyles.value(page1.pageStyle());
 
615
    KWFrameLayout::FrameSets fsets2 = bfl.m_pageStyles.value(style2);
 
616
    QVERIFY(fsets1.oddHeaders);
 
617
    QVERIFY(fsets2.oddHeaders);
 
618
    QVERIFY(fsets1.oddHeaders != fsets2.oddHeaders);
 
619
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page1), fsets1.oddHeaders);
 
620
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page2), fsets1.oddHeaders);
 
621
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page3), fsets2.oddHeaders);
 
622
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page4), fsets2.oddHeaders);
 
623
    QCOMPARE(fsets1.oddHeaders->frameCount(), 2);
 
624
    QCOMPARE(fsets2.oddHeaders->frameCount(), 2);
 
625
 
 
626
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 1));
 
627
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 2));
 
628
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 3) == 0);
 
629
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 4) == 0);
 
630
 
 
631
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 1) == 0);
 
632
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 2) == 0);
 
633
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 3));
 
634
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 4));
 
635
 
 
636
    // now we change one and check if the frame moved
 
637
    page2.setPageStyle(style2);
 
638
    bfl.createNewFramesForPage(2);
 
639
 
 
640
    fsets1 = bfl.m_pageStyles.value(page1.pageStyle());
 
641
    fsets2 = bfl.m_pageStyles.value(style2);
 
642
    QVERIFY(fsets1.oddHeaders);
 
643
    QVERIFY(fsets2.oddHeaders);
 
644
    QVERIFY(fsets1.oddHeaders != fsets2.oddHeaders);
 
645
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 1));
 
646
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 2) == 0);
 
647
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 3) == 0);
 
648
    QVERIFY(bfl.frameOn(fsets1.oddHeaders, 4) == 0);
 
649
 
 
650
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 1) == 0);
 
651
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 2));
 
652
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 3));
 
653
    QVERIFY(bfl.frameOn(fsets2.oddHeaders, 4));
 
654
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page1), fsets1.oddHeaders);
 
655
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page2), fsets2.oddHeaders);
 
656
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page3), fsets2.oddHeaders);
 
657
    QCOMPARE(bfl.getOrCreate(KWord::OddPagesHeaderTextFrameSet, page4), fsets2.oddHeaders);
 
658
    QCOMPARE(fsets1.oddHeaders->frameCount(), 1);
 
659
    QCOMPARE(fsets2.oddHeaders->frameCount(), 3);
 
660
}
 
661
 
 
662
void TestFrameLayout::testPageBackground()
 
663
{
 
664
    // creating a page with a pagestyle that has a background set should
 
665
    // trigger the creation of a shape that draws the page-background.
 
666
    // If there is no background or its removed (in a command) that should
 
667
    // remove the frame.
 
668
    Helper helper;
 
669
    m_frames.clear();
 
670
    KWFrameLayout bfl(helper.pageManager, m_frames);
 
671
    connect(&bfl, SIGNAL(newFrameSet(KWFrameSet*)), this, SLOT(addFS(KWFrameSet*)));
 
672
 
 
673
    KWPage page1 = helper.pageManager->page(1);
 
674
    page1.pageStyle().setBackground(new KoColorBackground(Qt::red));
 
675
 
 
676
    KWPageStyle style2("No Background");
 
677
    helper.pageManager->addPageStyle(style2);
 
678
    KWPage page2 = helper.pageManager->appendPage();
 
679
    KWPage page3 = helper.pageManager->appendPage(style2);
 
680
    KWPage page4 = helper.pageManager->appendPage();
 
681
 
 
682
    QVERIFY(bfl.m_backgroundFrameSet == 0);
 
683
    bfl.createNewFramesForPage(1);
 
684
    QVERIFY(bfl.m_backgroundFrameSet);
 
685
    QCOMPARE(bfl.m_backgroundFrameSet->frameCount(), 1);
 
686
    bfl.createNewFramesForPage(2);
 
687
    QCOMPARE(bfl.m_backgroundFrameSet->frameCount(), 2);
 
688
    bfl.createNewFramesForPage(3);
 
689
    QVERIFY(bfl.m_backgroundFrameSet);
 
690
    QCOMPARE(bfl.m_backgroundFrameSet->frameCount(), 2);
 
691
    bfl.createNewFramesForPage(4);
 
692
    QCOMPARE(bfl.m_backgroundFrameSet->frameCount(), 2);
 
693
 
 
694
    KWFrameSet *bfs = bfl.m_backgroundFrameSet;
 
695
    foreach (KWFrame *frame, bfs->frames()) {
 
696
        QCOMPARE(frame->shape()->background(), page1.pageStyle().background());
 
697
    }
 
698
 
 
699
    // run layout to position and size them.
 
700
    for (int i = 1; i <= 4; ++i)
 
701
        bfl.layoutFramesOnPage(i);
 
702
 
 
703
    QCOMPARE(bfs->frames()[0]->shape()->size(), QSizeF(page1.width(), page1.height()));
 
704
    QCOMPARE(bfs->frames()[0]->shape()->position(), QPointF());
 
705
    QCOMPARE(bfs->frames()[1]->shape()->size(), QSizeF(page2.width(), page2.height()));
 
706
    QCOMPARE(bfs->frames()[1]->shape()->position(), QPointF(0, page2.offsetInDocument()));
 
707
}
 
708
 
 
709
 
 
710
// helper method (slot)
 
711
void TestFrameLayout::addFS(KWFrameSet*fs)
 
712
{
 
713
    m_frames.append(fs);
 
714
}
 
715
 
 
716
void TestFrameLayout::removeAllFrames()
 
717
{
 
718
    foreach (KWFrameSet *fs, m_frames) {
 
719
        foreach (KWFrame *frame, fs->frames()) {
 
720
            fs->removeFrame(frame);
 
721
            delete frame->shape();
 
722
        }
 
723
    }
 
724
}
 
725
 
 
726
QTEST_KDEMAIN(TestFrameLayout, GUI)
 
727
 
 
728
#include <TestFrameLayout.moc>