Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*************************************************************************
3 : *
4 : * The Contents of this file are made available subject to the terms of
5 : * either of the following licenses
6 : *
7 : * - GNU Lesser General Public License Version 2.1
8 : * - Sun Industry Standards Source License Version 1.1
9 : *
10 : * Sun Microsystems Inc., October, 2000
11 : *
12 : * GNU Lesser General Public License Version 2.1
13 : * =============================================
14 : * Copyright 2000 by Sun Microsystems, Inc.
15 : * 901 San Antonio Road, Palo Alto, CA 94303, USA
16 : *
17 : * This library is free software; you can redistribute it and/or
18 : * modify it under the terms of the GNU Lesser General Public
19 : * License version 2.1, as published by the Free Software Foundation.
20 : *
21 : * This library is distributed in the hope that it will be useful,
22 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 : * Lesser General Public License for more details.
25 : *
26 : * You should have received a copy of the GNU Lesser General Public
27 : * License along with this library; if not, write to the Free Software
28 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 : * MA 02111-1307 USA
30 : *
31 : *
32 : * Sun Industry Standards Source License Version 1.1
33 : * =================================================
34 : * The contents of this file are subject to the Sun Industry Standards
35 : * Source License Version 1.1 (the "License"); You may not use this file
36 : * except in compliance with the License. You may obtain a copy of the
37 : * License at http://www.openoffice.org/license.html.
38 : *
39 : * Software provided under this License is provided on an "AS IS" basis,
40 : * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
41 : * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
42 : * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
43 : * See the License for the specific provisions governing your rights and
44 : * obligations concerning the Software.
45 : *
46 : * The Initial Developer of the Original Code is: IBM Corporation
47 : *
48 : * Copyright: 2008 by IBM Corporation
49 : *
50 : * All Rights Reserved.
51 : *
52 : * Contributor(s): _______________________________________
53 : *
54 : *
55 : ************************************************************************/
56 : /*************************************************************************
57 : * @file
58 : * For LWP filter architecture prototype
59 : ************************************************************************/
60 : /*************************************************************************
61 : * Change History
62 : Jan 2005 Created
63 : Feb 2005 Process gemotry, margins
64 : ************************************************************************/
65 :
66 : #include "lwplayout.hxx"
67 : #include "lwpusewhen.hxx"
68 : #include "lwptools.hxx"
69 : #include "xfilter/xfcolumns.hxx"
70 : #include "lwpstory.hxx"
71 : #include "lwpparastyle.hxx"
72 : #include "lwpholder.hxx"
73 : #include "lwpdoc.hxx"
74 : #include "lwppagehint.hxx"
75 : #include "lwpdivinfo.hxx"
76 : #include "lwpgrfobj.hxx"
77 : #include <osl/thread.h>
78 :
79 133 : LwpVirtualLayout::LwpVirtualLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
80 : : LwpDLNFPVList(objHdr, pStrm)
81 : , m_nAttributes(0)
82 : , m_nAttributes2(0)
83 : , m_nAttributes3(0)
84 : , m_nOverrideFlag(0)
85 : , m_nDirection(0)
86 133 : , m_nEditorID(0)
87 : {
88 133 : }
89 :
90 133 : void LwpVirtualLayout::Read()
91 : {
92 133 : LwpDLNFPVList::Read();
93 :
94 133 : LwpObjectStream* pStrm = m_pObjStrm;
95 133 : m_nAttributes = pStrm->QuickReaduInt32();
96 133 : m_nAttributes2 = pStrm->QuickReaduInt32();
97 133 : m_nAttributes3 = pStrm->QuickReaduInt32();
98 133 : m_nOverrideFlag = pStrm->QuickReaduInt32();
99 133 : m_nDirection = pStrm->QuickReaduInt16();
100 :
101 : //Note that two bytes is read into m_nEditorID instead of one byte.
102 133 : m_nEditorID = pStrm->QuickReaduInt16();
103 :
104 133 : m_NextEnumerated.ReadIndexed(pStrm);
105 133 : m_PreviousEnumerated.ReadIndexed(pStrm);
106 :
107 133 : pStrm->SkipExtra();
108 133 : }
109 :
110 1005 : bool LwpVirtualLayout::MarginsSameAsParent()
111 : {
112 1005 : return (m_nAttributes2 & STYLE2_MARGINSSAMEASPARENT) != 0;
113 : }
114 :
115 : /**
116 : * @descr: Get column width
117 : *
118 : */
119 0 : double LwpVirtualLayout::GetColWidth(sal_uInt16 /*nIndex*/)
120 : {
121 : //return GetContentWidth(); //not support now
122 : //return LwpTools::ConvertToMetric(5); //test
123 0 : return 0; //test
124 : }
125 :
126 : /**
127 : * @descr: Get the gap between columns
128 : *
129 : */
130 0 : double LwpVirtualLayout::GetColGap(sal_uInt16 /*nIndex*/)
131 : {
132 : //return DEFAULTGAPSIZE;
133 : //return LwpTools::ConvertToMetric(0.17);//DEFAULTGAPSIZE=0.17
134 0 : return LwpTools::ConvertToMetric(0.17);
135 : }
136 :
137 : /**
138 : * @descr: Whether it is honoring protection
139 : *
140 : */
141 111 : bool LwpVirtualLayout::HonorProtection()
142 : {
143 111 : if(!(m_nAttributes2 & STYLE2_HONORPROTECTION))
144 0 : return false;
145 :
146 111 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
147 111 : if(pParent && !pParent->IsHeader())
148 : {
149 0 : return pParent->HonorProtection();
150 : }
151 :
152 111 : if(m_pFoundry)//is null now
153 : {
154 109 : LwpDocument* pDoc = m_pFoundry->GetDocument();
155 : /*if(pDoc)
156 : {
157 : return pDoc->HonorProtection();
158 : }*/
159 109 : if(pDoc && pDoc->GetRootDocument())
160 109 : return pDoc->GetRootDocument()->HonorProtection();
161 : }
162 :
163 2 : return true;
164 : }
165 :
166 : /**
167 : * @descr: Whether it is protected
168 : *
169 : */
170 111 : bool LwpVirtualLayout::IsProtected()
171 : {
172 111 : bool bProtected = (m_nAttributes & STYLE_PROTECTED)!=0;
173 :
174 111 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
175 111 : if(pParent && !pParent->IsHeader())
176 : {
177 0 : if(pParent->HonorProtection()&&(pParent->HasProtection()||bProtected))
178 : {
179 0 : return true;
180 : }
181 : }
182 111 : else if(m_pFoundry)//is null now
183 : {
184 109 : LwpDocument* pDoc = m_pFoundry->GetDocument();
185 109 : if(pDoc)
186 : {
187 109 : if (pDoc->HonorProtection() && bProtected)
188 : {
189 0 : return true;
190 : }
191 : }
192 : }
193 :
194 111 : return false;
195 : }
196 :
197 : /**
198 : * @descr: Whether it has protection
199 : *
200 : */
201 0 : bool LwpVirtualLayout::HasProtection()
202 : {
203 0 : if(m_nAttributes & STYLE_PROTECTED)
204 0 : return true;
205 :
206 0 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
207 0 : if(pParent && !pParent->IsHeader())
208 : {
209 0 : return pParent->HasProtection();
210 : }
211 :
212 0 : return false;
213 : }
214 :
215 : /**
216 : * @descr: Whether it is a mirror layout
217 : *
218 : */
219 12 : bool LwpVirtualLayout::IsComplex()
220 : {
221 12 : return (m_nAttributes & STYLE_COMPLEX) != 0;
222 : }
223 :
224 : /**
225 : * @descr: Get usewhen pointer
226 : *
227 : */
228 12 : LwpUseWhen* LwpVirtualLayout::GetUseWhen()
229 : {
230 : /*
231 : If we have a parent, and I'm not a page layout,
232 : use my parents information.
233 : */
234 12 : if(GetLayoutType()!=LWP_PAGE_LAYOUT)
235 : {
236 : //get parent
237 0 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
238 0 : if(pParent && !pParent->IsHeader()&& (pParent->GetLayoutType()!=LWP_PAGE_LAYOUT))
239 0 : return pParent->GetUseWhen();
240 :
241 : }
242 :
243 12 : return VirtualGetUseWhen();
244 : }
245 : /**
246 : * @descr: Whether this layout is page layout or not
247 : * @param:
248 : * @return:
249 : */
250 33 : bool LwpVirtualLayout::IsPage()
251 : {
252 33 : return (GetLayoutType() == LWP_PAGE_LAYOUT);
253 : }
254 : /**
255 : * @descr: Whether this layout is heaer layout or not
256 : * @param:
257 : * @return:
258 : */
259 152 : bool LwpVirtualLayout::IsHeader()
260 : {
261 152 : return (GetLayoutType() == LWP_HEADER_LAYOUT);
262 : }
263 : /**
264 : * @descr: Whether this layout is footer layout or not
265 : * @param:
266 : * @return:
267 : */
268 6 : bool LwpVirtualLayout::IsFooter()
269 : {
270 6 : return (GetLayoutType() == LWP_FOOTER_LAYOUT);
271 : }
272 : /**
273 : * @descr: Whether this layout is frame layout or not
274 : * @param:
275 : * @return:
276 : */
277 45 : bool LwpVirtualLayout::IsFrame()
278 : {
279 45 : return (GetLayoutType() == LWP_FRAME_LAYOUT);
280 : }
281 :
282 : /**
283 : * @descr: Whether this layout is cell layout or not
284 : * @param:
285 : * @return:
286 : */
287 279 : bool LwpVirtualLayout::IsCell()
288 : {
289 279 : return (GetLayoutType() == LWP_CELL_LAYOUT
290 278 : || GetLayoutType() == LWP_CONNECTED_CELL_LAYOUT
291 557 : || GetLayoutType() == LWP_HIDDEN_CELL_LAYOUT);
292 : }
293 : /**
294 : * @descr: Whether this layout is supertable layout or not
295 : * @param:
296 : * @return:
297 : */
298 6 : bool LwpVirtualLayout::IsSuperTable()
299 : {
300 6 : return (GetLayoutType() == LWP_SUPERTABLE_LAYOUT);
301 : }
302 : /**
303 : * @descr: Whether this layout is group layout or not
304 : * @param:
305 : * @return:
306 : */
307 25 : bool LwpVirtualLayout::IsGroupHead()
308 : {
309 25 : return (GetLayoutType() == LWP_GROUP_LAYOUT);
310 : }
311 : /**
312 : * @descr: get the relative type
313 : * @param:
314 : * @return:
315 : */
316 27 : sal_uInt8 LwpVirtualLayout::GetRelativeType()
317 : {
318 27 : return LwpLayoutRelativityGuts::LAY_PARENT_RELATIVE;
319 : }
320 : /**
321 : * @descr: whether it is relative anchored layout
322 : * @param:
323 : * @return:
324 : */
325 176 : bool LwpVirtualLayout::IsRelativeAnchored()
326 : {
327 : sal_uInt8 nType;
328 :
329 176 : nType = GetRelativeType();
330 123 : return (nType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE) || (nType == LwpLayoutRelativityGuts::LAY_INLINE)
331 299 : || (nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE) || (nType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL);
332 : }
333 : /**
334 : * @descr: whether it is MinimumHeight layout
335 : * @param:
336 : * @return:
337 : */
338 0 : bool LwpVirtualLayout::IsMinimumHeight()
339 : {
340 0 : return ((m_nAttributes3& STYLE3_MINHEIGHTVALID) != 0);
341 : }
342 :
343 : /**
344 : * @descr: Get parent layout
345 : *
346 : */
347 28 : LwpVirtualLayout* LwpVirtualLayout::GetParentLayout()
348 : {
349 28 : return dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
350 : }
351 :
352 : /**
353 : * @descr: Register child layout style
354 : *
355 : */
356 48 : void LwpVirtualLayout::RegisterChildStyle()
357 : {
358 : //Register all children styles
359 48 : LwpVirtualLayout* pLayout = dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get());
360 112 : while(pLayout)
361 : {
362 16 : pLayout->SetFoundry(m_pFoundry);
363 16 : pLayout->RegisterStyle();
364 16 : pLayout = dynamic_cast<LwpVirtualLayout*>(pLayout->GetNext().obj().get());
365 : }
366 48 : }
367 :
368 0 : bool LwpVirtualLayout::NoContentReference()
369 : {
370 0 : return (m_nAttributes2 & STYLE2_NOCONTENTREFERENCE) != 0;
371 : }
372 :
373 0 : bool LwpVirtualLayout::IsStyleLayout()
374 : {
375 0 : if (m_nAttributes3 & STYLE3_STYLELAYOUT)
376 0 : return true;
377 :
378 0 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*>(GetParent().obj().get());
379 0 : if (pParent)
380 0 : return pParent->IsStyleLayout();
381 0 : return false;
382 : }
383 :
384 : /**
385 : * @descr: Find child layout by layout type
386 : *
387 : */
388 0 : LwpVirtualLayout* LwpVirtualLayout::FindChildByType(LWP_LAYOUT_TYPE eType)
389 : {
390 0 : LwpObjectID& rID = GetChildHead();
391 :
392 0 : while(!rID.IsNull())
393 : {
394 0 : LwpVirtualLayout * pLayout = dynamic_cast<LwpVirtualLayout *>(rID.obj().get());
395 0 : if(!pLayout)
396 : {
397 0 : break;
398 : }
399 :
400 0 : if (pLayout && pLayout->GetLayoutType() == eType)
401 : {
402 0 : return pLayout;
403 : }
404 0 : rID = pLayout->GetNext();
405 : }
406 :
407 0 : return NULL;
408 : }
409 :
410 : /**
411 : * @descr: Whether the size of layout is fit the graphic
412 : *
413 : */
414 25 : bool LwpVirtualLayout::IsFitGraphic()
415 : {
416 25 : return IsAutoGrowRight() && !IsAutoGrowLeft() && IsAutoGrowDown();
417 : }
418 :
419 : /**
420 : * @descr: Whether the width of layout is auto grow
421 : *
422 : */
423 0 : bool LwpVirtualLayout::IsAutoGrowWidth()
424 : {
425 0 : return IsAutoGrowLeft() || IsAutoGrowRight();
426 : }
427 :
428 : /**
429 : * @descr: Determine whether the layout width is to margin
430 : *
431 : */
432 42 : bool LwpVirtualLayout::IsInlineToMargin()
433 : {
434 42 : return (m_nAttributes3 & STYLE3_INLINETOMARGIN) != 0;
435 : }
436 :
437 83 : void LwpAssociatedLayouts::Read(LwpObjectStream* pStrm)
438 : {
439 83 : m_OnlyLayout.ReadIndexed(pStrm);
440 83 : m_Layouts.Read(pStrm);
441 83 : pStrm->SkipExtra();
442 83 : }
443 :
444 : /**
445 : * @descr: Looking for the layout which follows the pStartLayout
446 : * @param: pStartLayout - the layout which is used for looking for its following layout
447 : */
448 462 : LwpVirtualLayout* LwpAssociatedLayouts::GetLayout(LwpVirtualLayout *pStartLayout)
449 : {
450 462 : if (!pStartLayout && !m_OnlyLayout.IsNull())
451 : /* Looking for the first layout and there's only one layout in the list.*/
452 375 : return dynamic_cast<LwpVirtualLayout*>(m_OnlyLayout.obj().get());
453 :
454 87 : LwpObjectHolder* pObjHolder = dynamic_cast<LwpObjectHolder*>(m_Layouts.GetHead().obj().get());
455 87 : if(pObjHolder)
456 : {
457 0 : LwpVirtualLayout* pLayout = dynamic_cast<LwpVirtualLayout*>(pObjHolder->GetObject().obj().get());
458 0 : if(!pStartLayout )
459 0 : return pLayout;
460 :
461 0 : while(pObjHolder && pStartLayout != pLayout)
462 : {
463 0 : pObjHolder = dynamic_cast<LwpObjectHolder*>(pObjHolder->GetNext().obj().get());
464 0 : if(pObjHolder)
465 : {
466 0 : pLayout = dynamic_cast<LwpVirtualLayout*>(pObjHolder->GetObject().obj().get());
467 : }
468 : }
469 :
470 0 : if(pObjHolder)
471 : {
472 0 : pObjHolder = dynamic_cast<LwpObjectHolder*>(pObjHolder->GetNext().obj().get());
473 0 : if(pObjHolder)
474 : {
475 0 : pLayout = dynamic_cast<LwpVirtualLayout*>(pObjHolder->GetObject().obj().get());
476 0 : return pLayout;
477 : }
478 : }
479 :
480 : //return pLayout;
481 : }
482 :
483 87 : return NULL;
484 : }
485 :
486 32 : LwpHeadLayout::LwpHeadLayout(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
487 32 : : LwpVirtualLayout(objHdr, pStrm)
488 32 : {}
489 :
490 32 : void LwpHeadLayout::Read()
491 : {
492 32 : LwpVirtualLayout::Read();
493 : //For PermissiveLayout
494 32 : m_pObjStrm->SkipExtra();
495 : //For me
496 32 : m_pObjStrm->SkipExtra();
497 32 : }
498 :
499 32 : void LwpHeadLayout::RegisterStyle()
500 : {
501 : //Register all children styles
502 32 : LwpVirtualLayout* pLayout = dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get());
503 136 : while(pLayout)
504 : {
505 72 : pLayout->SetFoundry(m_pFoundry);
506 : //if the layout is relative to para, the layout will be registered in para
507 72 : if(!pLayout->IsRelativeAnchored())
508 : {
509 35 : if (pLayout == this)
510 : {
511 : OSL_FAIL("Layout points to itself");
512 0 : break;
513 : }
514 35 : pLayout->RegisterStyle();
515 : }
516 72 : LwpVirtualLayout *pNext = dynamic_cast<LwpVirtualLayout*>(pLayout->GetNext().obj().get());
517 72 : if (pNext == pLayout)
518 : {
519 : OSL_FAIL("Layout points to itself");
520 0 : break;
521 : }
522 72 : pLayout = pNext;
523 : }
524 32 : }
525 :
526 : /**
527 : * @descr find endnote supertable layout from the child layout list. Suppose that there is only one endnote supertablelayout in one division
528 : * @return pointer to endnote supertable layout
529 : */
530 7 : LwpVirtualLayout* LwpHeadLayout::FindEnSuperTableLayout()
531 : {
532 7 : LwpVirtualLayout* pLayout = dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get());
533 61 : while(pLayout)
534 : {
535 47 : if(pLayout->GetLayoutType() == LWP_ENDNOTE_SUPERTABLE_LAYOUT)
536 : {
537 0 : return pLayout;
538 : }
539 47 : pLayout = dynamic_cast<LwpVirtualLayout*>(pLayout->GetNext().obj().get());
540 : }
541 7 : return NULL;
542 : }
543 :
544 95 : LwpLayoutStyle::LwpLayoutStyle()
545 : : m_nStyleDefinition(0)
546 95 : , m_pDescription(new LwpAtomHolder)
547 190 : , m_nKey(0)
548 : {
549 95 : }
550 :
551 190 : LwpLayoutStyle::~LwpLayoutStyle()
552 : {
553 95 : delete m_pDescription;
554 190 : }
555 :
556 28 : void LwpLayoutStyle::Read(LwpObjectStream* pStrm)
557 : {
558 28 : m_nStyleDefinition = pStrm->QuickReaduInt32();
559 28 : m_pDescription->Read(pStrm);
560 28 : if (pStrm->CheckExtra())
561 : {
562 21 : m_nKey = pStrm->QuickReaduInt16();
563 21 : pStrm->SkipExtra();
564 : }
565 28 : }
566 :
567 95 : LwpLayoutMisc::LwpLayoutMisc() :
568 : m_nGridDistance(0), m_nGridType(0),
569 95 : m_pContentStyle(new LwpAtomHolder)
570 : {
571 95 : }
572 :
573 190 : LwpLayoutMisc::~LwpLayoutMisc()
574 : {
575 95 : if (m_pContentStyle)
576 : {
577 95 : delete m_pContentStyle;
578 : }
579 190 : }
580 :
581 39 : void LwpLayoutMisc::Read(LwpObjectStream* pStrm)
582 : {
583 39 : m_nGridType = pStrm->QuickReaduInt16();
584 39 : m_nGridDistance = pStrm->QuickReadInt32();
585 39 : m_pContentStyle->Read(pStrm);
586 39 : pStrm->SkipExtra();
587 39 : }
588 :
589 95 : LwpMiddleLayout::LwpMiddleLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
590 : : LwpVirtualLayout(objHdr, pStrm),
591 95 : m_pStyleStuff(new LwpLayoutStyle), m_pMiscStuff(new LwpLayoutMisc)
592 95 : {}
593 :
594 190 : LwpMiddleLayout::~LwpMiddleLayout()
595 : {
596 95 : if (m_pStyleStuff)
597 : {
598 95 : delete m_pStyleStuff;
599 : }
600 95 : if (m_pMiscStuff)
601 : {
602 95 : delete m_pMiscStuff;
603 : }
604 95 : }
605 95 : void LwpMiddleLayout::Read()
606 : {
607 95 : LwpObjectStream* pStrm = m_pObjStrm;
608 :
609 95 : LwpVirtualLayout::Read();
610 :
611 : //skip CLiteLayout data;
612 95 : LwpAtomHolder ContentClass;
613 95 : ContentClass.Read(pStrm);
614 95 : pStrm->SkipExtra();
615 :
616 : // before layout hierarchy rework
617 95 : if(LwpFileHeader::m_nFileRevision < 0x000B)
618 95 : return;
619 :
620 95 : m_Content.ReadIndexed(pStrm);
621 :
622 : // 01/20/2005
623 95 : m_BasedOnStyle.ReadIndexed(pStrm);
624 95 : m_TabPiece.ReadIndexed(pStrm);
625 :
626 95 : sal_uInt8 nWhatsItGot = pStrm->QuickReaduInt8();
627 :
628 95 : if (nWhatsItGot & DISK_GOT_STYLE_STUFF)
629 : {
630 28 : m_pStyleStuff->Read(pStrm);
631 : }
632 95 : if (nWhatsItGot & DISK_GOT_MISC_STUFF)
633 : {
634 39 : m_pMiscStuff->Read(pStrm);
635 : }
636 :
637 95 : m_LayGeometry.ReadIndexed(pStrm);
638 95 : m_LayScale.ReadIndexed(pStrm);
639 95 : m_LayMargins.ReadIndexed(pStrm);
640 95 : m_LayBorderStuff.ReadIndexed(pStrm);
641 95 : m_LayBackgroundStuff.ReadIndexed(pStrm);
642 :
643 95 : if (pStrm->CheckExtra())
644 : {
645 79 : m_LayExtBorderStuff.ReadIndexed(pStrm);
646 79 : pStrm->SkipExtra();
647 95 : }
648 : //end
649 : }
650 :
651 : #include "lwplaypiece.hxx"
652 :
653 : /**
654 : * @descr: Get the geometry of current layout
655 : *
656 : */
657 308 : LwpLayoutGeometry* LwpMiddleLayout::GetGeometry()
658 : {
659 308 : if( !m_LayGeometry.IsNull() )
660 : {
661 239 : return ( dynamic_cast<LwpLayoutGeometry*> (m_LayGeometry.obj().get()) );
662 : }
663 69 : else if( !m_BasedOnStyle.IsNull() )
664 : {
665 69 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
666 69 : return pLay ? pLay->GetGeometry() : NULL;
667 : }
668 0 : return NULL;
669 : }
670 :
671 : /**
672 : * @descr: Get layout height, measured by "cm"
673 : *
674 : */
675 65 : double LwpMiddleLayout::GetGeometryHeight()
676 : {
677 65 : LwpLayoutGeometry* pGeo = GetGeometry();
678 65 : if(pGeo)
679 : {
680 65 : return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetHeight() ) );
681 : }
682 : else
683 0 : return -1;
684 : }
685 :
686 : /**
687 : * @descr: Get layout width, measured by "cm"
688 : *
689 : */
690 72 : double LwpMiddleLayout::GetGeometryWidth()
691 : {
692 72 : LwpLayoutGeometry* pGeo = GetGeometry();
693 72 : if(pGeo)
694 : {
695 72 : return ( LwpTools::ConvertFromUnitsToMetric( pGeo->GetWidth() ) );
696 : }
697 : else
698 0 : return -1;
699 : }
700 :
701 : /**
702 : * @descr: Whether the margins is same as parent layout
703 : *
704 : */
705 1005 : bool LwpMiddleLayout::MarginsSameAsParent()
706 : {
707 1005 : if(m_nOverrideFlag & OVER_MARGINS)
708 : {
709 640 : return LwpVirtualLayout::MarginsSameAsParent();
710 : }
711 365 : if(!m_BasedOnStyle.IsNull())
712 : {
713 355 : LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
714 355 : if (pLay)
715 355 : pLay->MarginsSameAsParent();
716 : }
717 365 : return LwpVirtualLayout::MarginsSameAsParent();
718 :
719 : }
720 :
721 : /**
722 : * @descr: Get margin
723 : * @param: nWhichSide - 0: left, 1: right, 2:top, 3: bottom
724 : */
725 1172 : double LwpMiddleLayout::GetMarginsValue(const sal_uInt8 &nWhichSide)
726 : {
727 1172 : double fValue = 0;
728 1172 : if((nWhichSide==MARGIN_LEFT)||(nWhichSide==MARGIN_RIGHT))
729 : {
730 650 : if ( MarginsSameAsParent() )
731 : {
732 34 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
733 34 : if(pParent && !pParent->IsHeader())
734 : {
735 34 : fValue = pParent->GetMarginsValue(nWhichSide);
736 34 : return fValue;
737 : }
738 : }
739 : }
740 :
741 1138 : if(m_nOverrideFlag & OVER_MARGINS)
742 : {
743 677 : LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*> (m_LayMargins.obj().get());
744 677 : if(pMar1)
745 : {
746 677 : fValue = pMar1->GetMargins().GetMarginsValue(nWhichSide);
747 677 : return fValue;
748 : }
749 : }
750 461 : LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
751 461 : if(pStyle)
752 : {
753 456 : fValue = pStyle->GetMarginsValue(nWhichSide);
754 456 : return fValue;
755 : }
756 5 : return LwpVirtualLayout::GetMarginsValue(nWhichSide);
757 : }
758 : /**
759 : * @descr: Get extmargin value
760 : * @param: nWhichSide - 0: left, 1: right, 2:top, 3: bottom
761 : * @param:
762 : * @return:
763 : */
764 384 : double LwpMiddleLayout::GetExtMarginsValue(const sal_uInt8 &nWhichSide)
765 : {
766 384 : double fValue = 0;
767 384 : if(m_nOverrideFlag & OVER_MARGINS)
768 : {
769 144 : LwpLayoutMargins* pMar1 = dynamic_cast<LwpLayoutMargins*> (m_LayMargins.obj().get());
770 144 : if(pMar1)
771 : {
772 144 : fValue = pMar1->GetExtMargins().GetMarginsValue(nWhichSide);
773 144 : return fValue;
774 : }
775 : }
776 240 : LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
777 240 : if(pStyle)
778 : {
779 240 : fValue = pStyle->GetExtMarginsValue(nWhichSide);
780 240 : return fValue;
781 : }
782 0 : return LwpVirtualLayout::GetExtMarginsValue(nWhichSide);
783 : }
784 : /**
785 : * @descr: Get the LwpBorderStuff object according to m_LayBorderStuff id.
786 : * @param:
787 : * @param:
788 : * @return:
789 : */
790 205 : LwpBorderStuff* LwpMiddleLayout::GetBorderStuff()
791 : {
792 205 : if(m_nOverrideFlag & OVER_BORDERS)
793 : {
794 124 : LwpLayoutBorder* pLayoutBorder = dynamic_cast<LwpLayoutBorder*>(m_LayBorderStuff.obj().get());
795 124 : return pLayoutBorder ? &pLayoutBorder->GetBorderStuff() : NULL;
796 : }
797 81 : else if( !m_BasedOnStyle.IsNull() )
798 : {
799 33 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
800 33 : return pLay ? pLay->GetBorderStuff() : NULL;
801 : }
802 48 : return NULL;
803 : }
804 :
805 : /**
806 : * @descr: Get LwpBackgroundStuff object according to m_LayBackgroundStuff id;
807 : * @param:
808 : * @param:
809 : * @return:
810 : */
811 320 : LwpBackgroundStuff* LwpMiddleLayout::GetBackgroundStuff()
812 : {
813 320 : if(m_nOverrideFlag & OVER_BACKGROUND)
814 : {
815 174 : LwpLayoutBackground* pLayoutBackground = dynamic_cast<LwpLayoutBackground*>(m_LayBackgroundStuff.obj().get());
816 174 : return pLayoutBackground ? &pLayoutBackground->GetBackgoudStuff() : NULL;
817 : }
818 146 : else if( !m_BasedOnStyle.IsNull() )
819 : {
820 146 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
821 146 : return pLay ? pLay->GetBackgroundStuff() : NULL;
822 : }
823 0 : return NULL;
824 : }
825 : /**
826 : * @descr: create xfborder.
827 : * @param:
828 : * @param:
829 : * @return:
830 : */
831 172 : XFBorders* LwpMiddleLayout::GetXFBorders()
832 : {
833 172 : LwpBorderStuff* pBorderStuff = GetBorderStuff();
834 172 : if(pBorderStuff&&pBorderStuff->GetSide() != 0)
835 : {
836 : //copy from lwpparastyle.
837 83 : XFBorders *pXFBorders = new XFBorders();
838 : // apply 4 borders respectively
839 : LwpBorderStuff::BorderType pType[] = { LwpBorderStuff::LEFT, LwpBorderStuff::RIGHT,
840 83 : LwpBorderStuff::TOP, LwpBorderStuff::BOTTOM };
841 :
842 415 : for (sal_uInt8 nC = 0; nC < 4; nC++)
843 : {
844 332 : if (pBorderStuff->HasSide(pType[nC]))
845 : {
846 332 : LwpParaStyle::ApplySubBorder(pBorderStuff, pType[nC], pXFBorders);
847 : }
848 : }
849 83 : return pXFBorders;
850 : }
851 89 : return NULL;
852 : }
853 :
854 : /**
855 : * @descr: Get text direction settings.
856 : * @param:
857 : * @param:
858 : * @return:
859 : */
860 33 : enumXFTextDir LwpMiddleLayout::GetTextDirection()
861 : {
862 33 : enumXFTextDir eTextDir = enumXFTextDirNone;
863 33 : sal_uInt8 nDirection = GetContentOrientation();
864 33 : switch(nDirection)
865 : {
866 : case TEXT_ORIENT_LRTB:
867 : {
868 33 : eTextDir = enumXFTextDirLR_TB;
869 33 : break;
870 : }
871 : case TEXT_ORIENT_TBRL:
872 : {
873 0 : eTextDir = enumXFTextDirTB_RL;
874 0 : break;
875 : }
876 : case TEXT_ORIENT_RLBT: // not supported now
877 : {
878 0 : eTextDir = enumXFTextDirNone;
879 0 : break;
880 : }
881 : case TEXT_ORIENT_BTLR: // not supported now
882 : {
883 0 : eTextDir = enumXFTextDirNone;
884 0 : break;
885 : }
886 : default:
887 0 : break;
888 : }
889 33 : return eTextDir;
890 : }
891 : /**
892 : * @descr: Get back ground color.
893 : * @param:
894 : * @param:
895 : * @return:
896 : */
897 124 : LwpColor* LwpMiddleLayout::GetBackColor()
898 : {
899 124 : LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
900 124 : if(pBackgroundStuff && !pBackgroundStuff->IsTransparent())
901 : {
902 35 : LwpColor* pColor = pBackgroundStuff->GetFillColor();
903 35 : if(pColor->IsValidColor())
904 : {
905 35 : return pColor;
906 : }
907 : }
908 89 : return NULL;
909 : }
910 :
911 : /**
912 : * @descr: Add back color settings into xfpagemaster.
913 : * @param:
914 : * @param:
915 : * @return:
916 : */
917 25 : LwpTabOverride* LwpMiddleLayout::GetTabOverride()
918 : {
919 25 : if(m_nAttributes & OVER_TABS)
920 : {
921 25 : if(!m_TabPiece.IsNull())
922 : {
923 5 : LwpTabPiece *pPiece = dynamic_cast<LwpTabPiece*>(m_TabPiece.obj().get());
924 5 : return static_cast<LwpTabOverride*>(pPiece ? pPiece->GetOverride() : NULL);
925 : }
926 20 : return NULL;
927 : }
928 0 : else if( !m_BasedOnStyle.IsNull() )
929 : {
930 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
931 0 : return pLay ? pLay->GetTabOverride() : NULL;
932 : }
933 0 : return NULL;
934 : }
935 :
936 : /**
937 : * @descr: Layscale for graphic & watermark
938 : * @param:
939 : * @param:
940 : * @return:
941 : */
942 0 : sal_uInt16 LwpMiddleLayout::GetScaleMode()
943 : {
944 0 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
945 0 : return GetLayoutScale()->GetScaleMode();
946 0 : else if (m_BasedOnStyle.obj().is())
947 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScaleMode();
948 : else
949 0 : return (LwpLayoutScale::FIT_IN_FRAME | LwpLayoutScale::MAINTAIN_ASPECT_RATIO);
950 : }
951 :
952 3 : sal_uInt16 LwpMiddleLayout::GetScaleTile()
953 : {
954 3 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
955 3 : return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::TILED)
956 3 : ? 1 : 0;
957 0 : else if (m_BasedOnStyle.obj().is())
958 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScaleTile();
959 : else
960 0 : return 0;
961 : }
962 :
963 6 : sal_uInt16 LwpMiddleLayout::GetScaleCenter()
964 : {
965 6 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
966 6 : return (GetLayoutScale()->GetPlacement() & LwpLayoutScale::CENTERED)
967 6 : ? 1 : 0;
968 0 : else if (m_BasedOnStyle.obj().is())
969 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScaleCenter();
970 : else
971 0 : return 0;
972 : }
973 :
974 0 : sal_uInt32 LwpMiddleLayout::GetScalePercentage()
975 : {
976 0 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
977 0 : return GetLayoutScale()->GetScalePercentage()/10;//m_nScalePercentage 1000 = 100%
978 0 : else if (m_BasedOnStyle.obj().is())
979 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScalePercentage();
980 : else
981 0 : return 100;
982 : }
983 :
984 0 : double LwpMiddleLayout::GetScaleWidth()
985 : {
986 0 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
987 0 : return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleWidth());
988 0 : else if (m_BasedOnStyle.obj().is())
989 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScaleWidth();
990 : else
991 0 : return 0;
992 : }
993 :
994 0 : double LwpMiddleLayout::GetScaleHeight()
995 : {
996 0 : if ((m_nOverrideFlag & OVER_SCALING) && m_LayScale.obj().is())
997 0 : return LwpTools::ConvertFromUnits(GetLayoutScale()->GetScaleHeight());
998 0 : else if (m_BasedOnStyle.obj().is())
999 0 : return dynamic_cast<LwpMiddleLayout*>(m_BasedOnStyle.obj().get())->GetScaleHeight();
1000 : else
1001 0 : return 0;
1002 : }
1003 4 : bool LwpMiddleLayout::CanSizeRight()
1004 : {
1005 4 : sal_uInt8 RelType = GetRelativeType();
1006 :
1007 4 : if (RelType == LwpLayoutRelativityGuts::LAY_INLINE || RelType == LwpLayoutRelativityGuts::LAY_PARA_RELATIVE
1008 4 : || RelType == LwpLayoutRelativityGuts::LAY_INLINE_VERTICAL)
1009 : {
1010 0 : return false;
1011 : }
1012 4 : return true;
1013 : }
1014 2 : sal_Int32 LwpMiddleLayout::GetMinimumWidth()
1015 : {
1016 2 : if (((m_nAttributes3 & STYLE3_WIDTHVALID) != 0) && GetGeometry())
1017 : {
1018 2 : return GetGeometry()->GetWidth();
1019 : }
1020 0 : else if (m_nOverrideFlag & OVER_SIZE)
1021 : {
1022 0 : return DetermineWidth();
1023 : }
1024 0 : return 0;
1025 : }
1026 0 : sal_Int32 LwpMiddleLayout::DetermineWidth()
1027 : {
1028 0 : if (IsSizeRightToContent())
1029 : {
1030 : assert(false);
1031 : }
1032 0 : else if (IsSizeRightToContainer())
1033 : {
1034 : assert(false);
1035 : }
1036 : else
1037 : {
1038 0 : m_nAttributes3 |= STYLE3_WIDTHVALID;
1039 0 : return GetGeometry()->GetWidth();
1040 : }
1041 0 : return 0;
1042 : }
1043 0 : bool LwpMiddleLayout::IsSizeRightToContainer()
1044 : {
1045 0 : if (!CanSizeRight())
1046 0 : return false;
1047 :
1048 0 : if (m_nOverrideFlag & OVER_SIZE)
1049 : {
1050 0 : return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1051 : << SHIFT_RIGHT))
1052 0 : == ((LAY_USEDIRECTION | LAY_TOCONTAINER | LAY_AUTOSIZE) << SHIFT_RIGHT);
1053 : }
1054 0 : else if (m_BasedOnStyle.obj().is())
1055 : {
1056 0 : LwpMiddleLayout * pLayout = dynamic_cast<LwpMiddleLayout *>(m_BasedOnStyle.obj().get());
1057 0 : return pLayout && pLayout->IsSizeRightToContainer();
1058 : }
1059 : else
1060 0 : return false;
1061 : }
1062 4 : bool LwpMiddleLayout::IsSizeRightToContent()
1063 : {
1064 4 : if (!CanSizeRight())
1065 0 : return false;
1066 :
1067 4 : if (m_nOverrideFlag & OVER_SIZE)
1068 : {
1069 2 : return (m_nDirection & ((LAY_USEDIRECTION|LAY_AUTOSIZE|LAY_TOCONTAINER)
1070 : << SHIFT_RIGHT))
1071 2 : == ((LAY_USEDIRECTION | LAY_AUTOSIZE) << SHIFT_RIGHT);
1072 : }
1073 2 : else if (m_BasedOnStyle.obj().is())
1074 : {
1075 2 : LwpMiddleLayout * pLayout = dynamic_cast<LwpMiddleLayout *>(m_BasedOnStyle.obj().get());
1076 2 : return pLayout && pLayout->IsSizeRightToContent();
1077 : }
1078 : else
1079 0 : return false;
1080 : }
1081 :
1082 : /**
1083 : * @descr: Get layout height
1084 : *
1085 : */
1086 20 : double LwpMiddleLayout::GetHeight()
1087 : {
1088 20 : return GetGeometryHeight();
1089 : }
1090 :
1091 : /**
1092 : * @descr: Get layout height
1093 : *
1094 : */
1095 43 : double LwpMiddleLayout::GetWidth()
1096 : {
1097 43 : return GetGeometryWidth();
1098 : }
1099 : /**
1100 : * @descr: Get layout origin point
1101 : *
1102 : */
1103 22 : LwpPoint LwpMiddleLayout::GetOrigin()
1104 : {
1105 22 : LwpLayoutGeometry* pGeo = GetGeometry();
1106 22 : if(pGeo)
1107 : {
1108 22 : sal_uInt8 nType = GetRelativeType();
1109 22 : if(nType == LwpLayoutRelativityGuts::LAY_INLINE
1110 22 : || nType == LwpLayoutRelativityGuts::LAY_INLINE_NEWLINE )
1111 : {
1112 16 : return pGeo->GetAbsoluteOrigin();
1113 : }
1114 : else
1115 6 : return pGeo->GetOrigin();
1116 :
1117 : }
1118 :
1119 0 : return LwpPoint();
1120 : }
1121 :
1122 : /**
1123 : * @descr: Whether the fill is pattern fill or not
1124 : * @return: True if yes, false if not.
1125 : */
1126 50 : bool LwpMiddleLayout::IsPatternFill()
1127 : {
1128 50 : LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1129 50 : if (pBackgroundStuff)
1130 : {
1131 50 : return pBackgroundStuff->IsPatternFill();
1132 : }
1133 :
1134 0 : return false;
1135 : }
1136 :
1137 : /**
1138 : * @descr: Get the fill pattern style. Data are saved in a XFBGImage object
1139 : * @return: the fill pattern style.
1140 : */
1141 0 : XFBGImage* LwpMiddleLayout::GetFillPattern()
1142 : {
1143 0 : LwpBackgroundStuff* pBackgroundStuff = GetBackgroundStuff();
1144 0 : if (pBackgroundStuff)
1145 : {
1146 0 : return pBackgroundStuff->GetFillPattern();
1147 : }
1148 :
1149 0 : return NULL;
1150 :
1151 : }
1152 :
1153 : /**
1154 : * @descr: Whether the height and width of layout is auto grow
1155 : *
1156 : */
1157 13 : bool LwpMiddleLayout::IsAutoGrow()
1158 : {
1159 13 : if(m_nOverrideFlag & OVER_SIZE)
1160 : {
1161 13 : return (m_nDirection &
1162 : ((LAY_AUTOGROW << SHIFT_UP) | (LAY_AUTOGROW << SHIFT_DOWN) |
1163 13 : (LAY_AUTOGROW << SHIFT_RIGHT) | (LAY_AUTOGROW << SHIFT_LEFT))) != 0;
1164 : }
1165 0 : else if( !m_BasedOnStyle.IsNull() )
1166 : {
1167 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1168 0 : return pLay && pLay->IsAutoGrow();
1169 : }
1170 0 : return LwpVirtualLayout::IsAutoGrow();
1171 : }
1172 :
1173 : /**
1174 : * @descr: Whether the height of layout is auto grow down
1175 : *
1176 : */
1177 21 : bool LwpMiddleLayout::IsAutoGrowDown()
1178 : {
1179 21 : if(m_nOverrideFlag & OVER_SIZE)
1180 : {
1181 21 : return (m_nDirection & (LAY_AUTOGROW << SHIFT_DOWN)) != 0;
1182 : }
1183 0 : else if( !m_BasedOnStyle.IsNull() )
1184 : {
1185 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1186 0 : return pLay && pLay->IsAutoGrowDown();
1187 : }
1188 0 : return LwpVirtualLayout::IsAutoGrowDown();
1189 : }
1190 :
1191 : /**
1192 : * @descr: Whether the height of layout is auto grow up
1193 : *
1194 : */
1195 15 : bool LwpMiddleLayout::IsAutoGrowUp()
1196 : {
1197 15 : if(m_nOverrideFlag & OVER_SIZE)
1198 : {
1199 15 : return (m_nDirection & (LAY_AUTOGROW << SHIFT_UP)) != 0;
1200 : }
1201 0 : else if( !m_BasedOnStyle.IsNull() )
1202 : {
1203 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1204 0 : return pLay && pLay->IsAutoGrowUp();
1205 : }
1206 0 : return LwpVirtualLayout::IsAutoGrowUp();
1207 : }
1208 :
1209 : /**
1210 : * @descr: Whether the height of layout is auto grow down
1211 : *
1212 : */
1213 13 : bool LwpMiddleLayout::IsAutoGrowLeft()
1214 : {
1215 13 : if(m_nOverrideFlag & OVER_SIZE)
1216 : {
1217 13 : return (m_nDirection & (LAY_AUTOGROW << SHIFT_LEFT)) != 0;
1218 : }
1219 0 : else if( !m_BasedOnStyle.IsNull() )
1220 : {
1221 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1222 0 : if (pLay)
1223 0 : return pLay->IsAutoGrowLeft();
1224 : }
1225 0 : return LwpVirtualLayout::IsAutoGrowLeft();
1226 : }
1227 :
1228 : /**
1229 : * @descr: Whether the height of layout is auto grow down
1230 : *
1231 : */
1232 32 : bool LwpMiddleLayout::IsAutoGrowRight()
1233 : {
1234 32 : if(m_nOverrideFlag & OVER_SIZE)
1235 : {
1236 32 : return (m_nDirection & (LAY_AUTOGROW << SHIFT_RIGHT)) != 0;
1237 : }
1238 0 : else if( !m_BasedOnStyle.IsNull() )
1239 : {
1240 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1241 0 : return pLay && pLay->IsAutoGrowRight();
1242 : }
1243 0 : return LwpVirtualLayout::IsAutoGrowRight();
1244 : }
1245 :
1246 : /**
1247 : * @descr: Get contents orientation
1248 : *
1249 : */
1250 83 : sal_uInt8 LwpMiddleLayout::GetContentOrientation()
1251 : {
1252 : //content orientation in Graphic objects and OLE objects not supported now
1253 83 : if((m_nOverrideFlag & OVER_ROTATION)&& !m_LayGeometry.IsNull())
1254 : {
1255 33 : LwpLayoutGeometry* pLayGeometry = dynamic_cast<LwpLayoutGeometry*> (m_LayGeometry.obj().get());
1256 33 : if (pLayGeometry)
1257 33 : return pLayGeometry->GetContentOrientation();
1258 : }
1259 50 : else if( !m_BasedOnStyle.IsNull() )
1260 : {
1261 50 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1262 50 : if (pLay)
1263 50 : return pLay->GetContentOrientation();
1264 : }
1265 0 : return LwpVirtualLayout::GetContentOrientation();
1266 : }
1267 :
1268 : /**
1269 : * @descr: Whether it is honoring protection
1270 : *
1271 : */
1272 0 : bool LwpMiddleLayout::HonorProtection()
1273 : {
1274 0 : if(m_nOverrideFlag & OVER_MISC)
1275 : {
1276 0 : if(!(m_nAttributes2 & STYLE2_HONORPROTECTION))
1277 0 : return false;
1278 :
1279 0 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
1280 0 : if(pParent && !pParent->IsHeader())
1281 : {
1282 0 : return pParent->HonorProtection();
1283 : }
1284 :
1285 0 : if(m_pFoundry)//is null now
1286 : {
1287 0 : LwpDocument* pDoc = m_pFoundry->GetDocument();
1288 0 : if(pDoc)
1289 : {
1290 0 : return pDoc->HonorProtection();
1291 : }
1292 : }
1293 : }
1294 0 : else if( !m_BasedOnStyle.IsNull() )
1295 : {
1296 0 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1297 0 : if (pLay)
1298 0 : return pLay->HonorProtection();
1299 : }
1300 :
1301 0 : return LwpVirtualLayout::HonorProtection();
1302 : }
1303 :
1304 : /**
1305 : * @descr: Whether it is pretected
1306 : *
1307 : */
1308 111 : bool LwpMiddleLayout::IsProtected()
1309 : {
1310 111 : bool bProtected = false;
1311 111 : if(m_nOverrideFlag & OVER_MISC)
1312 : {
1313 65 : bProtected = (m_nAttributes & STYLE_PROTECTED)!=0;
1314 : }
1315 46 : else if( !m_BasedOnStyle.IsNull() )
1316 : {
1317 46 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1318 46 : bProtected = pLay && pLay->IsProtected();
1319 : }
1320 : else
1321 0 : bProtected = LwpVirtualLayout::IsProtected();
1322 :
1323 111 : LwpVirtualLayout* pParent = dynamic_cast<LwpVirtualLayout*> (GetParent().obj().get());
1324 111 : if(pParent && !pParent->IsHeader())
1325 : {
1326 : /* If a parent's protected then none of its children can be accessed. */
1327 111 : if(pParent->IsProtected())
1328 0 : return true;
1329 :
1330 111 : if(pParent->HonorProtection())
1331 111 : return bProtected;
1332 :
1333 : /* If our parent isn't honoring protection then we aren't protected. */
1334 0 : return false;
1335 :
1336 : }
1337 0 : if(m_pFoundry)//is null now
1338 : {
1339 0 : LwpDocument* pDoc = m_pFoundry->GetDocument();
1340 0 : if(pDoc)
1341 : {
1342 0 : if (pDoc->HonorProtection())
1343 0 : return bProtected;
1344 :
1345 : /* If the document isn't honoring protection then we aren't protected.*/
1346 0 : return false;
1347 : }
1348 : }
1349 :
1350 0 : return bProtected;
1351 : }
1352 :
1353 : /**
1354 : * @descr: Get watermark layout
1355 : *
1356 : */
1357 122 : LwpVirtualLayout* LwpMiddleLayout::GetWaterMarkLayout()
1358 : {
1359 122 : LwpVirtualLayout* pLay = dynamic_cast<LwpVirtualLayout*>(GetChildHead().obj().get());
1360 261 : while(pLay)
1361 : {
1362 17 : if( pLay->IsForWaterMark())
1363 : {
1364 0 : return pLay;
1365 : }
1366 17 : pLay = dynamic_cast<LwpVirtualLayout*> (pLay->GetNext().obj().get());
1367 : }
1368 122 : return NULL;
1369 : }
1370 :
1371 : /**
1372 : * @descr: Create and reture xfbgimage object for watermark
1373 : *
1374 : */
1375 122 : XFBGImage* LwpMiddleLayout::GetXFBGImage()
1376 : {
1377 122 : LwpMiddleLayout* pLay = static_cast<LwpMiddleLayout*>(GetWaterMarkLayout());
1378 122 : if(pLay)
1379 : {
1380 : //test BGImage
1381 0 : LwpGraphicObject* pGrfObj = dynamic_cast<LwpGraphicObject*>(pLay->GetContent().obj().get());
1382 0 : if(pGrfObj)
1383 : {
1384 0 : XFBGImage* pXFBGImage = new XFBGImage();
1385 :
1386 0 : if(pGrfObj->IsLinked())
1387 : {
1388 : //set file link
1389 0 : OUString linkedfilepath = pGrfObj->GetLinkedFilePath();
1390 0 : OUString fileURL = LwpTools::convertToFileUrl(OUStringToOString(linkedfilepath, osl_getThreadTextEncoding()));
1391 0 : pXFBGImage->SetFileLink(fileURL);
1392 : }
1393 : else
1394 : {
1395 0 : sal_uInt8* pGrafData = NULL;
1396 0 : sal_uInt32 nDataLen = pGrfObj->GetRawGrafData(pGrafData);
1397 0 : pXFBGImage->SetImageData(pGrafData, nDataLen);
1398 0 : if(pGrafData)
1399 : {
1400 0 : delete[] pGrafData;
1401 0 : pGrafData = NULL;
1402 : }
1403 : }
1404 :
1405 : //automatic, top left
1406 0 : pXFBGImage->SetPosition(enumXFAlignStart,enumXFAlignTop);
1407 0 : if(pLay->GetScaleCenter())
1408 : {
1409 : //center
1410 0 : pXFBGImage->SetPosition(enumXFAlignCenter,enumXFAlignCenter);
1411 : }
1412 0 : else if(pLay->GetScaleTile())
1413 : {
1414 : //tile
1415 0 : pXFBGImage->SetRepeate();
1416 : }
1417 : //fit type, area type
1418 0 : if((pLay->GetScaleMode()& LwpLayoutScale::FIT_IN_FRAME)!=0)
1419 : {
1420 0 : if((pLay->GetScaleMode()& LwpLayoutScale::MAINTAIN_ASPECT_RATIO)==0)
1421 : {
1422 0 : pXFBGImage->SetStretch();
1423 : }
1424 : }
1425 0 : return pXFBGImage;
1426 : }
1427 : }
1428 122 : return NULL;
1429 : }
1430 :
1431 : /**
1432 : * @descr: Whether the page uses the printer setting
1433 : *
1434 : */
1435 52 : bool LwpMiddleLayout::GetUsePrinterSettings()
1436 : {
1437 52 : if(m_nOverrideFlag & OVER_SIZE)
1438 : {
1439 29 : return (m_nAttributes3 & STYLE3_USEPRINTERSETTINGS) != 0;
1440 : }
1441 23 : else if( !m_BasedOnStyle.IsNull() )
1442 : {
1443 23 : LwpMiddleLayout* pLay = dynamic_cast<LwpMiddleLayout*> ( m_BasedOnStyle.obj().get() );
1444 23 : return pLay && pLay->GetUsePrinterSettings();
1445 : }
1446 0 : return false;
1447 : }
1448 :
1449 : //Check whether there are contents in the layout
1450 0 : bool LwpMiddleLayout::HasContent()
1451 : {
1452 0 : rtl::Reference<LwpObject> content = m_Content.obj();
1453 0 : if(content.is())
1454 0 : return true;
1455 0 : return false;
1456 : }
1457 : //End by
1458 :
1459 72 : LwpLayout::LwpLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm ) :
1460 72 : LwpMiddleLayout(objHdr, pStrm), m_pUseWhen(new LwpUseWhen)
1461 72 : {}
1462 :
1463 144 : LwpLayout::~LwpLayout()
1464 : {
1465 72 : if (m_pUseWhen)
1466 : {
1467 72 : delete m_pUseWhen;
1468 : }
1469 72 : }
1470 :
1471 72 : void LwpLayout::Read()
1472 : {
1473 72 : LwpObjectStream* pStrm = m_pObjStrm;
1474 :
1475 72 : LwpMiddleLayout::Read();
1476 72 : if (LwpFileHeader::m_nFileRevision < 0x000B)
1477 : {
1478 : // read PreRevBLayout...
1479 : }
1480 : else
1481 : {
1482 72 : sal_uInt16 nSimple = pStrm->QuickReaduInt16();
1483 :
1484 72 : if (!nSimple)
1485 : {
1486 69 : m_pUseWhen->Read(pStrm);
1487 :
1488 69 : sal_uInt8 nFlag = pStrm->QuickReaduInt8();
1489 69 : if (nFlag)
1490 26 : m_Positon.ReadIndexed(pStrm);
1491 : }
1492 :
1493 72 : m_LayColumns.ReadIndexed(pStrm);
1494 72 : m_LayGutterStuff.ReadIndexed(pStrm);
1495 72 : m_LayJoinStuff.ReadIndexed(pStrm);
1496 72 : m_LayShadow.ReadIndexed(pStrm);
1497 :
1498 72 : if (pStrm->CheckExtra())
1499 : {
1500 60 : m_LayExtJoinStuff.ReadIndexed(pStrm);
1501 60 : pStrm->SkipExtra();
1502 : }
1503 : }
1504 72 : }
1505 :
1506 : /**
1507 : * @descr: Get columns number
1508 : *
1509 : */
1510 85 : sal_uInt16 LwpLayout::GetNumCols()
1511 : {
1512 85 : if(m_nOverrideFlag & OVER_COLUMNS)
1513 : {
1514 37 : LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1515 37 : if(pLayColumns)
1516 : {
1517 37 : return pLayColumns->GetNumCols();
1518 : }
1519 : }
1520 :
1521 48 : LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
1522 48 : if(pStyle)
1523 : {
1524 48 : return pStyle->GetNumCols();
1525 : }
1526 :
1527 0 : return LwpVirtualLayout::GetNumCols();
1528 :
1529 : }
1530 :
1531 : /**
1532 : * @descr: Get column width
1533 : * @param: the order of column
1534 : */
1535 0 : double LwpLayout::GetColWidth(sal_uInt16 nIndex)
1536 : {
1537 0 : if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1538 : {
1539 0 : LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1540 0 : if(pLayColumns)
1541 : {
1542 0 : return pLayColumns->GetColWidth(nIndex);
1543 : }
1544 : }
1545 :
1546 0 : LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
1547 0 : if(pStyle)
1548 : {
1549 0 : return pStyle->GetColWidth(nIndex);
1550 : }
1551 :
1552 0 : return LwpVirtualLayout::GetColWidth(nIndex);
1553 :
1554 : }
1555 :
1556 : /**
1557 : * @descr: Get gap between columns
1558 : * @param: the order of column
1559 : */
1560 0 : double LwpLayout::GetColGap(sal_uInt16 nIndex)
1561 : {
1562 0 : if((m_nOverrideFlag & OVER_COLUMNS)||(m_nAttributes2 & STYLE2_LOCALCOLUMNINFO))
1563 : {
1564 0 : LwpLayoutColumns* pLayColumns = dynamic_cast<LwpLayoutColumns*>(m_LayColumns.obj().get());
1565 0 : if(pLayColumns)
1566 : {
1567 0 : return pLayColumns->GetColGap(nIndex);
1568 : }
1569 : }
1570 :
1571 0 : LwpVirtualLayout* pStyle = dynamic_cast<LwpVirtualLayout*> (m_BasedOnStyle.obj().get());
1572 0 : if(pStyle)
1573 : {
1574 0 : return pStyle->GetColGap(nIndex);
1575 : }
1576 :
1577 0 : return LwpVirtualLayout::GetColGap(nIndex);
1578 : }
1579 :
1580 : /**
1581 : * @descr: Create and return XFColumns object
1582 : *
1583 : */
1584 33 : XFColumns* LwpLayout::GetXFColumns()
1585 : {
1586 : //if there is only one column, do not need insert columns
1587 33 : sal_uInt16 nCols = GetNumCols();
1588 33 : if(nCols==1)
1589 : {
1590 33 : return NULL;
1591 : }
1592 :
1593 0 : XFColumns* pColumns = new XFColumns();
1594 : //set XFColumnSep
1595 0 : boost::scoped_ptr<XFColumnSep> pColumnSep(GetColumnSep());
1596 0 : if(pColumnSep)
1597 : {
1598 0 : pColumns->SetSeparator(*pColumnSep);
1599 : }
1600 :
1601 : //set column count and column gap
1602 0 : pColumns->SetCount(nCols);
1603 0 : double fGap = GetColGap(0);
1604 0 : pColumns->SetGap(fGap);
1605 :
1606 : //set xfcolumn
1607 0 : for(sal_uInt16 nIndex = 0; nIndex<nCols; nIndex++)
1608 : {
1609 0 : XFColumn aColumn;
1610 0 : sal_Int32 nWidth = static_cast<sal_Int32>(GetColWidth(nIndex));
1611 0 : nWidth=8305/nCols; //relative width
1612 0 : aColumn.SetRelWidth(nWidth);
1613 :
1614 : //the left and right margins is 0;
1615 0 : double nGap = GetColGap(nIndex)/2;
1616 : //nGap=0;
1617 0 : aColumn.SetMargins(nGap,nGap);
1618 0 : if(nIndex==0)
1619 : {
1620 0 : aColumn.SetMargins(0,nGap);
1621 : }
1622 0 : if(nIndex==(nCols-1))
1623 : {
1624 0 : aColumn.SetMargins(nGap,0);
1625 : }
1626 0 : pColumns->AddColumn(aColumn);
1627 : }
1628 :
1629 0 : return pColumns;
1630 : }
1631 :
1632 : /**
1633 : * @descr: Create and return XFColumnSep object
1634 : *
1635 : */
1636 0 : XFColumnSep* LwpLayout::GetColumnSep()
1637 : {
1638 :
1639 : //Get LwpLayoutGutters
1640 0 : LwpLayoutGutters* pLayoutGutters = dynamic_cast<LwpLayoutGutters*>(m_LayGutterStuff.obj().get());
1641 0 : if(!pLayoutGutters)
1642 : {
1643 0 : return NULL;
1644 : }
1645 :
1646 0 : LwpBorderStuff& pBorderStuff = pLayoutGutters->GetBorderStuff();
1647 :
1648 0 : LwpBorderStuff::BorderType eType = LwpBorderStuff::LEFT;
1649 0 : LwpColor aColor = pBorderStuff.GetSideColor(eType);
1650 0 : double fWidth = pBorderStuff.GetSideWidth(eType);
1651 : //sal_uInt16 nType = pBorderStuff->GetSideType(eType);
1652 :
1653 0 : XFColumnSep* pColumnSep = new XFColumnSep();
1654 0 : XFColor aXFColor(aColor.To24Color());
1655 0 : pColumnSep->SetColor(aXFColor);
1656 0 : pColumnSep->SetWidth(fWidth);
1657 0 : pColumnSep->SetRelHeight(100);
1658 0 : pColumnSep->SetVerticalAlign(enumXFAlignTop);
1659 :
1660 0 : return pColumnSep;
1661 : }
1662 :
1663 : /**
1664 : * @descr: Get use when type
1665 : *
1666 : */
1667 4 : LwpLayout::UseWhenType LwpLayout::GetUseWhenType()
1668 : {
1669 4 : UseWhenType eType = StartWithinPage;
1670 4 : LwpUseWhen* pUseWhen = GetUseWhen();
1671 4 : if(pUseWhen)
1672 : {
1673 4 : if(pUseWhen->IsStartOnThisHF())
1674 : {
1675 0 : eType = StartWithinColume;
1676 : }
1677 4 : else if(pUseWhen->IsStartOnThisPage())
1678 : {
1679 0 : eType = StartWithinPage;
1680 : }
1681 4 : else if(pUseWhen->IsStartOnNextPage())
1682 : {
1683 4 : eType = StartOnNextPage;
1684 : }
1685 0 : else if(pUseWhen->IsStartOnNextOddPage())
1686 : {
1687 0 : eType = StartOnOddPage;
1688 : }
1689 0 : else if(pUseWhen->IsStartOnNextEvenPage())
1690 : {
1691 0 : eType = StartOnEvenPage;
1692 : }
1693 :
1694 : }
1695 : else
1696 : {
1697 0 : eType = StartOnNextPage;
1698 : }
1699 4 : return eType;
1700 : }
1701 :
1702 : /**
1703 : * @descr: Get use page
1704 : *
1705 : */
1706 0 : sal_uInt16 LwpLayout::GetUsePage()
1707 : {
1708 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
1709 : {
1710 0 : LwpUseWhen* pUseWhen = GetUseWhen();
1711 0 : if(pUseWhen)
1712 0 : return pUseWhen->GetUsePage();
1713 : else
1714 0 : return 0;
1715 : }
1716 0 : else if( !m_BasedOnStyle.IsNull() )
1717 : {
1718 0 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1719 0 : return pLay ? pLay->GetUsePage() : 0;
1720 : }
1721 0 : return 0;
1722 : }
1723 :
1724 : /**
1725 : * @descr: Get usewhen pointer
1726 : *
1727 : */
1728 16 : LwpUseWhen* LwpLayout::VirtualGetUseWhen()
1729 : {
1730 16 : if(m_nOverrideFlag & OVER_PLACEMENT)
1731 : {
1732 12 : return m_pUseWhen;
1733 : }
1734 4 : else if( !m_BasedOnStyle.IsNull() )
1735 : {
1736 4 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1737 4 : return pLay ? pLay->VirtualGetUseWhen() : NULL;
1738 : }
1739 0 : return LwpVirtualLayout::VirtualGetUseWhen();
1740 : }
1741 :
1742 : /**
1743 : * @descr: Whether it is use on all pages
1744 : *
1745 : */
1746 0 : bool LwpLayout::IsUseOnAllPages()
1747 : {
1748 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
1749 : {
1750 0 : LwpUseWhen* pUseWhen = GetUseWhen();
1751 0 : if(pUseWhen)
1752 0 : return pUseWhen->IsUseOnAllPages();
1753 : else
1754 0 : return false;
1755 : }
1756 0 : else if( !m_BasedOnStyle.IsNull() )
1757 : {
1758 0 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1759 0 : if (pLay)
1760 0 : return pLay->IsUseOnAllPages();
1761 : }
1762 0 : return LwpVirtualLayout::IsUseOnAllPages();
1763 : }
1764 :
1765 : /**
1766 : * @descr: Whether it is use on all even pages
1767 : *
1768 : */
1769 0 : bool LwpLayout::IsUseOnAllEvenPages()
1770 : {
1771 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
1772 : {
1773 0 : LwpUseWhen* pUseWhen = GetUseWhen();
1774 0 : if(pUseWhen)
1775 0 : return pUseWhen->IsUseOnAllEvenPages();
1776 : else
1777 0 : return false;
1778 : }
1779 0 : else if( !m_BasedOnStyle.IsNull() )
1780 : {
1781 0 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1782 0 : if (pLay)
1783 0 : return pLay->IsUseOnAllEvenPages();
1784 : }
1785 0 : return LwpVirtualLayout::IsUseOnAllEvenPages();
1786 : }
1787 :
1788 : /**
1789 : * @descr: Whether it is use on all odd pages
1790 : *
1791 : */
1792 0 : bool LwpLayout::IsUseOnAllOddPages()
1793 : {
1794 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
1795 : {
1796 0 : LwpUseWhen* pUseWhen = GetUseWhen();
1797 0 : if(pUseWhen)
1798 0 : return pUseWhen->IsUseOnAllOddPages();
1799 : else
1800 0 : return false;
1801 : }
1802 0 : else if( !m_BasedOnStyle.IsNull() )
1803 : {
1804 0 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1805 0 : if (pLay)
1806 0 : return pLay->IsUseOnAllOddPages();
1807 : }
1808 0 : return LwpVirtualLayout::IsUseOnAllOddPages();
1809 : }
1810 :
1811 : /**
1812 : * @descr: Whether it is use on current page
1813 : *
1814 : */
1815 0 : bool LwpLayout::IsUseOnPage()
1816 : {
1817 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
1818 : {
1819 0 : LwpUseWhen* pUseWhen = GetUseWhen();
1820 0 : if(pUseWhen)
1821 0 : return pUseWhen->IsUseOnPage();
1822 : else
1823 0 : return false;
1824 : }
1825 0 : else if( !m_BasedOnStyle.IsNull() )
1826 : {
1827 0 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1828 0 : if (pLay)
1829 0 : return pLay->IsUseOnPage();
1830 : }
1831 0 : return LwpVirtualLayout::IsUseOnPage();
1832 : }
1833 :
1834 : /**
1835 : * @descr: Get the LwpShadow object according to m_LayShadow id.
1836 : * @param:
1837 : * @param:
1838 : * @return:
1839 : */
1840 117 : LwpShadow* LwpLayout::GetShadow()
1841 : {
1842 117 : if(m_nOverrideFlag & OVER_SHADOW)
1843 : {
1844 49 : LwpLayoutShadow* pLayoutShadow = dynamic_cast<LwpLayoutShadow*>(m_LayShadow.obj().get());
1845 49 : return pLayoutShadow ? &pLayoutShadow->GetShadow() : NULL;
1846 : }
1847 68 : else if( !m_BasedOnStyle.IsNull() )
1848 : {
1849 67 : LwpLayout* pLay = dynamic_cast<LwpLayout*> ( m_BasedOnStyle.obj().get() );
1850 67 : return pLay ? pLay->GetShadow() : NULL;
1851 : }
1852 1 : return NULL;
1853 : }
1854 :
1855 : /**
1856 : * @descr: create xfshadow
1857 : * @param:
1858 : * @param:
1859 : * @return:
1860 : */
1861 50 : XFShadow* LwpLayout::GetXFShadow()
1862 : {
1863 50 : LwpShadow* pShadow = GetShadow();
1864 50 : if( pShadow )
1865 : {
1866 49 : LwpColor color = pShadow->GetColor();
1867 49 : double offsetX = pShadow->GetOffsetX();
1868 49 : double offsetY = pShadow->GetOffsetY();
1869 :
1870 49 : if( offsetX && offsetY && color.IsValidColor() )
1871 : {
1872 0 : XFShadow* pXFShadow = new XFShadow();
1873 0 : enumXFShadowPos eXFShadowPos = enumXFShadowLeftTop;
1874 0 : double fOffset = 0;
1875 :
1876 0 : bool left = false;
1877 0 : bool top = false;
1878 0 : if( offsetX < 0 )
1879 0 : left = true;
1880 0 : if( offsetY < 0 )
1881 0 : top = true;
1882 0 : if( left )
1883 : {
1884 0 : fOffset = -offsetX;
1885 0 : if( top )
1886 0 : eXFShadowPos = enumXFShadowLeftTop;
1887 : else
1888 0 : eXFShadowPos = enumXFShadowLeftBottom;
1889 : }
1890 : else
1891 : {
1892 0 : fOffset = offsetX;
1893 0 : if( top )
1894 0 : eXFShadowPos = enumXFShadowRightTop;
1895 : else
1896 0 : eXFShadowPos = enumXFShadowRightBottom;
1897 : }
1898 :
1899 0 : pXFShadow->SetPosition(eXFShadowPos);
1900 0 : pXFShadow->SetOffset(fOffset);
1901 0 : pXFShadow->SetColor(XFColor(color.To24Color()));
1902 :
1903 0 : return pXFShadow;
1904 49 : }
1905 : }
1906 50 : return NULL;
1907 : }
1908 :
1909 : /**
1910 : * @descr get the layout that containers the current frame layout
1911 : *
1912 : */
1913 67 : LwpVirtualLayout* LwpLayout::GetContainerLayout()
1914 : {
1915 67 : if(IsRelativeAnchored())
1916 : {
1917 : //get position
1918 67 : LwpPara* pPara = dynamic_cast<LwpPara*>(GetPosition().obj().get());
1919 67 : if(pPara)
1920 : {
1921 67 : LwpStory* pStory = pPara->GetStory();
1922 67 : return pStory ? pStory->GetTabLayout() : NULL;
1923 : }
1924 : }
1925 0 : return GetParentLayout();
1926 : }
1927 :
1928 62 : LwpPlacableLayout::LwpPlacableLayout( LwpObjectHeader &objHdr, LwpSvStream* pStrm )
1929 : : LwpLayout(objHdr, pStrm)
1930 : , m_nWrapType(0)
1931 : , m_nBuoyancy(0)
1932 : , m_nBaseLineOffset(0)
1933 62 : , m_nPageNumber(0)
1934 62 : {}
1935 :
1936 62 : LwpPlacableLayout::~LwpPlacableLayout()
1937 62 : {}
1938 :
1939 62 : void LwpPlacableLayout::Read()
1940 : {
1941 62 : LwpObjectStream* pStrm = m_pObjStrm;
1942 62 : LwpLayout::Read();
1943 62 : if(LwpFileHeader::m_nFileRevision < 0x000B)
1944 : {
1945 : assert(false);
1946 : }
1947 : else
1948 : {
1949 62 : sal_uInt16 simple = pStrm->QuickReaduInt16();
1950 62 : if(!simple)
1951 : {
1952 30 : m_nWrapType = pStrm->QuickReaduInt8();
1953 30 : m_nBuoyancy = pStrm->QuickReaduInt8();
1954 30 : m_nBaseLineOffset = pStrm->QuickReadInt32();
1955 30 : m_Script.Read( pStrm);
1956 : }
1957 : else
1958 : {
1959 32 : m_nWrapType = LAY_WRAP_AROUND;
1960 32 : m_nBuoyancy = LAY_BUOYNEUTRAL;
1961 32 : m_nBaseLineOffset = 0;
1962 : }
1963 62 : m_LayRelativity.ReadIndexed( pStrm);
1964 62 : if(pStrm->CheckExtra())
1965 : {
1966 52 : sal_uInt16 count = pStrm->QuickReaduInt16();
1967 52 : if(count)
1968 : {
1969 : // temporily added by to avoid assertion
1970 0 : while (count)
1971 : {
1972 0 : LwpPoint aPoint;
1973 0 : aPoint.Read(pStrm);
1974 0 : count--;
1975 : }
1976 : // end added by
1977 : }
1978 52 : pStrm->SkipExtra();
1979 : }
1980 : }
1981 62 : }
1982 : /**
1983 : * @descr: get wrap type
1984 : * @param:
1985 : * @param:
1986 : * @return:
1987 : */
1988 25 : sal_uInt8 LwpPlacableLayout::GetWrapType()
1989 : {
1990 25 : if(m_nOverrideFlag & OVER_PLACEMENT)
1991 : {
1992 25 : return m_nWrapType;
1993 : }
1994 0 : else if( !m_BasedOnStyle.IsNull() )
1995 : {
1996 0 : LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj().get() );
1997 0 : if (pLay)
1998 0 : return pLay->GetWrapType();
1999 : }
2000 0 : return LAY_WRAP_AROUND;
2001 : }
2002 : /**
2003 : * @descr: get LayoutRelativity
2004 : * @param:
2005 : * @param:
2006 : * @return:
2007 : */
2008 283 : LwpLayoutRelativity* LwpPlacableLayout::GetRelativityPiece()
2009 : {
2010 283 : if(!m_LayRelativity.IsNull())
2011 : {
2012 283 : if(m_nOverrideFlag & OVER_PLACEMENT)
2013 : {
2014 283 : return dynamic_cast<LwpLayoutRelativity*>(m_LayRelativity.obj().get());
2015 : }
2016 : }
2017 0 : else if( !m_BasedOnStyle.IsNull() )
2018 : {
2019 0 : LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj().get() );
2020 0 : return pLay ? pLay->GetRelativityPiece() : NULL;
2021 : }
2022 0 : return NULL;
2023 : }
2024 : /**
2025 : * @descr: Get relative type
2026 : *
2027 : */
2028 283 : sal_uInt8 LwpPlacableLayout::GetRelativeType()
2029 : {
2030 283 : LwpLayoutRelativity* pLayRel = GetRelativityPiece();
2031 283 : if(pLayRel)
2032 : {
2033 283 : return pLayRel->GetRelGuts().GetRelativeType();
2034 : }
2035 0 : return LwpVirtualLayout::GetRelativeType();
2036 : }
2037 : /**
2038 : * @descr: Get offset from the baseline
2039 : *
2040 : */
2041 0 : sal_Int32 LwpPlacableLayout::GetBaseLineOffset()
2042 : {
2043 : /* The baseline is only valid if this is flow-with-text */
2044 0 : if(GetRelativeType()!=LwpLayoutRelativityGuts::LAY_INLINE)
2045 : {
2046 0 : return 0;
2047 : }
2048 :
2049 : // First, ask our content if it has a baseline, ignore now
2050 : /*
2051 : if (Content && Content->GetBaseLineOffset(&Baseline))
2052 : return Baseline;
2053 : */
2054 :
2055 0 : if(m_nOverrideFlag & OVER_PLACEMENT)
2056 : {
2057 0 : return m_nBaseLineOffset;
2058 : }
2059 0 : else if( !m_BasedOnStyle.IsNull() )
2060 : {
2061 0 : LwpPlacableLayout* pLay = dynamic_cast<LwpPlacableLayout*> ( m_BasedOnStyle.obj().get() );
2062 0 : return pLay ? pLay->GetBaseLineOffset() : 0;
2063 : }
2064 0 : return 0;
2065 :
2066 : }
2067 : /**
2068 : * @descr: whether the parent layout is page layout
2069 : *
2070 : */
2071 12 : bool LwpPlacableLayout::IsAnchorPage()
2072 : {
2073 12 : if(IsRelativeAnchored())
2074 0 : return false;
2075 :
2076 12 : LwpVirtualLayout* pLayout = GetParentLayout();
2077 12 : if(pLayout && (pLayout->IsPage() || pLayout->IsHeader() || pLayout->IsFooter()))
2078 : //if(pLayout && pLayout->IsPage())
2079 : {
2080 12 : return true;
2081 : }
2082 0 : return false;
2083 : }
2084 : /**
2085 : * @descr: whether the parent layout is frame layout
2086 : *
2087 : */
2088 6 : bool LwpPlacableLayout::IsAnchorFrame()
2089 : {
2090 6 : if(IsRelativeAnchored())
2091 0 : return false;
2092 :
2093 6 : LwpVirtualLayout* pLayout = GetParentLayout();
2094 6 : if(pLayout && (pLayout->IsFrame()||pLayout->IsGroupHead()))
2095 : {
2096 0 : return true;
2097 : }
2098 6 : return false;
2099 : }
2100 : /**
2101 : * @descr: whether the parent layout is cell layout
2102 : *
2103 : */
2104 6 : bool LwpPlacableLayout::IsAnchorCell()
2105 : {
2106 6 : if(IsRelativeAnchored())
2107 0 : return false;
2108 :
2109 6 : LwpVirtualLayout* pLayout = GetParentLayout();
2110 6 : if(pLayout && pLayout->IsCell())
2111 : {
2112 0 : return true;
2113 : }
2114 6 : return false;
2115 : }
2116 :
2117 : /**
2118 : * @descr: Set font style for setting position of frame
2119 : *
2120 : */
2121 25 : void LwpPlacableLayout::SetFont(rtl::Reference<XFFont> const & pFont)
2122 : {
2123 25 : m_pFont = pFont;
2124 37 : }
2125 :
2126 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
