1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include <com/sun/star/text/HoriOrientation.hpp>
28*b1cdbd2cSJim Jagielski #include <hintids.hxx>
29*b1cdbd2cSJim Jagielski #include <vcl/sound.hxx>
30*b1cdbd2cSJim Jagielski #include <tools/poly.hxx>
31*b1cdbd2cSJim Jagielski #define _SVSTDARR_LONGS
32*b1cdbd2cSJim Jagielski #include <svl/svstdarr.hxx>
33*b1cdbd2cSJim Jagielski #include <svx/xoutbmp.hxx>
34*b1cdbd2cSJim Jagielski #include <sfx2/progress.hxx>
35*b1cdbd2cSJim Jagielski #include <editeng/brshitem.hxx>
36*b1cdbd2cSJim Jagielski #include <editeng/opaqitem.hxx>
37*b1cdbd2cSJim Jagielski #include <editeng/prntitem.hxx>
38*b1cdbd2cSJim Jagielski #include <editeng/boxitem.hxx>
39*b1cdbd2cSJim Jagielski #include <editeng/shaditem.hxx>
40*b1cdbd2cSJim Jagielski #include <svx/framelink.hxx>
41*b1cdbd2cSJim Jagielski #include <vcl/graph.hxx>
42*b1cdbd2cSJim Jagielski #include <svx/svdpagv.hxx>
43*b1cdbd2cSJim Jagielski #include <hintids.hxx>
44*b1cdbd2cSJim Jagielski #include <tgrditem.hxx>
45*b1cdbd2cSJim Jagielski #include <switerator.hxx>
46*b1cdbd2cSJim Jagielski #include <fmtsrnd.hxx>
47*b1cdbd2cSJim Jagielski #include <fmtclds.hxx>
48*b1cdbd2cSJim Jagielski #include <tools/shl.hxx>
49*b1cdbd2cSJim Jagielski #include <comcore.hrc>
50*b1cdbd2cSJim Jagielski #include <swmodule.hxx>
51*b1cdbd2cSJim Jagielski #include <rootfrm.hxx>
52*b1cdbd2cSJim Jagielski #include <pagefrm.hxx>
53*b1cdbd2cSJim Jagielski #include <cntfrm.hxx>
54*b1cdbd2cSJim Jagielski #include <viewsh.hxx>
55*b1cdbd2cSJim Jagielski #include <section.hxx>
56*b1cdbd2cSJim Jagielski #include <sectfrm.hxx>
57*b1cdbd2cSJim Jagielski #include <doc.hxx>
58*b1cdbd2cSJim Jagielski #include <viewimp.hxx>
59*b1cdbd2cSJim Jagielski #include <dflyobj.hxx>
60*b1cdbd2cSJim Jagielski #include <flyfrm.hxx>
61*b1cdbd2cSJim Jagielski #include <frmtool.hxx>
62*b1cdbd2cSJim Jagielski #include <viewopt.hxx>
63*b1cdbd2cSJim Jagielski #include <dview.hxx>
64*b1cdbd2cSJim Jagielski #include <dcontact.hxx>
65*b1cdbd2cSJim Jagielski #include <txtfrm.hxx>
66*b1cdbd2cSJim Jagielski #include <ftnfrm.hxx>
67*b1cdbd2cSJim Jagielski #include <tabfrm.hxx>
68*b1cdbd2cSJim Jagielski #include <rowfrm.hxx>
69*b1cdbd2cSJim Jagielski #include <cellfrm.hxx>
70*b1cdbd2cSJim Jagielski #include <notxtfrm.hxx>
71*b1cdbd2cSJim Jagielski #include <swregion.hxx>
72*b1cdbd2cSJim Jagielski #include <layact.hxx>
73*b1cdbd2cSJim Jagielski #include <pagedesc.hxx>
74*b1cdbd2cSJim Jagielski #include <ptqueue.hxx>
75*b1cdbd2cSJim Jagielski #include <noteurl.hxx>
76*b1cdbd2cSJim Jagielski #include <virtoutp.hxx>
77*b1cdbd2cSJim Jagielski #include <lineinfo.hxx>
78*b1cdbd2cSJim Jagielski #include <dbg_lay.hxx>
79*b1cdbd2cSJim Jagielski #include <accessibilityoptions.hxx>
80*b1cdbd2cSJim Jagielski #include <docsh.hxx>
81*b1cdbd2cSJim Jagielski #include <swtable.hxx>
82*b1cdbd2cSJim Jagielski #include <svx/svdogrp.hxx>
83*b1cdbd2cSJim Jagielski #include <sortedobjs.hxx>
84*b1cdbd2cSJim Jagielski #include <EnhancedPDFExportHelper.hxx>
85*b1cdbd2cSJim Jagielski // <--
86*b1cdbd2cSJim Jagielski // --> OD #i76669#
87*b1cdbd2cSJim Jagielski #include <svx/sdr/contact/viewobjectcontactredirector.hxx>
88*b1cdbd2cSJim Jagielski #include <svx/sdr/contact/viewobjectcontact.hxx>
89*b1cdbd2cSJim Jagielski #include <svx/sdr/contact/viewcontact.hxx>
90*b1cdbd2cSJim Jagielski // <--
91*b1cdbd2cSJim Jagielski
92*b1cdbd2cSJim Jagielski #include <ndole.hxx>
93*b1cdbd2cSJim Jagielski #include <svx/charthelper.hxx>
94*b1cdbd2cSJim Jagielski #include <PostItMgr.hxx>
95*b1cdbd2cSJim Jagielski #include <tools/color.hxx>
96*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
97*b1cdbd2cSJim Jagielski
98*b1cdbd2cSJim Jagielski #define COL_NOTES_SIDEPANE RGB_COLORDATA(230,230,230)
99*b1cdbd2cSJim Jagielski #define COL_NOTES_SIDEPANE_BORDER RGB_COLORDATA(200,200,200)
100*b1cdbd2cSJim Jagielski #define COL_NOTES_SIDEPANE_SCROLLAREA RGB_COLORDATA(230,230,220)
101*b1cdbd2cSJim Jagielski
102*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
103*b1cdbd2cSJim Jagielski
104*b1cdbd2cSJim Jagielski #define GETOBJSHELL() ((SfxObjectShell*)rSh.GetDoc()->GetDocShell())
105*b1cdbd2cSJim Jagielski
106*b1cdbd2cSJim Jagielski //Tabellenhilfslinien an?
107*b1cdbd2cSJim Jagielski #define IS_SUBS_TABLE \
108*b1cdbd2cSJim Jagielski (pGlobalShell->GetViewOptions()->IsTable() && \
109*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsPagePreview()&&\
110*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsReadonly()&&\
111*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsFormView() &&\
112*b1cdbd2cSJim Jagielski SwViewOption::IsTableBoundaries())
113*b1cdbd2cSJim Jagielski //sonstige Hilfslinien an?
114*b1cdbd2cSJim Jagielski #define IS_SUBS (!pGlobalShell->GetViewOptions()->IsPagePreview() && \
115*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsReadonly() && \
116*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsFormView() &&\
117*b1cdbd2cSJim Jagielski SwViewOption::IsDocBoundaries())
118*b1cdbd2cSJim Jagielski //Hilfslinien fuer Bereiche
119*b1cdbd2cSJim Jagielski #define IS_SUBS_SECTION (!pGlobalShell->GetViewOptions()->IsPagePreview() && \
120*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsReadonly()&&\
121*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsFormView() &&\
122*b1cdbd2cSJim Jagielski SwViewOption::IsSectionBoundaries())
123*b1cdbd2cSJim Jagielski #define IS_SUBS_FLYS (!pGlobalShell->GetViewOptions()->IsPagePreview() && \
124*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsReadonly()&&\
125*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsFormView() &&\
126*b1cdbd2cSJim Jagielski SwViewOption::IsObjectBoundaries())
127*b1cdbd2cSJim Jagielski
128*b1cdbd2cSJim Jagielski #define SW_MAXBORDERCACHE 20
129*b1cdbd2cSJim Jagielski
130*b1cdbd2cSJim Jagielski //Klassendeklarationen. Hier weil sie eben nur in diesem File benoetigt
131*b1cdbd2cSJim Jagielski //werden.
132*b1cdbd2cSJim Jagielski
133*b1cdbd2cSJim Jagielski #define SUBCOL_PAGE 0x01 //Helplines of the page
134*b1cdbd2cSJim Jagielski #define SUBCOL_BREAK 0x02 //Helpline for a page or column break
135*b1cdbd2cSJim Jagielski #define SUBCOL_TAB 0x08 //Helplines inside tables
136*b1cdbd2cSJim Jagielski #define SUBCOL_FLY 0x10 //Helplines inside fly frames
137*b1cdbd2cSJim Jagielski #define SUBCOL_SECT 0x20 //Helplines inside sections
138*b1cdbd2cSJim Jagielski
139*b1cdbd2cSJim Jagielski //----- Klassen zum Sammeln von Umrandungen und Hilfslinien ---
140*b1cdbd2cSJim Jagielski class SwLineRect : public SwRect
141*b1cdbd2cSJim Jagielski {
142*b1cdbd2cSJim Jagielski const Color *pColor;
143*b1cdbd2cSJim Jagielski const SwTabFrm *pTab;
144*b1cdbd2cSJim Jagielski sal_uInt8 nSubColor; //Hilfslinien einfaerben
145*b1cdbd2cSJim Jagielski sal_Bool bPainted; //schon gepaintet?
146*b1cdbd2cSJim Jagielski sal_uInt8 nLock; //Um die Linien zum Hell-Layer abzugrenzen.
147*b1cdbd2cSJim Jagielski public:
148*b1cdbd2cSJim Jagielski SwLineRect( const SwRect &rRect, const Color *pCol,
149*b1cdbd2cSJim Jagielski const SwTabFrm *pT , const sal_uInt8 nSCol );
150*b1cdbd2cSJim Jagielski
GetColor() const151*b1cdbd2cSJim Jagielski const Color *GetColor() const { return pColor;}
GetTab() const152*b1cdbd2cSJim Jagielski const SwTabFrm *GetTab() const { return pTab; }
SetPainted()153*b1cdbd2cSJim Jagielski void SetPainted() { bPainted = sal_True; }
Lock(sal_Bool bLock)154*b1cdbd2cSJim Jagielski void Lock( sal_Bool bLock ) { if ( bLock )
155*b1cdbd2cSJim Jagielski ++nLock;
156*b1cdbd2cSJim Jagielski else if ( nLock )
157*b1cdbd2cSJim Jagielski --nLock;
158*b1cdbd2cSJim Jagielski }
IsPainted() const159*b1cdbd2cSJim Jagielski sal_Bool IsPainted() const { return bPainted; }
IsLocked() const160*b1cdbd2cSJim Jagielski sal_Bool IsLocked() const { return nLock != 0; }
GetSubColor() const161*b1cdbd2cSJim Jagielski sal_uInt8 GetSubColor() const { return nSubColor;}
162*b1cdbd2cSJim Jagielski
163*b1cdbd2cSJim Jagielski sal_Bool MakeUnion( const SwRect &rRect );
164*b1cdbd2cSJim Jagielski };
165*b1cdbd2cSJim Jagielski
166*b1cdbd2cSJim Jagielski SV_DECL_VARARR( SwLRects, SwLineRect, 100, 100 )
167*b1cdbd2cSJim Jagielski
168*b1cdbd2cSJim Jagielski class SwLineRects : public SwLRects
169*b1cdbd2cSJim Jagielski {
170*b1cdbd2cSJim Jagielski sal_uInt16 nLastCount; //unuetze Durchlaeufe im PaintLines verhindern.
171*b1cdbd2cSJim Jagielski public:
SwLineRects()172*b1cdbd2cSJim Jagielski SwLineRects() : nLastCount( 0 ) {}
173*b1cdbd2cSJim Jagielski void AddLineRect( const SwRect& rRect, const Color *pColor,
174*b1cdbd2cSJim Jagielski const SwTabFrm *pTab, const sal_uInt8 nSCol );
175*b1cdbd2cSJim Jagielski void ConnectEdges( OutputDevice *pOut );
176*b1cdbd2cSJim Jagielski void PaintLines ( OutputDevice *pOut );
177*b1cdbd2cSJim Jagielski void LockLines( sal_Bool bLock );
178*b1cdbd2cSJim Jagielski
179*b1cdbd2cSJim Jagielski /// OD 13.08.2002 - correct type of function
Free() const180*b1cdbd2cSJim Jagielski sal_uInt16 Free() const { return nFree; }
181*b1cdbd2cSJim Jagielski };
182*b1cdbd2cSJim Jagielski
183*b1cdbd2cSJim Jagielski class SwSubsRects : public SwLineRects
184*b1cdbd2cSJim Jagielski {
185*b1cdbd2cSJim Jagielski void RemoveSuperfluousSubsidiaryLines( const SwLineRects &rRects ); //;-)
186*b1cdbd2cSJim Jagielski public:
187*b1cdbd2cSJim Jagielski void PaintSubsidiary( OutputDevice *pOut, const SwLineRects *pRects );
188*b1cdbd2cSJim Jagielski
189*b1cdbd2cSJim Jagielski inline void Ins( const SwRect &rRect, const sal_uInt8 nSCol );
190*b1cdbd2cSJim Jagielski };
191*b1cdbd2cSJim Jagielski
192*b1cdbd2cSJim Jagielski //----------------- End Klassen Umrandungen ----------------------
193*b1cdbd2cSJim Jagielski
194*b1cdbd2cSJim Jagielski static ViewShell *pGlobalShell = 0;
195*b1cdbd2cSJim Jagielski
196*b1cdbd2cSJim Jagielski //Wenn durchsichtige FlyInCnts im PaintBackground gepainted werden so soll der
197*b1cdbd2cSJim Jagielski //Hintergrund nicht mehr retouchiert werden.
198*b1cdbd2cSJim Jagielski //static sal_Bool bLockFlyBackground = sal_False;
199*b1cdbd2cSJim Jagielski
200*b1cdbd2cSJim Jagielski //Wenn vom Fly ein Metafile abgezogen wird, so soll nur der FlyInhalt und vor
201*b1cdbd2cSJim Jagielski //nur hintergrund vom FlyInhalt gepaintet werden.
202*b1cdbd2cSJim Jagielski static sal_Bool bFlyMetafile = sal_False;
203*b1cdbd2cSJim Jagielski static OutputDevice *pFlyMetafileOut = 0;
204*b1cdbd2cSJim Jagielski
205*b1cdbd2cSJim Jagielski //Die Retouche fuer Durchsichtige Flys wird vom Hintergrund der Flys
206*b1cdbd2cSJim Jagielski //erledigt. Dabei darf der Fly selbst natuerlich nicht ausgespart werden.
207*b1cdbd2cSJim Jagielski //siehe PaintBackground und lcl_SubtractFlys()
208*b1cdbd2cSJim Jagielski static SwFlyFrm *pRetoucheFly = 0;
209*b1cdbd2cSJim Jagielski static SwFlyFrm *pRetoucheFly2 = 0;
210*b1cdbd2cSJim Jagielski
211*b1cdbd2cSJim Jagielski //Groesse eines Pixel und die Haelfte davon. Wird jeweils bei Eintritt in
212*b1cdbd2cSJim Jagielski //SwRootFrm::Paint neu gesetzt.
213*b1cdbd2cSJim Jagielski static long nPixelSzW = 0, nPixelSzH = 0;
214*b1cdbd2cSJim Jagielski static long nHalfPixelSzW = 0, nHalfPixelSzH = 0;
215*b1cdbd2cSJim Jagielski static long nMinDistPixelW = 0, nMinDistPixelH = 0;
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski //Aktueller Zoomfaktor
218*b1cdbd2cSJim Jagielski static double aScaleX = 1.0;
219*b1cdbd2cSJim Jagielski static double aScaleY = 1.0;
220*b1cdbd2cSJim Jagielski static double aMinDistScale = 0.73;
221*b1cdbd2cSJim Jagielski static double aEdgeScale = 0.5;
222*b1cdbd2cSJim Jagielski
223*b1cdbd2cSJim Jagielski
224*b1cdbd2cSJim Jagielski //In pLines werden Umrandungen waehrend des Paint gesammelt und soweit
225*b1cdbd2cSJim Jagielski //moeglich zusammengefasst.
226*b1cdbd2cSJim Jagielski //In pSubsLines werden Hilfslinien gesammelt und zusammengefasst. Diese
227*b1cdbd2cSJim Jagielski //werden vor der Ausgabe mit pLines abgeglichen, so dass moeglichst keine
228*b1cdbd2cSJim Jagielski //Umrandungen von den Hilfslinen verdeckt werden.
229*b1cdbd2cSJim Jagielski //bTablines ist waerend des Paints einer Tabelle sal_True.
230*b1cdbd2cSJim Jagielski static SwLineRects *pLines = 0;
231*b1cdbd2cSJim Jagielski static SwSubsRects *pSubsLines = 0;
232*b1cdbd2cSJim Jagielski // OD 18.11.2002 #99672# - global variable for sub-lines of body, header, footer,
233*b1cdbd2cSJim Jagielski // section and footnote frames.
234*b1cdbd2cSJim Jagielski static SwSubsRects *pSpecSubsLines = 0;
235*b1cdbd2cSJim Jagielski
236*b1cdbd2cSJim Jagielski static SfxProgress *pProgress = 0;
237*b1cdbd2cSJim Jagielski
238*b1cdbd2cSJim Jagielski static SwFlyFrm *pFlyOnlyDraw = 0;
239*b1cdbd2cSJim Jagielski
240*b1cdbd2cSJim Jagielski //Damit die Flys auch fuer den Hack richtig gepaintet werden koennen.
241*b1cdbd2cSJim Jagielski static sal_Bool bTableHack = sal_False;
242*b1cdbd2cSJim Jagielski
243*b1cdbd2cSJim Jagielski //Um das teure Ermitteln der RetoucheColor zu optimieren
244*b1cdbd2cSJim Jagielski Color aGlobalRetoucheColor;
245*b1cdbd2cSJim Jagielski
246*b1cdbd2cSJim Jagielski //Statics fuer Umrandungsalignment setzen.
247*b1cdbd2cSJim Jagielski // OD 05.05.2003 #107169# - adjustment for 'small' twip-to-pixel relations:
248*b1cdbd2cSJim Jagielski // For 'small' twip-to-pixel relations (less then 2:1)
249*b1cdbd2cSJim Jagielski // values of <nHalfPixelSzW> and <nHalfPixelSzH> are set to ZERO.
SwCalcPixStatics(OutputDevice * pOut)250*b1cdbd2cSJim Jagielski void SwCalcPixStatics( OutputDevice *pOut )
251*b1cdbd2cSJim Jagielski {
252*b1cdbd2cSJim Jagielski // OD 30.04.2003 #107169# - determine 'small' twip-to-pixel relation
253*b1cdbd2cSJim Jagielski sal_Bool bSmallTwipToPxRelW = sal_False;
254*b1cdbd2cSJim Jagielski sal_Bool bSmallTwipToPxRelH = sal_False;
255*b1cdbd2cSJim Jagielski {
256*b1cdbd2cSJim Jagielski Size aCheckTwipToPxRelSz( pOut->PixelToLogic( Size( 100, 100 )) );
257*b1cdbd2cSJim Jagielski if ( (aCheckTwipToPxRelSz.Width()/100.0) < 2.0 )
258*b1cdbd2cSJim Jagielski {
259*b1cdbd2cSJim Jagielski bSmallTwipToPxRelW = sal_True;
260*b1cdbd2cSJim Jagielski }
261*b1cdbd2cSJim Jagielski if ( (aCheckTwipToPxRelSz.Height()/100.0) < 2.0 )
262*b1cdbd2cSJim Jagielski {
263*b1cdbd2cSJim Jagielski bSmallTwipToPxRelH = sal_True;
264*b1cdbd2cSJim Jagielski }
265*b1cdbd2cSJim Jagielski }
266*b1cdbd2cSJim Jagielski
267*b1cdbd2cSJim Jagielski Size aSz( pOut->PixelToLogic( Size( 1,1 )) );
268*b1cdbd2cSJim Jagielski
269*b1cdbd2cSJim Jagielski nPixelSzW = aSz.Width();
270*b1cdbd2cSJim Jagielski if( !nPixelSzW )
271*b1cdbd2cSJim Jagielski nPixelSzW = 1;
272*b1cdbd2cSJim Jagielski nPixelSzH = aSz.Height();
273*b1cdbd2cSJim Jagielski if( !nPixelSzH )
274*b1cdbd2cSJim Jagielski nPixelSzH = 1;
275*b1cdbd2cSJim Jagielski
276*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - consider 'small' twip-to-pixel relations
277*b1cdbd2cSJim Jagielski if ( !bSmallTwipToPxRelW )
278*b1cdbd2cSJim Jagielski {
279*b1cdbd2cSJim Jagielski nHalfPixelSzW = nPixelSzW / 2 + 1;
280*b1cdbd2cSJim Jagielski }
281*b1cdbd2cSJim Jagielski else
282*b1cdbd2cSJim Jagielski {
283*b1cdbd2cSJim Jagielski nHalfPixelSzW = 0;
284*b1cdbd2cSJim Jagielski }
285*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - consider 'small' twip-to-pixel relations
286*b1cdbd2cSJim Jagielski if ( !bSmallTwipToPxRelH )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski nHalfPixelSzH = nPixelSzH / 2 + 1;
289*b1cdbd2cSJim Jagielski }
290*b1cdbd2cSJim Jagielski else
291*b1cdbd2cSJim Jagielski {
292*b1cdbd2cSJim Jagielski nHalfPixelSzH = 0;
293*b1cdbd2cSJim Jagielski }
294*b1cdbd2cSJim Jagielski
295*b1cdbd2cSJim Jagielski nMinDistPixelW = nPixelSzW * 2 + 1;
296*b1cdbd2cSJim Jagielski nMinDistPixelH = nPixelSzH * 2 + 1;
297*b1cdbd2cSJim Jagielski
298*b1cdbd2cSJim Jagielski const MapMode &rMap = pOut->GetMapMode();
299*b1cdbd2cSJim Jagielski aScaleX = rMap.GetScaleX();
300*b1cdbd2cSJim Jagielski aScaleY = rMap.GetScaleY();
301*b1cdbd2cSJim Jagielski }
302*b1cdbd2cSJim Jagielski
303*b1cdbd2cSJim Jagielski //Zum Sichern der statics, damit das Paint (quasi) reentrant wird.
304*b1cdbd2cSJim Jagielski class SwSavePaintStatics
305*b1cdbd2cSJim Jagielski {
306*b1cdbd2cSJim Jagielski sal_Bool bSFlyMetafile,
307*b1cdbd2cSJim Jagielski bSPageOnly;
308*b1cdbd2cSJim Jagielski ViewShell *pSGlobalShell;
309*b1cdbd2cSJim Jagielski OutputDevice *pSFlyMetafileOut;
310*b1cdbd2cSJim Jagielski SwFlyFrm *pSRetoucheFly,
311*b1cdbd2cSJim Jagielski *pSRetoucheFly2,
312*b1cdbd2cSJim Jagielski *pSFlyOnlyDraw;
313*b1cdbd2cSJim Jagielski SwLineRects *pSLines;
314*b1cdbd2cSJim Jagielski SwSubsRects *pSSubsLines;
315*b1cdbd2cSJim Jagielski // --> OD 2005-07-04 #123196#
316*b1cdbd2cSJim Jagielski SwSubsRects* pSSpecSubsLines;
317*b1cdbd2cSJim Jagielski // <--
318*b1cdbd2cSJim Jagielski SfxProgress *pSProgress;
319*b1cdbd2cSJim Jagielski long nSPixelSzW,
320*b1cdbd2cSJim Jagielski nSPixelSzH,
321*b1cdbd2cSJim Jagielski nSHalfPixelSzW,
322*b1cdbd2cSJim Jagielski nSHalfPixelSzH,
323*b1cdbd2cSJim Jagielski nSMinDistPixelW,
324*b1cdbd2cSJim Jagielski nSMinDistPixelH;
325*b1cdbd2cSJim Jagielski Color aSGlobalRetoucheColor;
326*b1cdbd2cSJim Jagielski double aSScaleX,
327*b1cdbd2cSJim Jagielski aSScaleY;
328*b1cdbd2cSJim Jagielski public:
329*b1cdbd2cSJim Jagielski SwSavePaintStatics();
330*b1cdbd2cSJim Jagielski ~SwSavePaintStatics();
331*b1cdbd2cSJim Jagielski };
332*b1cdbd2cSJim Jagielski
SwSavePaintStatics()333*b1cdbd2cSJim Jagielski SwSavePaintStatics::SwSavePaintStatics() :
334*b1cdbd2cSJim Jagielski bSFlyMetafile ( bFlyMetafile ),
335*b1cdbd2cSJim Jagielski pSGlobalShell ( pGlobalShell ),
336*b1cdbd2cSJim Jagielski pSFlyMetafileOut ( pFlyMetafileOut ),
337*b1cdbd2cSJim Jagielski pSRetoucheFly ( pRetoucheFly ),
338*b1cdbd2cSJim Jagielski pSRetoucheFly2 ( pRetoucheFly2 ),
339*b1cdbd2cSJim Jagielski pSFlyOnlyDraw ( pFlyOnlyDraw ),
340*b1cdbd2cSJim Jagielski pSLines ( pLines ),
341*b1cdbd2cSJim Jagielski pSSubsLines ( pSubsLines ),
342*b1cdbd2cSJim Jagielski // --> OD 2005-07-04 #123196#
343*b1cdbd2cSJim Jagielski pSSpecSubsLines ( pSpecSubsLines ),
344*b1cdbd2cSJim Jagielski // <--
345*b1cdbd2cSJim Jagielski pSProgress ( pProgress ),
346*b1cdbd2cSJim Jagielski nSPixelSzW ( nPixelSzW ),
347*b1cdbd2cSJim Jagielski nSPixelSzH ( nPixelSzH ),
348*b1cdbd2cSJim Jagielski nSHalfPixelSzW ( nHalfPixelSzW ),
349*b1cdbd2cSJim Jagielski nSHalfPixelSzH ( nHalfPixelSzH ),
350*b1cdbd2cSJim Jagielski nSMinDistPixelW ( nMinDistPixelW ),
351*b1cdbd2cSJim Jagielski nSMinDistPixelH ( nMinDistPixelH ),
352*b1cdbd2cSJim Jagielski aSGlobalRetoucheColor( aGlobalRetoucheColor ),
353*b1cdbd2cSJim Jagielski aSScaleX ( aScaleX ),
354*b1cdbd2cSJim Jagielski aSScaleY ( aScaleY )
355*b1cdbd2cSJim Jagielski {
356*b1cdbd2cSJim Jagielski bFlyMetafile = sal_False;
357*b1cdbd2cSJim Jagielski pFlyMetafileOut = 0;
358*b1cdbd2cSJim Jagielski pRetoucheFly = 0;
359*b1cdbd2cSJim Jagielski pRetoucheFly2 = 0;
360*b1cdbd2cSJim Jagielski nPixelSzW = nPixelSzH =
361*b1cdbd2cSJim Jagielski nHalfPixelSzW = nHalfPixelSzH =
362*b1cdbd2cSJim Jagielski nMinDistPixelW = nMinDistPixelH = 0;
363*b1cdbd2cSJim Jagielski aScaleX = aScaleY = 1.0;
364*b1cdbd2cSJim Jagielski aMinDistScale = 0.73;
365*b1cdbd2cSJim Jagielski aEdgeScale = 0.5;
366*b1cdbd2cSJim Jagielski pLines = 0;
367*b1cdbd2cSJim Jagielski pSubsLines = 0;
368*b1cdbd2cSJim Jagielski // --> OD 2005-07-04 #123196#
369*b1cdbd2cSJim Jagielski pSpecSubsLines = 0L;
370*b1cdbd2cSJim Jagielski // <--
371*b1cdbd2cSJim Jagielski pProgress = 0;
372*b1cdbd2cSJim Jagielski }
373*b1cdbd2cSJim Jagielski
~SwSavePaintStatics()374*b1cdbd2cSJim Jagielski SwSavePaintStatics::~SwSavePaintStatics()
375*b1cdbd2cSJim Jagielski {
376*b1cdbd2cSJim Jagielski pGlobalShell = pSGlobalShell;
377*b1cdbd2cSJim Jagielski bFlyMetafile = bSFlyMetafile;
378*b1cdbd2cSJim Jagielski pFlyMetafileOut = pSFlyMetafileOut;
379*b1cdbd2cSJim Jagielski pRetoucheFly = pSRetoucheFly;
380*b1cdbd2cSJim Jagielski pRetoucheFly2 = pSRetoucheFly2;
381*b1cdbd2cSJim Jagielski pFlyOnlyDraw = pSFlyOnlyDraw;
382*b1cdbd2cSJim Jagielski pLines = pSLines;
383*b1cdbd2cSJim Jagielski pSubsLines = pSSubsLines;
384*b1cdbd2cSJim Jagielski // --> OD 2005-07-04 #123196#
385*b1cdbd2cSJim Jagielski pSpecSubsLines = pSSpecSubsLines;
386*b1cdbd2cSJim Jagielski // <--
387*b1cdbd2cSJim Jagielski pProgress = pSProgress;
388*b1cdbd2cSJim Jagielski nPixelSzW = nSPixelSzW;
389*b1cdbd2cSJim Jagielski nPixelSzH = nSPixelSzH;
390*b1cdbd2cSJim Jagielski nHalfPixelSzW = nSHalfPixelSzW;
391*b1cdbd2cSJim Jagielski nHalfPixelSzH = nSHalfPixelSzH;
392*b1cdbd2cSJim Jagielski nMinDistPixelW = nSMinDistPixelW;
393*b1cdbd2cSJim Jagielski nMinDistPixelH = nSMinDistPixelH;
394*b1cdbd2cSJim Jagielski aGlobalRetoucheColor = aSGlobalRetoucheColor;
395*b1cdbd2cSJim Jagielski aScaleX = aSScaleX;
396*b1cdbd2cSJim Jagielski aScaleY = aSScaleY;
397*b1cdbd2cSJim Jagielski }
398*b1cdbd2cSJim Jagielski
399*b1cdbd2cSJim Jagielski //----------------- Implementierungen fuer Tabellenumrandung --------------
400*b1cdbd2cSJim Jagielski
401*b1cdbd2cSJim Jagielski SV_IMPL_VARARR( SwLRects, SwLineRect );
402*b1cdbd2cSJim Jagielski
403*b1cdbd2cSJim Jagielski
SwLineRect(const SwRect & rRect,const Color * pCol,const SwTabFrm * pT,const sal_uInt8 nSCol)404*b1cdbd2cSJim Jagielski SwLineRect::SwLineRect( const SwRect &rRect, const Color *pCol,
405*b1cdbd2cSJim Jagielski const SwTabFrm *pT, const sal_uInt8 nSCol ) :
406*b1cdbd2cSJim Jagielski SwRect( rRect ),
407*b1cdbd2cSJim Jagielski pColor( pCol ),
408*b1cdbd2cSJim Jagielski pTab( pT ),
409*b1cdbd2cSJim Jagielski nSubColor( nSCol ),
410*b1cdbd2cSJim Jagielski bPainted( sal_False ),
411*b1cdbd2cSJim Jagielski nLock( 0 )
412*b1cdbd2cSJim Jagielski {
413*b1cdbd2cSJim Jagielski }
414*b1cdbd2cSJim Jagielski
MakeUnion(const SwRect & rRect)415*b1cdbd2cSJim Jagielski sal_Bool SwLineRect::MakeUnion( const SwRect &rRect )
416*b1cdbd2cSJim Jagielski {
417*b1cdbd2cSJim Jagielski //Es wurde bereits ausserhalb geprueft, ob die Rechtecke die gleiche
418*b1cdbd2cSJim Jagielski //Ausrichtung (horizontal bzw. vertikal), Farbe usw. besitzen.
419*b1cdbd2cSJim Jagielski if ( Height() > Width() ) //Vertikale Linie
420*b1cdbd2cSJim Jagielski {
421*b1cdbd2cSJim Jagielski if ( Left() == rRect.Left() && Width() == rRect.Width() )
422*b1cdbd2cSJim Jagielski {
423*b1cdbd2cSJim Jagielski //Zusammenfassen wenn kein Luecke zwischen den Linien ist.
424*b1cdbd2cSJim Jagielski const long nAdd = nPixelSzW + nHalfPixelSzW;
425*b1cdbd2cSJim Jagielski if ( Bottom() + nAdd >= rRect.Top() &&
426*b1cdbd2cSJim Jagielski Top() - nAdd <= rRect.Bottom() )
427*b1cdbd2cSJim Jagielski {
428*b1cdbd2cSJim Jagielski Bottom( Max( Bottom(), rRect.Bottom() ) );
429*b1cdbd2cSJim Jagielski Top ( Min( Top(), rRect.Top() ) );
430*b1cdbd2cSJim Jagielski return sal_True;
431*b1cdbd2cSJim Jagielski }
432*b1cdbd2cSJim Jagielski }
433*b1cdbd2cSJim Jagielski }
434*b1cdbd2cSJim Jagielski else
435*b1cdbd2cSJim Jagielski {
436*b1cdbd2cSJim Jagielski if ( Top() == rRect.Top() && Height() == rRect.Height() )
437*b1cdbd2cSJim Jagielski {
438*b1cdbd2cSJim Jagielski //Zusammenfassen wenn kein Luecke zwischen den Linien ist.
439*b1cdbd2cSJim Jagielski const long nAdd = nPixelSzW + nHalfPixelSzW;
440*b1cdbd2cSJim Jagielski if ( Right() + nAdd >= rRect.Left() &&
441*b1cdbd2cSJim Jagielski Left() - nAdd <= rRect.Right() )
442*b1cdbd2cSJim Jagielski {
443*b1cdbd2cSJim Jagielski Right( Max( Right(), rRect.Right() ) );
444*b1cdbd2cSJim Jagielski Left ( Min( Left(), rRect.Left() ) );
445*b1cdbd2cSJim Jagielski return sal_True;
446*b1cdbd2cSJim Jagielski }
447*b1cdbd2cSJim Jagielski }
448*b1cdbd2cSJim Jagielski }
449*b1cdbd2cSJim Jagielski return sal_False;
450*b1cdbd2cSJim Jagielski }
451*b1cdbd2cSJim Jagielski
AddLineRect(const SwRect & rRect,const Color * pCol,const SwTabFrm * pTab,const sal_uInt8 nSCol)452*b1cdbd2cSJim Jagielski void SwLineRects::AddLineRect( const SwRect &rRect, const Color *pCol,
453*b1cdbd2cSJim Jagielski const SwTabFrm *pTab, const sal_uInt8 nSCol )
454*b1cdbd2cSJim Jagielski {
455*b1cdbd2cSJim Jagielski //Rueckwaerts durch, weil Linien die zusammengefasst werden koennen i.d.R.
456*b1cdbd2cSJim Jagielski //im gleichen Kontext gepaintet werden.
457*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = Count(); i ; )
458*b1cdbd2cSJim Jagielski {
459*b1cdbd2cSJim Jagielski SwLineRect &rLRect = operator[](--i);
460*b1cdbd2cSJim Jagielski //Pruefen von Ausrichtung, Farbe, Tabelle.
461*b1cdbd2cSJim Jagielski if ( rLRect.GetTab() == pTab &&
462*b1cdbd2cSJim Jagielski !rLRect.IsPainted() && rLRect.GetSubColor() == nSCol &&
463*b1cdbd2cSJim Jagielski (rLRect.Height() > rLRect.Width()) == (rRect.Height() > rRect.Width()) &&
464*b1cdbd2cSJim Jagielski ((!rLRect.GetColor() && !pCol) ||
465*b1cdbd2cSJim Jagielski (rLRect.GetColor() && pCol && *rLRect.GetColor() == *pCol)) )
466*b1cdbd2cSJim Jagielski {
467*b1cdbd2cSJim Jagielski if ( rLRect.MakeUnion( rRect ) )
468*b1cdbd2cSJim Jagielski return;
469*b1cdbd2cSJim Jagielski }
470*b1cdbd2cSJim Jagielski }
471*b1cdbd2cSJim Jagielski Insert( SwLineRect( rRect, pCol, pTab, nSCol ), Count() );
472*b1cdbd2cSJim Jagielski }
473*b1cdbd2cSJim Jagielski
ConnectEdges(OutputDevice * pOut)474*b1cdbd2cSJim Jagielski void SwLineRects::ConnectEdges( OutputDevice *pOut )
475*b1cdbd2cSJim Jagielski {
476*b1cdbd2cSJim Jagielski if ( pOut->GetOutDevType() != OUTDEV_PRINTER )
477*b1cdbd2cSJim Jagielski {
478*b1cdbd2cSJim Jagielski //Fuer einen zu kleinen Zoom arbeite ich nicht.
479*b1cdbd2cSJim Jagielski if ( aScaleX < aEdgeScale || aScaleY < aEdgeScale )
480*b1cdbd2cSJim Jagielski return;
481*b1cdbd2cSJim Jagielski }
482*b1cdbd2cSJim Jagielski
483*b1cdbd2cSJim Jagielski static const long nAdd = 20;
484*b1cdbd2cSJim Jagielski
485*b1cdbd2cSJim Jagielski SvPtrarr aCheck( 64, 64 );
486*b1cdbd2cSJim Jagielski
487*b1cdbd2cSJim Jagielski for ( int i = 0; i < (int)Count(); ++i )
488*b1cdbd2cSJim Jagielski {
489*b1cdbd2cSJim Jagielski SwLineRect &rL1 = operator[](sal_uInt16(i));
490*b1cdbd2cSJim Jagielski if ( !rL1.GetTab() || rL1.IsPainted() || rL1.IsLocked() )
491*b1cdbd2cSJim Jagielski continue;
492*b1cdbd2cSJim Jagielski
493*b1cdbd2cSJim Jagielski aCheck.Remove( 0, aCheck.Count() );
494*b1cdbd2cSJim Jagielski
495*b1cdbd2cSJim Jagielski const sal_Bool bVert = rL1.Height() > rL1.Width();
496*b1cdbd2cSJim Jagielski long nL1a, nL1b, nL1c, nL1d;
497*b1cdbd2cSJim Jagielski
498*b1cdbd2cSJim Jagielski if ( bVert )
499*b1cdbd2cSJim Jagielski {
500*b1cdbd2cSJim Jagielski nL1a = rL1.Top(); nL1b = rL1.Left();
501*b1cdbd2cSJim Jagielski nL1c = rL1.Right(); nL1d = rL1.Bottom();
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski else
504*b1cdbd2cSJim Jagielski {
505*b1cdbd2cSJim Jagielski nL1a = rL1.Left(); nL1b = rL1.Top();
506*b1cdbd2cSJim Jagielski nL1c = rL1.Bottom(); nL1d = rL1.Right();
507*b1cdbd2cSJim Jagielski }
508*b1cdbd2cSJim Jagielski
509*b1cdbd2cSJim Jagielski //Alle moeglicherweise mit i1 zu verbindenden Linien einsammeln.
510*b1cdbd2cSJim Jagielski for ( sal_uInt16 i2 = 0; i2 < Count(); ++i2 )
511*b1cdbd2cSJim Jagielski {
512*b1cdbd2cSJim Jagielski SwLineRect &rL2 = operator[](i2);
513*b1cdbd2cSJim Jagielski if ( rL2.GetTab() != rL1.GetTab() ||
514*b1cdbd2cSJim Jagielski rL2.IsPainted() ||
515*b1cdbd2cSJim Jagielski rL2.IsLocked() ||
516*b1cdbd2cSJim Jagielski (bVert == (rL2.Height() > rL2.Width())) )
517*b1cdbd2cSJim Jagielski continue;
518*b1cdbd2cSJim Jagielski
519*b1cdbd2cSJim Jagielski long nL2a, nL2b, nL2c, nL2d;
520*b1cdbd2cSJim Jagielski if ( bVert )
521*b1cdbd2cSJim Jagielski {
522*b1cdbd2cSJim Jagielski nL2a = rL2.Top(); nL2b = rL2.Left();
523*b1cdbd2cSJim Jagielski nL2c = rL2.Right(); nL2d = rL2.Bottom();
524*b1cdbd2cSJim Jagielski }
525*b1cdbd2cSJim Jagielski else
526*b1cdbd2cSJim Jagielski {
527*b1cdbd2cSJim Jagielski nL2a = rL2.Left(); nL2b = rL2.Top();
528*b1cdbd2cSJim Jagielski nL2c = rL2.Bottom(); nL2d = rL2.Right();
529*b1cdbd2cSJim Jagielski }
530*b1cdbd2cSJim Jagielski
531*b1cdbd2cSJim Jagielski if ( (nL1a - nAdd < nL2d && nL1d + nAdd > nL2a) &&
532*b1cdbd2cSJim Jagielski ((nL1b > nL2b && nL1c < nL2c) ||
533*b1cdbd2cSJim Jagielski (nL1c >= nL2c && nL1b - nAdd < nL2c) ||
534*b1cdbd2cSJim Jagielski (nL1b <= nL2b && nL1c + nAdd > nL2b)) )
535*b1cdbd2cSJim Jagielski {
536*b1cdbd2cSJim Jagielski SwLineRect *pMSC = &rL2;
537*b1cdbd2cSJim Jagielski aCheck.Insert( pMSC, aCheck.Count() );
538*b1cdbd2cSJim Jagielski }
539*b1cdbd2cSJim Jagielski }
540*b1cdbd2cSJim Jagielski if ( aCheck.Count() < 2 )
541*b1cdbd2cSJim Jagielski continue;
542*b1cdbd2cSJim Jagielski
543*b1cdbd2cSJim Jagielski sal_Bool bRemove = sal_False;
544*b1cdbd2cSJim Jagielski
545*b1cdbd2cSJim Jagielski //Fuer jede Linie jede alle folgenden checken.
546*b1cdbd2cSJim Jagielski for ( sal_uInt16 k = 0; !bRemove && k < aCheck.Count(); ++k )
547*b1cdbd2cSJim Jagielski {
548*b1cdbd2cSJim Jagielski SwLineRect &rR1 = (SwLineRect&)*(SwLineRect*)aCheck[k];
549*b1cdbd2cSJim Jagielski
550*b1cdbd2cSJim Jagielski for ( sal_uInt16 k2 = k+1; !bRemove && k2 < aCheck.Count(); ++k2 )
551*b1cdbd2cSJim Jagielski {
552*b1cdbd2cSJim Jagielski SwLineRect &rR2 = (SwLineRect&)*(SwLineRect*)aCheck[k2];
553*b1cdbd2cSJim Jagielski if ( bVert )
554*b1cdbd2cSJim Jagielski {
555*b1cdbd2cSJim Jagielski SwLineRect *pLA = 0;
556*b1cdbd2cSJim Jagielski SwLineRect *pLB = 0;
557*b1cdbd2cSJim Jagielski if ( rR1.Top() < rR2.Top() )
558*b1cdbd2cSJim Jagielski {
559*b1cdbd2cSJim Jagielski pLA = &rR1; pLB = &rR2;
560*b1cdbd2cSJim Jagielski }
561*b1cdbd2cSJim Jagielski else if ( rR1.Top() > rR2.Top() )
562*b1cdbd2cSJim Jagielski {
563*b1cdbd2cSJim Jagielski pLA = &rR2; pLB = &rR1;
564*b1cdbd2cSJim Jagielski }
565*b1cdbd2cSJim Jagielski //beschreiben k1 und k2 eine Doppellinie?
566*b1cdbd2cSJim Jagielski if ( pLA && pLA->Bottom() + 60 > pLB->Top() )
567*b1cdbd2cSJim Jagielski {
568*b1cdbd2cSJim Jagielski if ( rL1.Top() < pLA->Top() )
569*b1cdbd2cSJim Jagielski {
570*b1cdbd2cSJim Jagielski if ( rL1.Bottom() == pLA->Bottom() )
571*b1cdbd2cSJim Jagielski continue; //kleiner Irrtum (woher?)
572*b1cdbd2cSJim Jagielski
573*b1cdbd2cSJim Jagielski SwRect aIns( rL1 );
574*b1cdbd2cSJim Jagielski aIns.Bottom( pLA->Bottom() );
575*b1cdbd2cSJim Jagielski if ( !rL1.IsInside( aIns ) )
576*b1cdbd2cSJim Jagielski continue;
577*b1cdbd2cSJim Jagielski const sal_uInt16 nTmpFree = Free();
578*b1cdbd2cSJim Jagielski Insert( SwLineRect( aIns, rL1.GetColor(),
579*b1cdbd2cSJim Jagielski rL1.GetTab(), SUBCOL_TAB ), Count() );
580*b1cdbd2cSJim Jagielski if ( !nTmpFree )
581*b1cdbd2cSJim Jagielski {
582*b1cdbd2cSJim Jagielski --i;
583*b1cdbd2cSJim Jagielski k = aCheck.Count();
584*b1cdbd2cSJim Jagielski break;
585*b1cdbd2cSJim Jagielski }
586*b1cdbd2cSJim Jagielski }
587*b1cdbd2cSJim Jagielski
588*b1cdbd2cSJim Jagielski if ( rL1.Bottom() > pLB->Bottom() )
589*b1cdbd2cSJim Jagielski rL1.Top( pLB->Top() ); //i1 nach oben verlaengern
590*b1cdbd2cSJim Jagielski else
591*b1cdbd2cSJim Jagielski bRemove = sal_True; //abbrechen, i1 entfernen
592*b1cdbd2cSJim Jagielski }
593*b1cdbd2cSJim Jagielski }
594*b1cdbd2cSJim Jagielski else
595*b1cdbd2cSJim Jagielski {
596*b1cdbd2cSJim Jagielski SwLineRect *pLA = 0;
597*b1cdbd2cSJim Jagielski SwLineRect *pLB = 0;
598*b1cdbd2cSJim Jagielski if ( rR1.Left() < rR2.Left() )
599*b1cdbd2cSJim Jagielski {
600*b1cdbd2cSJim Jagielski pLA = &rR1; pLB = &rR2;
601*b1cdbd2cSJim Jagielski }
602*b1cdbd2cSJim Jagielski else if ( rR1.Left() > rR2.Left() )
603*b1cdbd2cSJim Jagielski {
604*b1cdbd2cSJim Jagielski pLA = &rR2; pLB = &rR1;
605*b1cdbd2cSJim Jagielski }
606*b1cdbd2cSJim Jagielski //Liegt eine 'doppellinie' vor?
607*b1cdbd2cSJim Jagielski if ( pLA && pLA->Right() + 60 > pLB->Left() )
608*b1cdbd2cSJim Jagielski {
609*b1cdbd2cSJim Jagielski if ( rL1.Left() < pLA->Left() )
610*b1cdbd2cSJim Jagielski {
611*b1cdbd2cSJim Jagielski if ( rL1.Right() == pLA->Right() )
612*b1cdbd2cSJim Jagielski continue; //kleiner irrtum
613*b1cdbd2cSJim Jagielski
614*b1cdbd2cSJim Jagielski SwRect aIns( rL1 );
615*b1cdbd2cSJim Jagielski aIns.Right( pLA->Right() );
616*b1cdbd2cSJim Jagielski if ( !rL1.IsInside( aIns ) )
617*b1cdbd2cSJim Jagielski continue;
618*b1cdbd2cSJim Jagielski const sal_uInt16 nTmpFree = Free();
619*b1cdbd2cSJim Jagielski Insert( SwLineRect( aIns, rL1.GetColor(),
620*b1cdbd2cSJim Jagielski rL1.GetTab(), SUBCOL_TAB ), Count() );
621*b1cdbd2cSJim Jagielski if ( !nTmpFree )
622*b1cdbd2cSJim Jagielski {
623*b1cdbd2cSJim Jagielski --i;
624*b1cdbd2cSJim Jagielski k = aCheck.Count();
625*b1cdbd2cSJim Jagielski break;
626*b1cdbd2cSJim Jagielski }
627*b1cdbd2cSJim Jagielski }
628*b1cdbd2cSJim Jagielski if ( rL1.Right() > pLB->Right() )
629*b1cdbd2cSJim Jagielski rL1.Left( pLB->Left() );
630*b1cdbd2cSJim Jagielski else
631*b1cdbd2cSJim Jagielski bRemove = sal_True;
632*b1cdbd2cSJim Jagielski }
633*b1cdbd2cSJim Jagielski }
634*b1cdbd2cSJim Jagielski }
635*b1cdbd2cSJim Jagielski }
636*b1cdbd2cSJim Jagielski if ( bRemove )
637*b1cdbd2cSJim Jagielski {
638*b1cdbd2cSJim Jagielski Remove( static_cast<sal_uInt16>(i), 1 );
639*b1cdbd2cSJim Jagielski --i; //keinen auslassen!
640*b1cdbd2cSJim Jagielski }
641*b1cdbd2cSJim Jagielski }
642*b1cdbd2cSJim Jagielski }
643*b1cdbd2cSJim Jagielski
Ins(const SwRect & rRect,const sal_uInt8 nSCol)644*b1cdbd2cSJim Jagielski inline void SwSubsRects::Ins( const SwRect &rRect, const sal_uInt8 nSCol )
645*b1cdbd2cSJim Jagielski {
646*b1cdbd2cSJim Jagielski //Linien die kuerzer als die breiteste Linienbreite sind werden
647*b1cdbd2cSJim Jagielski //nicht aufgenommen.
648*b1cdbd2cSJim Jagielski if ( rRect.Height() > DEF_LINE_WIDTH_4 || rRect.Width() > DEF_LINE_WIDTH_4 )
649*b1cdbd2cSJim Jagielski Insert( SwLineRect( rRect, 0, 0, nSCol ), Count());
650*b1cdbd2cSJim Jagielski }
651*b1cdbd2cSJim Jagielski
RemoveSuperfluousSubsidiaryLines(const SwLineRects & rRects)652*b1cdbd2cSJim Jagielski void SwSubsRects::RemoveSuperfluousSubsidiaryLines( const SwLineRects &rRects )
653*b1cdbd2cSJim Jagielski {
654*b1cdbd2cSJim Jagielski //Alle Hilfslinien, die sich mit irgendwelchen Umrandungen decken werden
655*b1cdbd2cSJim Jagielski //entfernt bzw. zerstueckelt..
656*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < Count(); ++i )
657*b1cdbd2cSJim Jagielski {
658*b1cdbd2cSJim Jagielski // OD 18.11.2002 #99672# - get a copy instead of a reference, because
659*b1cdbd2cSJim Jagielski // an <insert> may destroy the object due to a necessary array resize.
660*b1cdbd2cSJim Jagielski const SwLineRect aSubsLineRect = SwLineRect( operator[](i) );
661*b1cdbd2cSJim Jagielski
662*b1cdbd2cSJim Jagielski // OD 19.12.2002 #106318# - add condition <aSubsLineRect.IsLocked()>
663*b1cdbd2cSJim Jagielski // in order to consider only border lines, which are *not* locked.
664*b1cdbd2cSJim Jagielski if ( aSubsLineRect.IsPainted() ||
665*b1cdbd2cSJim Jagielski aSubsLineRect.IsLocked() )
666*b1cdbd2cSJim Jagielski continue;
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski const bool bVerticalSubs = aSubsLineRect.Height() > aSubsLineRect.Width();
669*b1cdbd2cSJim Jagielski SwRect aSubsRect( aSubsLineRect );
670*b1cdbd2cSJim Jagielski if ( bVerticalSubs )
671*b1cdbd2cSJim Jagielski {
672*b1cdbd2cSJim Jagielski aSubsRect.Left ( aSubsRect.Left() - (nPixelSzW+nHalfPixelSzW) );
673*b1cdbd2cSJim Jagielski aSubsRect.Right ( aSubsRect.Right() + (nPixelSzW+nHalfPixelSzW) );
674*b1cdbd2cSJim Jagielski }
675*b1cdbd2cSJim Jagielski else
676*b1cdbd2cSJim Jagielski {
677*b1cdbd2cSJim Jagielski aSubsRect.Top ( aSubsRect.Top() - (nPixelSzH+nHalfPixelSzH) );
678*b1cdbd2cSJim Jagielski aSubsRect.Bottom( aSubsRect.Bottom() + (nPixelSzH+nHalfPixelSzH) );
679*b1cdbd2cSJim Jagielski }
680*b1cdbd2cSJim Jagielski for ( sal_uInt16 k = 0; k < rRects.Count(); ++k )
681*b1cdbd2cSJim Jagielski {
682*b1cdbd2cSJim Jagielski SwLineRect &rLine = rRects[k];
683*b1cdbd2cSJim Jagielski
684*b1cdbd2cSJim Jagielski // OD 20.12.2002 #106318# - do *not* consider painted or locked
685*b1cdbd2cSJim Jagielski // border lines.
686*b1cdbd2cSJim Jagielski // OD 20.01.2003 #i1837# - locked border lines have to be considered.
687*b1cdbd2cSJim Jagielski if ( rLine.IsLocked () )
688*b1cdbd2cSJim Jagielski continue;
689*b1cdbd2cSJim Jagielski
690*b1cdbd2cSJim Jagielski if ( (!bVerticalSubs == (rLine.Height() > rLine.Width())) ) //gleiche Ausrichtung?
691*b1cdbd2cSJim Jagielski continue;
692*b1cdbd2cSJim Jagielski
693*b1cdbd2cSJim Jagielski if ( aSubsRect.IsOver( rLine ) )
694*b1cdbd2cSJim Jagielski {
695*b1cdbd2cSJim Jagielski if ( bVerticalSubs ) //Vertikal?
696*b1cdbd2cSJim Jagielski {
697*b1cdbd2cSJim Jagielski if ( aSubsRect.Left() <= rLine.Right() &&
698*b1cdbd2cSJim Jagielski aSubsRect.Right() >= rLine.Left() )
699*b1cdbd2cSJim Jagielski {
700*b1cdbd2cSJim Jagielski long nTmp = rLine.Top()-(nPixelSzH+1);
701*b1cdbd2cSJim Jagielski if ( aSubsLineRect.Top() < nTmp )
702*b1cdbd2cSJim Jagielski {
703*b1cdbd2cSJim Jagielski SwRect aNewSubsRect( aSubsLineRect );
704*b1cdbd2cSJim Jagielski aNewSubsRect.Bottom( nTmp );
705*b1cdbd2cSJim Jagielski Insert( SwLineRect( aNewSubsRect, 0, 0,
706*b1cdbd2cSJim Jagielski aSubsLineRect.GetSubColor() ), Count());
707*b1cdbd2cSJim Jagielski }
708*b1cdbd2cSJim Jagielski nTmp = rLine.Bottom()+nPixelSzH+1;
709*b1cdbd2cSJim Jagielski if ( aSubsLineRect.Bottom() > nTmp )
710*b1cdbd2cSJim Jagielski {
711*b1cdbd2cSJim Jagielski SwRect aNewSubsRect( aSubsLineRect );
712*b1cdbd2cSJim Jagielski aNewSubsRect.Top( nTmp );
713*b1cdbd2cSJim Jagielski Insert( SwLineRect( aNewSubsRect, 0, 0,
714*b1cdbd2cSJim Jagielski aSubsLineRect.GetSubColor() ), Count());
715*b1cdbd2cSJim Jagielski }
716*b1cdbd2cSJim Jagielski Remove( i, 1 );
717*b1cdbd2cSJim Jagielski --i;
718*b1cdbd2cSJim Jagielski break;
719*b1cdbd2cSJim Jagielski }
720*b1cdbd2cSJim Jagielski }
721*b1cdbd2cSJim Jagielski else //Horizontal
722*b1cdbd2cSJim Jagielski {
723*b1cdbd2cSJim Jagielski if ( aSubsRect.Top() <= rLine.Bottom() &&
724*b1cdbd2cSJim Jagielski aSubsRect.Bottom() >= rLine.Top() )
725*b1cdbd2cSJim Jagielski {
726*b1cdbd2cSJim Jagielski long nTmp = rLine.Left()-(nPixelSzW+1);
727*b1cdbd2cSJim Jagielski if ( aSubsLineRect.Left() < nTmp )
728*b1cdbd2cSJim Jagielski {
729*b1cdbd2cSJim Jagielski SwRect aNewSubsRect( aSubsLineRect );
730*b1cdbd2cSJim Jagielski aNewSubsRect.Right( nTmp );
731*b1cdbd2cSJim Jagielski Insert( SwLineRect( aNewSubsRect, 0, 0,
732*b1cdbd2cSJim Jagielski aSubsLineRect.GetSubColor() ), Count());
733*b1cdbd2cSJim Jagielski }
734*b1cdbd2cSJim Jagielski nTmp = rLine.Right()+nPixelSzW+1;
735*b1cdbd2cSJim Jagielski if ( aSubsLineRect.Right() > nTmp )
736*b1cdbd2cSJim Jagielski {
737*b1cdbd2cSJim Jagielski SwRect aNewSubsRect( aSubsLineRect );
738*b1cdbd2cSJim Jagielski aNewSubsRect.Left( nTmp );
739*b1cdbd2cSJim Jagielski Insert( SwLineRect( aNewSubsRect, 0, 0,
740*b1cdbd2cSJim Jagielski aSubsLineRect.GetSubColor() ), Count());
741*b1cdbd2cSJim Jagielski }
742*b1cdbd2cSJim Jagielski Remove( i, 1 );
743*b1cdbd2cSJim Jagielski --i;
744*b1cdbd2cSJim Jagielski break;
745*b1cdbd2cSJim Jagielski }
746*b1cdbd2cSJim Jagielski }
747*b1cdbd2cSJim Jagielski }
748*b1cdbd2cSJim Jagielski }
749*b1cdbd2cSJim Jagielski }
750*b1cdbd2cSJim Jagielski }
751*b1cdbd2cSJim Jagielski
LockLines(sal_Bool bLock)752*b1cdbd2cSJim Jagielski void SwLineRects::LockLines( sal_Bool bLock )
753*b1cdbd2cSJim Jagielski {
754*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < Count(); ++i )
755*b1cdbd2cSJim Jagielski operator[](i).Lock( bLock );
756*b1cdbd2cSJim Jagielski }
757*b1cdbd2cSJim Jagielski
PaintLines(OutputDevice * pOut)758*b1cdbd2cSJim Jagielski void SwLineRects::PaintLines( OutputDevice *pOut )
759*b1cdbd2cSJim Jagielski {
760*b1cdbd2cSJim Jagielski //Painten der Umrandungen. Leider muessen wir zweimal durch.
761*b1cdbd2cSJim Jagielski //Einmal fuer die innenliegenden und einmal fuer die Aussenkanten
762*b1cdbd2cSJim Jagielski //der Tabellen.
763*b1cdbd2cSJim Jagielski if ( Count() != nLastCount )
764*b1cdbd2cSJim Jagielski {
765*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
766*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *pOut );
767*b1cdbd2cSJim Jagielski // <--
768*b1cdbd2cSJim Jagielski
769*b1cdbd2cSJim Jagielski // OD 2004-04-23 #116347#
770*b1cdbd2cSJim Jagielski pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
771*b1cdbd2cSJim Jagielski pOut->SetLineColor();
772*b1cdbd2cSJim Jagielski ConnectEdges( pOut );
773*b1cdbd2cSJim Jagielski const Color *pLast = 0;
774*b1cdbd2cSJim Jagielski
775*b1cdbd2cSJim Jagielski sal_Bool bPaint2nd = sal_False;
776*b1cdbd2cSJim Jagielski sal_uInt16 nMinCount = Count();
777*b1cdbd2cSJim Jagielski sal_uInt16 i;
778*b1cdbd2cSJim Jagielski
779*b1cdbd2cSJim Jagielski for ( i = 0; i < Count(); ++i )
780*b1cdbd2cSJim Jagielski {
781*b1cdbd2cSJim Jagielski SwLineRect &rLRect = operator[](i);
782*b1cdbd2cSJim Jagielski
783*b1cdbd2cSJim Jagielski if ( rLRect.IsPainted() )
784*b1cdbd2cSJim Jagielski continue;
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski if ( rLRect.IsLocked() )
787*b1cdbd2cSJim Jagielski {
788*b1cdbd2cSJim Jagielski nMinCount = Min( nMinCount, i );
789*b1cdbd2cSJim Jagielski continue;
790*b1cdbd2cSJim Jagielski }
791*b1cdbd2cSJim Jagielski
792*b1cdbd2cSJim Jagielski //Jetzt malen oder erst in der zweiten Runde?
793*b1cdbd2cSJim Jagielski sal_Bool bPaint = sal_True;
794*b1cdbd2cSJim Jagielski if ( rLRect.GetTab() )
795*b1cdbd2cSJim Jagielski {
796*b1cdbd2cSJim Jagielski if ( rLRect.Height() > rLRect.Width() )
797*b1cdbd2cSJim Jagielski {
798*b1cdbd2cSJim Jagielski //Senkrechte Kante, ueberlappt sie mit der TabellenKante?
799*b1cdbd2cSJim Jagielski SwTwips nLLeft = rLRect.Left() - 30,
800*b1cdbd2cSJim Jagielski nLRight = rLRect.Right() + 30,
801*b1cdbd2cSJim Jagielski nTLeft = rLRect.GetTab()->Frm().Left() + rLRect.GetTab()->Prt().Left(),
802*b1cdbd2cSJim Jagielski nTRight = rLRect.GetTab()->Frm().Left() + rLRect.GetTab()->Prt().Right();
803*b1cdbd2cSJim Jagielski if ( (nTLeft >= nLLeft && nTLeft <= nLRight) ||
804*b1cdbd2cSJim Jagielski (nTRight>= nLLeft && nTRight<= nLRight) )
805*b1cdbd2cSJim Jagielski bPaint = sal_False;
806*b1cdbd2cSJim Jagielski }
807*b1cdbd2cSJim Jagielski else
808*b1cdbd2cSJim Jagielski { //Waagerechte Kante, ueberlappt sie mit der Tabellenkante?
809*b1cdbd2cSJim Jagielski SwTwips nLTop = rLRect.Top() - 30,
810*b1cdbd2cSJim Jagielski nLBottom = rLRect.Bottom() + 30,
811*b1cdbd2cSJim Jagielski nTTop = rLRect.GetTab()->Frm().Top() + rLRect.GetTab()->Prt().Top(),
812*b1cdbd2cSJim Jagielski nTBottom = rLRect.GetTab()->Frm().Top() + rLRect.GetTab()->Prt().Bottom();
813*b1cdbd2cSJim Jagielski if ( (nTTop >= nLTop && nTTop <= nLBottom) ||
814*b1cdbd2cSJim Jagielski (nTBottom >= nLTop && nTBottom <= nLBottom) )
815*b1cdbd2cSJim Jagielski bPaint = sal_False;
816*b1cdbd2cSJim Jagielski }
817*b1cdbd2cSJim Jagielski }
818*b1cdbd2cSJim Jagielski if ( bPaint )
819*b1cdbd2cSJim Jagielski {
820*b1cdbd2cSJim Jagielski if ( !pLast || *pLast != *rLRect.GetColor() )
821*b1cdbd2cSJim Jagielski {
822*b1cdbd2cSJim Jagielski pLast = rLRect.GetColor();
823*b1cdbd2cSJim Jagielski
824*b1cdbd2cSJim Jagielski sal_uLong nOldDrawMode = pOut->GetDrawMode();
825*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin() &&
826*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
827*b1cdbd2cSJim Jagielski pOut->SetDrawMode( 0 );
828*b1cdbd2cSJim Jagielski
829*b1cdbd2cSJim Jagielski pOut->SetFillColor( *pLast );
830*b1cdbd2cSJim Jagielski pOut->SetDrawMode( nOldDrawMode );
831*b1cdbd2cSJim Jagielski }
832*b1cdbd2cSJim Jagielski if( !rLRect.IsEmpty() )
833*b1cdbd2cSJim Jagielski pOut->DrawRect( rLRect.SVRect() );
834*b1cdbd2cSJim Jagielski rLRect.SetPainted();
835*b1cdbd2cSJim Jagielski }
836*b1cdbd2cSJim Jagielski else
837*b1cdbd2cSJim Jagielski bPaint2nd = sal_True;
838*b1cdbd2cSJim Jagielski }
839*b1cdbd2cSJim Jagielski if ( bPaint2nd )
840*b1cdbd2cSJim Jagielski for ( i = 0; i < Count(); ++i )
841*b1cdbd2cSJim Jagielski {
842*b1cdbd2cSJim Jagielski SwLineRect &rLRect = operator[](i);
843*b1cdbd2cSJim Jagielski if ( rLRect.IsPainted() )
844*b1cdbd2cSJim Jagielski continue;
845*b1cdbd2cSJim Jagielski
846*b1cdbd2cSJim Jagielski if ( rLRect.IsLocked() )
847*b1cdbd2cSJim Jagielski {
848*b1cdbd2cSJim Jagielski nMinCount = Min( nMinCount, i );
849*b1cdbd2cSJim Jagielski continue;
850*b1cdbd2cSJim Jagielski }
851*b1cdbd2cSJim Jagielski
852*b1cdbd2cSJim Jagielski if ( !pLast || *pLast != *rLRect.GetColor() )
853*b1cdbd2cSJim Jagielski {
854*b1cdbd2cSJim Jagielski pLast = rLRect.GetColor();
855*b1cdbd2cSJim Jagielski
856*b1cdbd2cSJim Jagielski sal_uLong nOldDrawMode = pOut->GetDrawMode();
857*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin() &&
858*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
859*b1cdbd2cSJim Jagielski {
860*b1cdbd2cSJim Jagielski pOut->SetDrawMode( 0 );
861*b1cdbd2cSJim Jagielski }
862*b1cdbd2cSJim Jagielski
863*b1cdbd2cSJim Jagielski pOut->SetFillColor( *pLast );
864*b1cdbd2cSJim Jagielski pOut->SetDrawMode( nOldDrawMode );
865*b1cdbd2cSJim Jagielski }
866*b1cdbd2cSJim Jagielski if( !rLRect.IsEmpty() )
867*b1cdbd2cSJim Jagielski pOut->DrawRect( rLRect.SVRect() );
868*b1cdbd2cSJim Jagielski rLRect.SetPainted();
869*b1cdbd2cSJim Jagielski }
870*b1cdbd2cSJim Jagielski nLastCount = nMinCount;
871*b1cdbd2cSJim Jagielski pOut->Pop();
872*b1cdbd2cSJim Jagielski }
873*b1cdbd2cSJim Jagielski }
874*b1cdbd2cSJim Jagielski
PaintSubsidiary(OutputDevice * pOut,const SwLineRects * pRects)875*b1cdbd2cSJim Jagielski void SwSubsRects::PaintSubsidiary( OutputDevice *pOut,
876*b1cdbd2cSJim Jagielski const SwLineRects *pRects )
877*b1cdbd2cSJim Jagielski {
878*b1cdbd2cSJim Jagielski if ( Count() )
879*b1cdbd2cSJim Jagielski {
880*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
881*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *pOut );
882*b1cdbd2cSJim Jagielski // <--
883*b1cdbd2cSJim Jagielski
884*b1cdbd2cSJim Jagielski //Alle Hilfslinien, die sich fast decken entfernen (Tabellen)
885*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < Count(); ++i )
886*b1cdbd2cSJim Jagielski {
887*b1cdbd2cSJim Jagielski SwLineRect &rLi = operator[](i);
888*b1cdbd2cSJim Jagielski const bool bVerticalSubs = rLi.Height() > rLi.Width();
889*b1cdbd2cSJim Jagielski
890*b1cdbd2cSJim Jagielski for ( sal_uInt16 k = i+1; k < Count(); ++k )
891*b1cdbd2cSJim Jagielski {
892*b1cdbd2cSJim Jagielski SwLineRect &rLk = operator[](k);
893*b1cdbd2cSJim Jagielski if ( rLi.SSize() == rLk.SSize() )
894*b1cdbd2cSJim Jagielski {
895*b1cdbd2cSJim Jagielski if ( (bVerticalSubs == (rLk.Height() > rLk.Width())) )
896*b1cdbd2cSJim Jagielski {
897*b1cdbd2cSJim Jagielski if ( bVerticalSubs )
898*b1cdbd2cSJim Jagielski {
899*b1cdbd2cSJim Jagielski long nLi = rLi.Right();
900*b1cdbd2cSJim Jagielski long nLk = rLk.Right();
901*b1cdbd2cSJim Jagielski if ( rLi.Top() == rLk.Top() &&
902*b1cdbd2cSJim Jagielski ((nLi < rLk.Left() && nLi+21 > rLk.Left()) ||
903*b1cdbd2cSJim Jagielski (nLk < rLi.Left() && nLk+21 > rLi.Left())))
904*b1cdbd2cSJim Jagielski {
905*b1cdbd2cSJim Jagielski Remove( k, 1 );
906*b1cdbd2cSJim Jagielski //Nicht mit der inneren Schleife weiter, weil
907*b1cdbd2cSJim Jagielski //das Array schrumpfen koennte!
908*b1cdbd2cSJim Jagielski --i; k = Count();
909*b1cdbd2cSJim Jagielski }
910*b1cdbd2cSJim Jagielski }
911*b1cdbd2cSJim Jagielski else
912*b1cdbd2cSJim Jagielski {
913*b1cdbd2cSJim Jagielski long nLi = rLi.Bottom();
914*b1cdbd2cSJim Jagielski long nLk = rLk.Bottom();
915*b1cdbd2cSJim Jagielski if ( rLi.Left() == rLk.Left() &&
916*b1cdbd2cSJim Jagielski ((nLi < rLk.Top() && nLi+21 > rLk.Top()) ||
917*b1cdbd2cSJim Jagielski (nLk < rLi.Top() && nLk+21 > rLi.Top())))
918*b1cdbd2cSJim Jagielski {
919*b1cdbd2cSJim Jagielski Remove( k, 1 );
920*b1cdbd2cSJim Jagielski --i; k = Count();
921*b1cdbd2cSJim Jagielski }
922*b1cdbd2cSJim Jagielski }
923*b1cdbd2cSJim Jagielski }
924*b1cdbd2cSJim Jagielski }
925*b1cdbd2cSJim Jagielski }
926*b1cdbd2cSJim Jagielski }
927*b1cdbd2cSJim Jagielski
928*b1cdbd2cSJim Jagielski
929*b1cdbd2cSJim Jagielski if ( pRects && pRects->Count() )
930*b1cdbd2cSJim Jagielski RemoveSuperfluousSubsidiaryLines( *pRects );
931*b1cdbd2cSJim Jagielski
932*b1cdbd2cSJim Jagielski if ( Count() )
933*b1cdbd2cSJim Jagielski {
934*b1cdbd2cSJim Jagielski // OD 2004-04-23 #116347#
935*b1cdbd2cSJim Jagielski pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
936*b1cdbd2cSJim Jagielski pOut->SetLineColor();
937*b1cdbd2cSJim Jagielski
938*b1cdbd2cSJim Jagielski // OD 14.01.2003 #106660# - reset draw mode in high contrast
939*b1cdbd2cSJim Jagielski // mode in order to get fill color set at output device.
940*b1cdbd2cSJim Jagielski // Recover draw mode after draw of lines.
941*b1cdbd2cSJim Jagielski // Necessary for the subsidiary lines painted by the fly frames.
942*b1cdbd2cSJim Jagielski sal_uLong nOldDrawMode = pOut->GetDrawMode();
943*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin() &&
944*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
945*b1cdbd2cSJim Jagielski {
946*b1cdbd2cSJim Jagielski pOut->SetDrawMode( 0 );
947*b1cdbd2cSJim Jagielski }
948*b1cdbd2cSJim Jagielski
949*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < Count(); ++i )
950*b1cdbd2cSJim Jagielski {
951*b1cdbd2cSJim Jagielski SwLineRect &rLRect = operator[](i);
952*b1cdbd2cSJim Jagielski // OD 19.12.2002 #106318# - add condition <!rLRect.IsLocked()>
953*b1cdbd2cSJim Jagielski // to prevent paint of locked subsidiary lines.
954*b1cdbd2cSJim Jagielski if ( !rLRect.IsPainted() &&
955*b1cdbd2cSJim Jagielski !rLRect.IsLocked() )
956*b1cdbd2cSJim Jagielski {
957*b1cdbd2cSJim Jagielski const Color *pCol = 0;
958*b1cdbd2cSJim Jagielski switch ( rLRect.GetSubColor() )
959*b1cdbd2cSJim Jagielski {
960*b1cdbd2cSJim Jagielski case SUBCOL_PAGE: pCol = &SwViewOption::GetDocBoundariesColor(); break;
961*b1cdbd2cSJim Jagielski case SUBCOL_FLY: pCol = &SwViewOption::GetObjectBoundariesColor(); break;
962*b1cdbd2cSJim Jagielski case SUBCOL_TAB: pCol = &SwViewOption::GetTableBoundariesColor(); break;
963*b1cdbd2cSJim Jagielski case SUBCOL_SECT: pCol = &SwViewOption::GetSectionBoundColor(); break;
964*b1cdbd2cSJim Jagielski case SUBCOL_BREAK: pCol = &SwViewOption::GetPageBreakColor(); break;
965*b1cdbd2cSJim Jagielski }
966*b1cdbd2cSJim Jagielski
967*b1cdbd2cSJim Jagielski if ( pOut->GetFillColor() != *pCol )
968*b1cdbd2cSJim Jagielski pOut->SetFillColor( *pCol );
969*b1cdbd2cSJim Jagielski pOut->DrawRect( rLRect.SVRect() );
970*b1cdbd2cSJim Jagielski
971*b1cdbd2cSJim Jagielski rLRect.SetPainted();
972*b1cdbd2cSJim Jagielski }
973*b1cdbd2cSJim Jagielski }
974*b1cdbd2cSJim Jagielski
975*b1cdbd2cSJim Jagielski // OD 14.01.2003 #106660# - recovering draw mode
976*b1cdbd2cSJim Jagielski pOut->SetDrawMode( nOldDrawMode );
977*b1cdbd2cSJim Jagielski
978*b1cdbd2cSJim Jagielski pOut->Pop();
979*b1cdbd2cSJim Jagielski }
980*b1cdbd2cSJim Jagielski }
981*b1cdbd2cSJim Jagielski }
982*b1cdbd2cSJim Jagielski
983*b1cdbd2cSJim Jagielski //-------------------------------------------------------------------------
984*b1cdbd2cSJim Jagielski //Diverse Functions die in diesem File so verwendet werden.
985*b1cdbd2cSJim Jagielski
986*b1cdbd2cSJim Jagielski // OD 20.02.2003 - Note: function <SwAlignRect(..)> also used outside this file.
987*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - correction: adjust rectangle on pixel level in order
988*b1cdbd2cSJim Jagielski // to assure, that the border 'leaves its original pixel', if it has to.
989*b1cdbd2cSJim Jagielski // No prior adjustments for odd relation between pixel and twip.
SwAlignRect(SwRect & rRect,ViewShell * pSh)990*b1cdbd2cSJim Jagielski void MA_FASTCALL SwAlignRect( SwRect &rRect, ViewShell *pSh )
991*b1cdbd2cSJim Jagielski {
992*b1cdbd2cSJim Jagielski if( !rRect.HasArea() )
993*b1cdbd2cSJim Jagielski return;
994*b1cdbd2cSJim Jagielski
995*b1cdbd2cSJim Jagielski // OD 03.09.2002 #102450#
996*b1cdbd2cSJim Jagielski // Assure that view shell (parameter <pSh>) exists, if the output device
997*b1cdbd2cSJim Jagielski // is taken from this view shell --> no output device, no alignment.
998*b1cdbd2cSJim Jagielski // Output device taken from view shell <pSh>, if <bFlyMetafile> not set.
999*b1cdbd2cSJim Jagielski if ( !bFlyMetafile && !pSh )
1000*b1cdbd2cSJim Jagielski {
1001*b1cdbd2cSJim Jagielski return;
1002*b1cdbd2cSJim Jagielski }
1003*b1cdbd2cSJim Jagielski
1004*b1cdbd2cSJim Jagielski const OutputDevice *pOut = bFlyMetafile ?
1005*b1cdbd2cSJim Jagielski pFlyMetafileOut : pSh->GetOut();
1006*b1cdbd2cSJim Jagielski
1007*b1cdbd2cSJim Jagielski // OD 28.04.2003 #107169# - hold original rectangle in pixel
1008*b1cdbd2cSJim Jagielski const Rectangle aOrgPxRect = pOut->LogicToPixel( rRect.SVRect() );
1009*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - determine pixel-center rectangle in twip
1010*b1cdbd2cSJim Jagielski const SwRect aPxCenterRect( pOut->PixelToLogic( aOrgPxRect ) );
1011*b1cdbd2cSJim Jagielski
1012*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - perform adjustments on pixel level.
1013*b1cdbd2cSJim Jagielski SwRect aAlignedPxRect( aOrgPxRect );
1014*b1cdbd2cSJim Jagielski if ( rRect.Top() > aPxCenterRect.Top() )
1015*b1cdbd2cSJim Jagielski {
1016*b1cdbd2cSJim Jagielski // 'leave pixel overlapping on top'
1017*b1cdbd2cSJim Jagielski aAlignedPxRect.Top( aAlignedPxRect.Top() + 1 );
1018*b1cdbd2cSJim Jagielski }
1019*b1cdbd2cSJim Jagielski
1020*b1cdbd2cSJim Jagielski if ( rRect.Bottom() < aPxCenterRect.Bottom() )
1021*b1cdbd2cSJim Jagielski {
1022*b1cdbd2cSJim Jagielski // 'leave pixel overlapping on bottom'
1023*b1cdbd2cSJim Jagielski aAlignedPxRect.Bottom( aAlignedPxRect.Bottom() - 1 );
1024*b1cdbd2cSJim Jagielski }
1025*b1cdbd2cSJim Jagielski
1026*b1cdbd2cSJim Jagielski if ( rRect.Left() > aPxCenterRect.Left() )
1027*b1cdbd2cSJim Jagielski {
1028*b1cdbd2cSJim Jagielski // 'leave pixel overlapping on left'
1029*b1cdbd2cSJim Jagielski aAlignedPxRect.Left( aAlignedPxRect.Left() + 1 );
1030*b1cdbd2cSJim Jagielski }
1031*b1cdbd2cSJim Jagielski
1032*b1cdbd2cSJim Jagielski if ( rRect.Right() < aPxCenterRect.Right() )
1033*b1cdbd2cSJim Jagielski {
1034*b1cdbd2cSJim Jagielski // 'leave pixel overlapping on right'
1035*b1cdbd2cSJim Jagielski aAlignedPxRect.Right( aAlignedPxRect.Right() - 1 );
1036*b1cdbd2cSJim Jagielski }
1037*b1cdbd2cSJim Jagielski
1038*b1cdbd2cSJim Jagielski // OD 11.10.2002 #103636# - consider negative width/height
1039*b1cdbd2cSJim Jagielski // check, if aligned SwRect has negative width/height.
1040*b1cdbd2cSJim Jagielski // If Yes, adjust it to width/height = 0 twip.
1041*b1cdbd2cSJim Jagielski // NOTE: A SwRect with negative width/height can occur, if the width/height
1042*b1cdbd2cSJim Jagielski // of the given SwRect in twip was less than a pixel in twip and that
1043*b1cdbd2cSJim Jagielski // the alignment calculates that the aligned SwRect should not contain
1044*b1cdbd2cSJim Jagielski // the pixels the width/height is on.
1045*b1cdbd2cSJim Jagielski if ( aAlignedPxRect.Width() < 0 )
1046*b1cdbd2cSJim Jagielski {
1047*b1cdbd2cSJim Jagielski aAlignedPxRect.Width(0);
1048*b1cdbd2cSJim Jagielski }
1049*b1cdbd2cSJim Jagielski if ( aAlignedPxRect.Height() < 0 )
1050*b1cdbd2cSJim Jagielski {
1051*b1cdbd2cSJim Jagielski aAlignedPxRect.Height(0);
1052*b1cdbd2cSJim Jagielski }
1053*b1cdbd2cSJim Jagielski // OD 30.04.2003 #107169# - consider zero width/height
1054*b1cdbd2cSJim Jagielski // For converting a rectangle from pixel to logic it needs a width/height.
1055*b1cdbd2cSJim Jagielski // Thus, set width/height to one, if it's zero and correct this on the twip
1056*b1cdbd2cSJim Jagielski // level after the conversion.
1057*b1cdbd2cSJim Jagielski sal_Bool bZeroWidth = sal_False;
1058*b1cdbd2cSJim Jagielski if ( aAlignedPxRect.Width() == 0 )
1059*b1cdbd2cSJim Jagielski {
1060*b1cdbd2cSJim Jagielski aAlignedPxRect.Width(1);
1061*b1cdbd2cSJim Jagielski bZeroWidth = sal_True;
1062*b1cdbd2cSJim Jagielski }
1063*b1cdbd2cSJim Jagielski sal_Bool bZeroHeight = sal_False;
1064*b1cdbd2cSJim Jagielski if ( aAlignedPxRect.Height() == 0 )
1065*b1cdbd2cSJim Jagielski {
1066*b1cdbd2cSJim Jagielski aAlignedPxRect.Height(1);
1067*b1cdbd2cSJim Jagielski bZeroHeight = sal_True;
1068*b1cdbd2cSJim Jagielski }
1069*b1cdbd2cSJim Jagielski
1070*b1cdbd2cSJim Jagielski rRect = pOut->PixelToLogic( aAlignedPxRect.SVRect() );
1071*b1cdbd2cSJim Jagielski
1072*b1cdbd2cSJim Jagielski // OD 30.04.2003 #107169# - consider zero width/height and adjust calculated
1073*b1cdbd2cSJim Jagielski // aligned twip rectangle.
1074*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - reset width/height to zero; previous negative
1075*b1cdbd2cSJim Jagielski // width/height haven't to be considered.
1076*b1cdbd2cSJim Jagielski if ( bZeroWidth )
1077*b1cdbd2cSJim Jagielski {
1078*b1cdbd2cSJim Jagielski rRect.Width(0);
1079*b1cdbd2cSJim Jagielski }
1080*b1cdbd2cSJim Jagielski if ( bZeroHeight )
1081*b1cdbd2cSJim Jagielski {
1082*b1cdbd2cSJim Jagielski rRect.Height(0);
1083*b1cdbd2cSJim Jagielski }
1084*b1cdbd2cSJim Jagielski }
1085*b1cdbd2cSJim Jagielski
1086*b1cdbd2cSJim Jagielski /** OD 19.05.2003 #109667# - helper method for twip adjustments on pixel base
1087*b1cdbd2cSJim Jagielski
1088*b1cdbd2cSJim Jagielski method compares the x- or y-pixel position of two twip-point. If the x-/y-pixel
1089*b1cdbd2cSJim Jagielski positions are the same, the x-/y-pixel position of the second twip point is
1090*b1cdbd2cSJim Jagielski adjusted by a given amount of pixels.
1091*b1cdbd2cSJim Jagielski
1092*b1cdbd2cSJim Jagielski @author OD
1093*b1cdbd2cSJim Jagielski */
lcl_CompPxPosAndAdjustPos(const OutputDevice & _rOut,const Point & _rRefPt,Point & _rCompPt,const sal_Bool _bChkXPos,const sal_Int8 _nPxAdjustment)1094*b1cdbd2cSJim Jagielski void lcl_CompPxPosAndAdjustPos( const OutputDevice& _rOut,
1095*b1cdbd2cSJim Jagielski const Point& _rRefPt,
1096*b1cdbd2cSJim Jagielski Point& _rCompPt,
1097*b1cdbd2cSJim Jagielski const sal_Bool _bChkXPos,
1098*b1cdbd2cSJim Jagielski const sal_Int8 _nPxAdjustment )
1099*b1cdbd2cSJim Jagielski {
1100*b1cdbd2cSJim Jagielski const Point aRefPxPt = _rOut.LogicToPixel( _rRefPt );
1101*b1cdbd2cSJim Jagielski Point aCompPxPt = _rOut.LogicToPixel( _rCompPt );
1102*b1cdbd2cSJim Jagielski
1103*b1cdbd2cSJim Jagielski if ( _bChkXPos )
1104*b1cdbd2cSJim Jagielski {
1105*b1cdbd2cSJim Jagielski if ( aCompPxPt.X() == aRefPxPt.X() )
1106*b1cdbd2cSJim Jagielski {
1107*b1cdbd2cSJim Jagielski aCompPxPt.X() += _nPxAdjustment ;
1108*b1cdbd2cSJim Jagielski const Point aAdjustedCompPt = _rOut.PixelToLogic( aCompPxPt );
1109*b1cdbd2cSJim Jagielski _rCompPt.X() = aAdjustedCompPt.X();
1110*b1cdbd2cSJim Jagielski }
1111*b1cdbd2cSJim Jagielski }
1112*b1cdbd2cSJim Jagielski else
1113*b1cdbd2cSJim Jagielski {
1114*b1cdbd2cSJim Jagielski if ( aCompPxPt.Y() == aRefPxPt.Y() )
1115*b1cdbd2cSJim Jagielski {
1116*b1cdbd2cSJim Jagielski aCompPxPt.Y() += _nPxAdjustment ;
1117*b1cdbd2cSJim Jagielski const Point aAdjustedCompPt = _rOut.PixelToLogic( aCompPxPt );
1118*b1cdbd2cSJim Jagielski _rCompPt.Y() = aAdjustedCompPt.Y();
1119*b1cdbd2cSJim Jagielski }
1120*b1cdbd2cSJim Jagielski }
1121*b1cdbd2cSJim Jagielski }
1122*b1cdbd2cSJim Jagielski
1123*b1cdbd2cSJim Jagielski /** OD 25.09.2002 #99739# - method to pixel-align rectangle for drawing graphic object
1124*b1cdbd2cSJim Jagielski
1125*b1cdbd2cSJim Jagielski Because for drawing a graphic left-top-corner and size coordinations are
1126*b1cdbd2cSJim Jagielski used, these coordinations have to be determined on pixel level.
1127*b1cdbd2cSJim Jagielski Thus, convert rectangle to pixel and then convert left-top-corner and
1128*b1cdbd2cSJim Jagielski size of pixel rectangle back to logic.
1129*b1cdbd2cSJim Jagielski This calculation is necessary, because there exists a different between
1130*b1cdbd2cSJim Jagielski the convert from logic to pixel of a normal rectangle with its left-top-
1131*b1cdbd2cSJim Jagielski and right-bottom-corner and the same convert of the same rectangle
1132*b1cdbd2cSJim Jagielski with left-top-corner and size.
1133*b1cdbd2cSJim Jagielski Call this method before each <GraphicObject.Draw(...)>
1134*b1cdbd2cSJim Jagielski
1135*b1cdbd2cSJim Jagielski @author OD
1136*b1cdbd2cSJim Jagielski */
SwAlignGrfRect(SwRect * pGrfRect,const OutputDevice & rOut)1137*b1cdbd2cSJim Jagielski void SwAlignGrfRect( SwRect *pGrfRect, const OutputDevice &rOut )
1138*b1cdbd2cSJim Jagielski {
1139*b1cdbd2cSJim Jagielski Rectangle aPxRect = rOut.LogicToPixel( pGrfRect->SVRect() );
1140*b1cdbd2cSJim Jagielski pGrfRect->Pos( rOut.PixelToLogic( aPxRect.TopLeft() ) );
1141*b1cdbd2cSJim Jagielski pGrfRect->SSize( rOut.PixelToLogic( aPxRect.GetSize() ) );
1142*b1cdbd2cSJim Jagielski }
1143*b1cdbd2cSJim Jagielski
lcl_AlignWidth(const long nWidth)1144*b1cdbd2cSJim Jagielski long MA_FASTCALL lcl_AlignWidth( const long nWidth )
1145*b1cdbd2cSJim Jagielski {
1146*b1cdbd2cSJim Jagielski if ( nWidth )
1147*b1cdbd2cSJim Jagielski {
1148*b1cdbd2cSJim Jagielski const long nW = nWidth % nPixelSzW;
1149*b1cdbd2cSJim Jagielski
1150*b1cdbd2cSJim Jagielski if ( !nW || nW > nHalfPixelSzW )
1151*b1cdbd2cSJim Jagielski return Max(1L, nWidth - nHalfPixelSzW);
1152*b1cdbd2cSJim Jagielski }
1153*b1cdbd2cSJim Jagielski return nWidth;
1154*b1cdbd2cSJim Jagielski }
1155*b1cdbd2cSJim Jagielski
lcl_AlignHeight(const long nHeight)1156*b1cdbd2cSJim Jagielski long MA_FASTCALL lcl_AlignHeight( const long nHeight )
1157*b1cdbd2cSJim Jagielski {
1158*b1cdbd2cSJim Jagielski if ( nHeight )
1159*b1cdbd2cSJim Jagielski {
1160*b1cdbd2cSJim Jagielski const long nH = nHeight % nPixelSzH;
1161*b1cdbd2cSJim Jagielski
1162*b1cdbd2cSJim Jagielski if ( !nH || nH > nHalfPixelSzH )
1163*b1cdbd2cSJim Jagielski return Max(1L, nHeight - nHalfPixelSzH);
1164*b1cdbd2cSJim Jagielski }
1165*b1cdbd2cSJim Jagielski return nHeight;
1166*b1cdbd2cSJim Jagielski }
1167*b1cdbd2cSJim Jagielski
lcl_MinHeightDist(const long nDist)1168*b1cdbd2cSJim Jagielski long MA_FASTCALL lcl_MinHeightDist( const long nDist )
1169*b1cdbd2cSJim Jagielski {
1170*b1cdbd2cSJim Jagielski if ( aScaleX < aMinDistScale || aScaleY < aMinDistScale )
1171*b1cdbd2cSJim Jagielski return nDist;
1172*b1cdbd2cSJim Jagielski return ::lcl_AlignHeight( Max( nDist, nMinDistPixelH ));
1173*b1cdbd2cSJim Jagielski }
1174*b1cdbd2cSJim Jagielski
lcl_MinWidthDist(const long nDist)1175*b1cdbd2cSJim Jagielski long MA_FASTCALL lcl_MinWidthDist( const long nDist )
1176*b1cdbd2cSJim Jagielski {
1177*b1cdbd2cSJim Jagielski if ( aScaleX < aMinDistScale || aScaleY < aMinDistScale )
1178*b1cdbd2cSJim Jagielski return nDist;
1179*b1cdbd2cSJim Jagielski return ::lcl_AlignWidth( Max( nDist, nMinDistPixelW ));
1180*b1cdbd2cSJim Jagielski }
1181*b1cdbd2cSJim Jagielski
1182*b1cdbd2cSJim Jagielski
1183*b1cdbd2cSJim Jagielski //Ermittelt PrtArea plus Umrandung plus Schatten.
lcl_CalcBorderRect(SwRect & rRect,const SwFrm * pFrm,const SwBorderAttrs & rAttrs,const sal_Bool bShadow)1184*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_CalcBorderRect( SwRect &rRect, const SwFrm *pFrm,
1185*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs,
1186*b1cdbd2cSJim Jagielski const sal_Bool bShadow )
1187*b1cdbd2cSJim Jagielski {
1188*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106386# - special handling for cell frames.
1189*b1cdbd2cSJim Jagielski // The printing area of a cell frame is completely enclosed in the frame area
1190*b1cdbd2cSJim Jagielski // and a cell frame has no shadow. Thus, for cell frames the calculated
1191*b1cdbd2cSJim Jagielski // area equals the frame area.
1192*b1cdbd2cSJim Jagielski // Notes: Borders of cell frames in R2L text direction will switch its side
1193*b1cdbd2cSJim Jagielski // - left border is painted on the right; right border on the left.
1194*b1cdbd2cSJim Jagielski // See <lcl_PaintLeftLine> and <lcl_PaintRightLine>.
1195*b1cdbd2cSJim Jagielski if( pFrm->IsSctFrm() )
1196*b1cdbd2cSJim Jagielski {
1197*b1cdbd2cSJim Jagielski rRect = pFrm->Prt();
1198*b1cdbd2cSJim Jagielski rRect.Pos() += pFrm->Frm().Pos();
1199*b1cdbd2cSJim Jagielski }
1200*b1cdbd2cSJim Jagielski else if ( pFrm->IsCellFrm() )
1201*b1cdbd2cSJim Jagielski rRect = pFrm->Frm();
1202*b1cdbd2cSJim Jagielski else
1203*b1cdbd2cSJim Jagielski {
1204*b1cdbd2cSJim Jagielski rRect = pFrm->Prt();
1205*b1cdbd2cSJim Jagielski rRect.Pos() += pFrm->Frm().Pos();
1206*b1cdbd2cSJim Jagielski
1207*b1cdbd2cSJim Jagielski if ( rAttrs.IsLine() || rAttrs.IsBorderDist() ||
1208*b1cdbd2cSJim Jagielski (bShadow && rAttrs.GetShadow().GetLocation() != SVX_SHADOW_NONE) )
1209*b1cdbd2cSJim Jagielski {
1210*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
1211*b1cdbd2cSJim Jagielski SwRectFn fnRect = pFrm->IsVertical() ? ( pFrm->IsVertLR() ? fnRectVertL2R : fnRectVert ) : fnRectHori;
1212*b1cdbd2cSJim Jagielski
1213*b1cdbd2cSJim Jagielski const SvxBoxItem &rBox = rAttrs.GetBox();
1214*b1cdbd2cSJim Jagielski const sal_Bool bTop = 0 != (pFrm->*fnRect->fnGetTopMargin)();
1215*b1cdbd2cSJim Jagielski if ( bTop )
1216*b1cdbd2cSJim Jagielski {
1217*b1cdbd2cSJim Jagielski SwTwips nDiff = rBox.GetTop() ?
1218*b1cdbd2cSJim Jagielski rBox.CalcLineSpace( BOX_LINE_TOP ) :
1219*b1cdbd2cSJim Jagielski ( rAttrs.IsBorderDist() ?
1220*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106386# - increase of distance by
1221*b1cdbd2cSJim Jagielski // one twip is incorrect.
1222*b1cdbd2cSJim Jagielski rBox.GetDistance( BOX_LINE_TOP ) : 0 );
1223*b1cdbd2cSJim Jagielski if( nDiff )
1224*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnSubTop)( nDiff );
1225*b1cdbd2cSJim Jagielski }
1226*b1cdbd2cSJim Jagielski
1227*b1cdbd2cSJim Jagielski const sal_Bool bBottom = 0 != (pFrm->*fnRect->fnGetBottomMargin)();
1228*b1cdbd2cSJim Jagielski if ( bBottom )
1229*b1cdbd2cSJim Jagielski {
1230*b1cdbd2cSJim Jagielski SwTwips nDiff = 0;
1231*b1cdbd2cSJim Jagielski // --> collapsing borders FME 2005-05-27 #i29550#
1232*b1cdbd2cSJim Jagielski if ( pFrm->IsTabFrm() &&
1233*b1cdbd2cSJim Jagielski ((SwTabFrm*)pFrm)->IsCollapsingBorders() )
1234*b1cdbd2cSJim Jagielski {
1235*b1cdbd2cSJim Jagielski // For collapsing borders, we have to add the height of
1236*b1cdbd2cSJim Jagielski // the height of the last line
1237*b1cdbd2cSJim Jagielski nDiff = ((SwTabFrm*)pFrm)->GetBottomLineSize();
1238*b1cdbd2cSJim Jagielski }
1239*b1cdbd2cSJim Jagielski // <-- collapsing
1240*b1cdbd2cSJim Jagielski else
1241*b1cdbd2cSJim Jagielski {
1242*b1cdbd2cSJim Jagielski nDiff = rBox.GetBottom() ?
1243*b1cdbd2cSJim Jagielski rBox.CalcLineSpace( BOX_LINE_BOTTOM ) :
1244*b1cdbd2cSJim Jagielski ( rAttrs.IsBorderDist() ?
1245*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106386# - increase of distance by
1246*b1cdbd2cSJim Jagielski // one twip is incorrect.
1247*b1cdbd2cSJim Jagielski rBox.GetDistance( BOX_LINE_BOTTOM ) : 0 );
1248*b1cdbd2cSJim Jagielski }
1249*b1cdbd2cSJim Jagielski if( nDiff )
1250*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnAddBottom)( nDiff );
1251*b1cdbd2cSJim Jagielski }
1252*b1cdbd2cSJim Jagielski
1253*b1cdbd2cSJim Jagielski if ( rBox.GetLeft() )
1254*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnSubLeft)( rBox.CalcLineSpace( BOX_LINE_LEFT ) );
1255*b1cdbd2cSJim Jagielski else if ( rAttrs.IsBorderDist() )
1256*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106386# - increase of distance by one twip is incorrect.
1257*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnSubLeft)( rBox.GetDistance( BOX_LINE_LEFT ) );
1258*b1cdbd2cSJim Jagielski
1259*b1cdbd2cSJim Jagielski if ( rBox.GetRight() )
1260*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnAddRight)( rBox.CalcLineSpace( BOX_LINE_RIGHT ) );
1261*b1cdbd2cSJim Jagielski else if ( rAttrs.IsBorderDist() )
1262*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106386# - increase of distance by one twip is incorrect.
1263*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnAddRight)( rBox.GetDistance( BOX_LINE_RIGHT ) );
1264*b1cdbd2cSJim Jagielski
1265*b1cdbd2cSJim Jagielski if ( bShadow && rAttrs.GetShadow().GetLocation() != SVX_SHADOW_NONE )
1266*b1cdbd2cSJim Jagielski {
1267*b1cdbd2cSJim Jagielski const SvxShadowItem &rShadow = rAttrs.GetShadow();
1268*b1cdbd2cSJim Jagielski if ( bTop )
1269*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnSubTop)(rShadow.CalcShadowSpace(SHADOW_TOP));
1270*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnSubLeft)(rShadow.CalcShadowSpace(SHADOW_LEFT));
1271*b1cdbd2cSJim Jagielski if ( bBottom )
1272*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnAddBottom)
1273*b1cdbd2cSJim Jagielski (rShadow.CalcShadowSpace( SHADOW_BOTTOM ));
1274*b1cdbd2cSJim Jagielski (rRect.*fnRect->fnAddRight)(rShadow.CalcShadowSpace(SHADOW_RIGHT));
1275*b1cdbd2cSJim Jagielski }
1276*b1cdbd2cSJim Jagielski }
1277*b1cdbd2cSJim Jagielski }
1278*b1cdbd2cSJim Jagielski
1279*b1cdbd2cSJim Jagielski ::SwAlignRect( rRect, pGlobalShell );
1280*b1cdbd2cSJim Jagielski }
1281*b1cdbd2cSJim Jagielski
lcl_ExtendLeftAndRight(SwRect & _rRect,const SwFrm & _rFrm,const SwBorderAttrs & _rAttrs,const SwRectFn & _rRectFn)1282*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_ExtendLeftAndRight( SwRect& _rRect,
1283*b1cdbd2cSJim Jagielski const SwFrm& _rFrm,
1284*b1cdbd2cSJim Jagielski const SwBorderAttrs& _rAttrs,
1285*b1cdbd2cSJim Jagielski const SwRectFn& _rRectFn )
1286*b1cdbd2cSJim Jagielski {
1287*b1cdbd2cSJim Jagielski // OD 21.05.2003 #108789# - extend left/right border/shadow rectangle to
1288*b1cdbd2cSJim Jagielski // bottom of previous frame/to top of next frame, if border/shadow is joined
1289*b1cdbd2cSJim Jagielski // with previous/next frame.
1290*b1cdbd2cSJim Jagielski if ( _rAttrs.JoinedWithPrev( _rFrm ) )
1291*b1cdbd2cSJim Jagielski {
1292*b1cdbd2cSJim Jagielski const SwFrm* pPrevFrm = _rFrm.GetPrev();
1293*b1cdbd2cSJim Jagielski (_rRect.*_rRectFn->fnSetTop)( (pPrevFrm->*_rRectFn->fnGetPrtBottom)() );
1294*b1cdbd2cSJim Jagielski }
1295*b1cdbd2cSJim Jagielski if ( _rAttrs.JoinedWithNext( _rFrm ) )
1296*b1cdbd2cSJim Jagielski {
1297*b1cdbd2cSJim Jagielski const SwFrm* pNextFrm = _rFrm.GetNext();
1298*b1cdbd2cSJim Jagielski (_rRect.*_rRectFn->fnSetBottom)( (pNextFrm->*_rRectFn->fnGetPrtTop)() );
1299*b1cdbd2cSJim Jagielski }
1300*b1cdbd2cSJim Jagielski }
1301*b1cdbd2cSJim Jagielski
1302*b1cdbd2cSJim Jagielski
lcl_SubtractFlys(const SwFrm * pFrm,const SwPageFrm * pPage,const SwRect & rRect,SwRegionRects & rRegion)1303*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_SubtractFlys( const SwFrm *pFrm, const SwPageFrm *pPage,
1304*b1cdbd2cSJim Jagielski const SwRect &rRect, SwRegionRects &rRegion )
1305*b1cdbd2cSJim Jagielski {
1306*b1cdbd2cSJim Jagielski const SwSortedObjs& rObjs = *pPage->GetSortedObjs();
1307*b1cdbd2cSJim Jagielski const SwFlyFrm* pSelfFly = pFrm->IsInFly() ? pFrm->FindFlyFrm() : pRetoucheFly2;
1308*b1cdbd2cSJim Jagielski if ( !pRetoucheFly )
1309*b1cdbd2cSJim Jagielski pRetoucheFly = pRetoucheFly2;
1310*b1cdbd2cSJim Jagielski
1311*b1cdbd2cSJim Jagielski for ( sal_uInt16 j = 0; (j < rObjs.Count()) && rRegion.Count(); ++j )
1312*b1cdbd2cSJim Jagielski {
1313*b1cdbd2cSJim Jagielski const SwAnchoredObject* pAnchoredObj = rObjs[j];
1314*b1cdbd2cSJim Jagielski const SdrObject* pSdrObj = pAnchoredObj->GetDrawObj();
1315*b1cdbd2cSJim Jagielski
1316*b1cdbd2cSJim Jagielski // OD 2004-01-15 #110582# - do not consider invisible objects
1317*b1cdbd2cSJim Jagielski if ( !pPage->GetFmt()->GetDoc()->IsVisibleLayerId( pSdrObj->GetLayer() ) )
1318*b1cdbd2cSJim Jagielski continue;
1319*b1cdbd2cSJim Jagielski
1320*b1cdbd2cSJim Jagielski if ( !pAnchoredObj->ISA(SwFlyFrm) )
1321*b1cdbd2cSJim Jagielski continue;
1322*b1cdbd2cSJim Jagielski
1323*b1cdbd2cSJim Jagielski const SwFlyFrm *pFly = static_cast<const SwFlyFrm*>(pAnchoredObj);
1324*b1cdbd2cSJim Jagielski
1325*b1cdbd2cSJim Jagielski if ( pSelfFly == pFly || pRetoucheFly == pFly || !rRect.IsOver( pFly->Frm() ) )
1326*b1cdbd2cSJim Jagielski continue;
1327*b1cdbd2cSJim Jagielski
1328*b1cdbd2cSJim Jagielski if ( !pFly->GetFmt()->GetPrint().GetValue() &&
1329*b1cdbd2cSJim Jagielski (OUTDEV_PRINTER == pGlobalShell->GetOut()->GetOutDevType() ||
1330*b1cdbd2cSJim Jagielski pGlobalShell->IsPreView()))
1331*b1cdbd2cSJim Jagielski continue;
1332*b1cdbd2cSJim Jagielski
1333*b1cdbd2cSJim Jagielski const sal_Bool bLowerOfSelf = pSelfFly && pFly->IsLowerOf( pSelfFly ) ?
1334*b1cdbd2cSJim Jagielski sal_True : sal_False;
1335*b1cdbd2cSJim Jagielski
1336*b1cdbd2cSJim Jagielski //Bei zeichengebundenem Fly nur diejenigen betrachten, in denen er
1337*b1cdbd2cSJim Jagielski //nicht selbst verankert ist.
1338*b1cdbd2cSJim Jagielski //#33429# Warum nur bei zeichengebundenen? Es macht doch nie Sinn
1339*b1cdbd2cSJim Jagielski //Rahmen abzuziehen in denen er selbst verankert ist oder?
1340*b1cdbd2cSJim Jagielski if ( pSelfFly && pSelfFly->IsLowerOf( pFly ) )
1341*b1cdbd2cSJim Jagielski continue;
1342*b1cdbd2cSJim Jagielski
1343*b1cdbd2cSJim Jagielski //#57194# Und warum gilt das nicht analog fuer den RetoucheFly?
1344*b1cdbd2cSJim Jagielski if ( pRetoucheFly && pRetoucheFly->IsLowerOf( pFly ) )
1345*b1cdbd2cSJim Jagielski continue;
1346*b1cdbd2cSJim Jagielski
1347*b1cdbd2cSJim Jagielski
1348*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
1349*b1cdbd2cSJim Jagielski //Flys, die innerhalb des eigenen verankert sind, muessen eine
1350*b1cdbd2cSJim Jagielski //groessere OrdNum haben oder Zeichengebunden sein.
1351*b1cdbd2cSJim Jagielski if ( pSelfFly && bLowerOfSelf )
1352*b1cdbd2cSJim Jagielski {
1353*b1cdbd2cSJim Jagielski ASSERT( pFly->IsFlyInCntFrm() ||
1354*b1cdbd2cSJim Jagielski pSdrObj->GetOrdNumDirect() > pSelfFly->GetVirtDrawObj()->GetOrdNumDirect(),
1355*b1cdbd2cSJim Jagielski "Fly with wrong z-Order" );
1356*b1cdbd2cSJim Jagielski }
1357*b1cdbd2cSJim Jagielski #endif
1358*b1cdbd2cSJim Jagielski
1359*b1cdbd2cSJim Jagielski sal_Bool bStopOnHell = sal_True;
1360*b1cdbd2cSJim Jagielski if ( pSelfFly )
1361*b1cdbd2cSJim Jagielski {
1362*b1cdbd2cSJim Jagielski const SdrObject *pTmp = pSelfFly->GetVirtDrawObj();
1363*b1cdbd2cSJim Jagielski if ( pSdrObj->GetLayer() == pTmp->GetLayer() )
1364*b1cdbd2cSJim Jagielski {
1365*b1cdbd2cSJim Jagielski if ( pSdrObj->GetOrdNumDirect() < pTmp->GetOrdNumDirect() )
1366*b1cdbd2cSJim Jagielski //Im gleichen Layer werden nur obenliegende beachtet.
1367*b1cdbd2cSJim Jagielski continue;
1368*b1cdbd2cSJim Jagielski }
1369*b1cdbd2cSJim Jagielski else
1370*b1cdbd2cSJim Jagielski {
1371*b1cdbd2cSJim Jagielski if ( !bLowerOfSelf && !pFly->GetFmt()->GetOpaque().GetValue() )
1372*b1cdbd2cSJim Jagielski //Aus anderem Layer interessieren uns nur nicht transparente
1373*b1cdbd2cSJim Jagielski //oder innenliegende
1374*b1cdbd2cSJim Jagielski continue;
1375*b1cdbd2cSJim Jagielski bStopOnHell = sal_False;
1376*b1cdbd2cSJim Jagielski }
1377*b1cdbd2cSJim Jagielski }
1378*b1cdbd2cSJim Jagielski if ( pRetoucheFly )
1379*b1cdbd2cSJim Jagielski {
1380*b1cdbd2cSJim Jagielski const SdrObject *pTmp = pRetoucheFly->GetVirtDrawObj();
1381*b1cdbd2cSJim Jagielski if ( pSdrObj->GetLayer() == pTmp->GetLayer() )
1382*b1cdbd2cSJim Jagielski {
1383*b1cdbd2cSJim Jagielski if ( pSdrObj->GetOrdNumDirect() < pTmp->GetOrdNumDirect() )
1384*b1cdbd2cSJim Jagielski //Im gleichen Layer werden nur obenliegende beachtet.
1385*b1cdbd2cSJim Jagielski continue;
1386*b1cdbd2cSJim Jagielski }
1387*b1cdbd2cSJim Jagielski else
1388*b1cdbd2cSJim Jagielski {
1389*b1cdbd2cSJim Jagielski if ( !pFly->IsLowerOf( pRetoucheFly ) && !pFly->GetFmt()->GetOpaque().GetValue() )
1390*b1cdbd2cSJim Jagielski //Aus anderem Layer interessieren uns nur nicht transparente
1391*b1cdbd2cSJim Jagielski //oder innenliegende
1392*b1cdbd2cSJim Jagielski continue;
1393*b1cdbd2cSJim Jagielski bStopOnHell = sal_False;
1394*b1cdbd2cSJim Jagielski }
1395*b1cdbd2cSJim Jagielski }
1396*b1cdbd2cSJim Jagielski
1397*b1cdbd2cSJim Jagielski //Wenn der Inhalt des Fly Transparent ist, wird er nicht abgezogen, es sei denn
1398*b1cdbd2cSJim Jagielski //er steht im Hell-Layer (#31941#)
1399*b1cdbd2cSJim Jagielski const IDocumentDrawModelAccess* pIDDMA = pFly->GetFmt()->getIDocumentDrawModelAccess();
1400*b1cdbd2cSJim Jagielski sal_Bool bHell = pSdrObj->GetLayer() == pIDDMA->GetHellId();
1401*b1cdbd2cSJim Jagielski if ( (bStopOnHell && bHell) ||
1402*b1cdbd2cSJim Jagielski /// OD 05.08.2002 - change internal order of condition
1403*b1cdbd2cSJim Jagielski /// first check "!bHell", then "..->Lower()" and "..->IsNoTxtFrm()"
1404*b1cdbd2cSJim Jagielski /// have not to be performed, if frame is in "Hell"
1405*b1cdbd2cSJim Jagielski ( !bHell && pFly->Lower() && pFly->Lower()->IsNoTxtFrm() &&
1406*b1cdbd2cSJim Jagielski ( ((SwNoTxtFrm*)pFly->Lower())->IsTransparent() ||
1407*b1cdbd2cSJim Jagielski ((SwNoTxtFrm*)pFly->Lower())->HasAnimation() ||
1408*b1cdbd2cSJim Jagielski pFly->GetFmt()->GetSurround().IsContour()
1409*b1cdbd2cSJim Jagielski )
1410*b1cdbd2cSJim Jagielski )
1411*b1cdbd2cSJim Jagielski )
1412*b1cdbd2cSJim Jagielski continue;
1413*b1cdbd2cSJim Jagielski
1414*b1cdbd2cSJim Jagielski // OD 08.10.2002 #103898#
1415*b1cdbd2cSJim Jagielski // Own if-statements for transparent background/shadow of fly frames
1416*b1cdbd2cSJim Jagielski // (#99657#) in order to handle special conditions.
1417*b1cdbd2cSJim Jagielski if ( pFly->IsBackgroundTransparent() )
1418*b1cdbd2cSJim Jagielski {
1419*b1cdbd2cSJim Jagielski // Background <pFly> is transparent drawn. Thus normally, its region
1420*b1cdbd2cSJim Jagielski // have not to be substracted from given region.
1421*b1cdbd2cSJim Jagielski // But, if method is called for a fly frame and
1422*b1cdbd2cSJim Jagielski // <pFly> is a direct lower of this fly frame and
1423*b1cdbd2cSJim Jagielski // <pFly> inherites its transparent background brush from its parent,
1424*b1cdbd2cSJim Jagielski // then <pFly> frame area have to be subtracted from given region.
1425*b1cdbd2cSJim Jagielski // NOTE: Because in Status Quo transparent backgrounds can only be
1426*b1cdbd2cSJim Jagielski // assigned to fly frames, the handle of this special case
1427*b1cdbd2cSJim Jagielski // avoids drawing of transparent areas more than once, if
1428*b1cdbd2cSJim Jagielski // a fly frame inherites a transparent background from its
1429*b1cdbd2cSJim Jagielski // parent fly frame.
1430*b1cdbd2cSJim Jagielski if ( pFrm->IsFlyFrm() &&
1431*b1cdbd2cSJim Jagielski (pFly->GetAnchorFrm()->FindFlyFrm() == pFrm) &&
1432*b1cdbd2cSJim Jagielski static_cast<const SwFlyFrmFmt*>(pFly->GetFmt())->IsBackgroundBrushInherited()
1433*b1cdbd2cSJim Jagielski )
1434*b1cdbd2cSJim Jagielski {
1435*b1cdbd2cSJim Jagielski SwRect aRect;
1436*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)pFly );
1437*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
1438*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( aRect, pFly, rAttrs, sal_True );
1439*b1cdbd2cSJim Jagielski rRegion -= aRect;
1440*b1cdbd2cSJim Jagielski continue;
1441*b1cdbd2cSJim Jagielski }
1442*b1cdbd2cSJim Jagielski else
1443*b1cdbd2cSJim Jagielski {
1444*b1cdbd2cSJim Jagielski continue;
1445*b1cdbd2cSJim Jagielski }
1446*b1cdbd2cSJim Jagielski }
1447*b1cdbd2cSJim Jagielski if ( pFly->IsShadowTransparent() )
1448*b1cdbd2cSJim Jagielski {
1449*b1cdbd2cSJim Jagielski continue;
1450*b1cdbd2cSJim Jagielski }
1451*b1cdbd2cSJim Jagielski
1452*b1cdbd2cSJim Jagielski if ( bHell && pFly->GetAnchorFrm()->IsInFly() )
1453*b1cdbd2cSJim Jagielski {
1454*b1cdbd2cSJim Jagielski //Damit die Umrandung nicht vom Hintergrund des anderen Flys
1455*b1cdbd2cSJim Jagielski //zerlegt wird.
1456*b1cdbd2cSJim Jagielski SwRect aRect;
1457*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)pFly );
1458*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
1459*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( aRect, pFly, rAttrs, sal_True );
1460*b1cdbd2cSJim Jagielski rRegion -= aRect;
1461*b1cdbd2cSJim Jagielski }
1462*b1cdbd2cSJim Jagielski else
1463*b1cdbd2cSJim Jagielski {
1464*b1cdbd2cSJim Jagielski SwRect aRect( pFly->Prt() );
1465*b1cdbd2cSJim Jagielski aRect += pFly->Frm().Pos();
1466*b1cdbd2cSJim Jagielski rRegion -= aRect;
1467*b1cdbd2cSJim Jagielski }
1468*b1cdbd2cSJim Jagielski }
1469*b1cdbd2cSJim Jagielski if ( pRetoucheFly == pRetoucheFly2 )
1470*b1cdbd2cSJim Jagielski pRetoucheFly = 0;
1471*b1cdbd2cSJim Jagielski }
1472*b1cdbd2cSJim Jagielski
1473*b1cdbd2cSJim Jagielski // --> OD 2008-05-16 #i84659# - no longer needed
1474*b1cdbd2cSJim Jagielski //inline sal_Bool IsShortCut( const SwRect &rRect, const SwRect &rFrmRect )
1475*b1cdbd2cSJim Jagielski //{
1476*b1cdbd2cSJim Jagielski // //Wenn der Frm vollstaendig rechts neben bzw. unter dem
1477*b1cdbd2cSJim Jagielski // //Rect sitzt ist's genug mit Painten.
1478*b1cdbd2cSJim Jagielski // return rFrmRect.Top() > rRect.Bottom();
1479*b1cdbd2cSJim Jagielski // // PAGES01 || (rFrmRect.Left() > rRect.Right()) );
1480*b1cdbd2cSJim Jagielski //}
1481*b1cdbd2cSJim Jagielski // <--
1482*b1cdbd2cSJim Jagielski
1483*b1cdbd2cSJim Jagielski //---------------- Ausgabe fuer das BrushItem ----------------
1484*b1cdbd2cSJim Jagielski
1485*b1cdbd2cSJim Jagielski /** lcl_DrawGraphicBackgrd - local help method to draw a background for a graphic
1486*b1cdbd2cSJim Jagielski
1487*b1cdbd2cSJim Jagielski OD 17.10.2002 #103876#
1488*b1cdbd2cSJim Jagielski Under certain circumstances we have to draw a background for a graphic.
1489*b1cdbd2cSJim Jagielski This method takes care of the conditions and draws the background with the
1490*b1cdbd2cSJim Jagielski corresponding color.
1491*b1cdbd2cSJim Jagielski Method introduced for bug fix #103876# in order to optimize drawing tiled
1492*b1cdbd2cSJim Jagielski background graphics. Previously, this code was integrated in method
1493*b1cdbd2cSJim Jagielski <lcl_DrawGraphic>.
1494*b1cdbd2cSJim Jagielski Method implemented as a inline, checking the conditions and calling method
1495*b1cdbd2cSJim Jagielski method <lcl_implDrawGraphicBackgrd(..)> for the intrinsic drawing.
1496*b1cdbd2cSJim Jagielski
1497*b1cdbd2cSJim Jagielski @author OD
1498*b1cdbd2cSJim Jagielski
1499*b1cdbd2cSJim Jagielski @param _rBackgrdBrush
1500*b1cdbd2cSJim Jagielski background brush contain the color the background has to be drawn.
1501*b1cdbd2cSJim Jagielski
1502*b1cdbd2cSJim Jagielski @param _pOut
1503*b1cdbd2cSJim Jagielski output device the background has to be drawn in.
1504*b1cdbd2cSJim Jagielski
1505*b1cdbd2cSJim Jagielski @param _rPaintRect
1506*b1cdbd2cSJim Jagielski paint retangle in the output device, which has to be drawn with the background.
1507*b1cdbd2cSJim Jagielski rectangle have to be aligned by method ::SwAlignRect
1508*b1cdbd2cSJim Jagielski
1509*b1cdbd2cSJim Jagielski @param _rGraphicObj
1510*b1cdbd2cSJim Jagielski graphic object, for which the background has to be drawn. Used for checking
1511*b1cdbd2cSJim Jagielski the transparency of its bitmap, its type and if the graphic is drawn transparent
1512*b1cdbd2cSJim Jagielski
1513*b1cdbd2cSJim Jagielski @param _bNumberingGraphic
1514*b1cdbd2cSJim Jagielski boolean indicating that graphic is used as a numbering.
1515*b1cdbd2cSJim Jagielski
1516*b1cdbd2cSJim Jagielski @param _bBackgrdAlreadyDrawn
1517*b1cdbd2cSJim Jagielski boolean (optional; default: false) indicating, if the background is already drawn.
1518*b1cdbd2cSJim Jagielski */
lcl_implDrawGraphicBackgrd(const SvxBrushItem & _rBackgrdBrush,OutputDevice * _pOut,const SwRect & _rAlignedPaintRect,const GraphicObject & _rGraphicObj)1519*b1cdbd2cSJim Jagielski void lcl_implDrawGraphicBackgrd( const SvxBrushItem& _rBackgrdBrush,
1520*b1cdbd2cSJim Jagielski OutputDevice* _pOut,
1521*b1cdbd2cSJim Jagielski const SwRect& _rAlignedPaintRect,
1522*b1cdbd2cSJim Jagielski const GraphicObject& _rGraphicObj )
1523*b1cdbd2cSJim Jagielski {
1524*b1cdbd2cSJim Jagielski /// determine color of background
1525*b1cdbd2cSJim Jagielski /// If color of background brush is not "no fill"/"auto fill" or
1526*b1cdbd2cSJim Jagielski /// <bFlyMetafile> is set, use color of background brush, otherwise
1527*b1cdbd2cSJim Jagielski /// use global retouche color.
1528*b1cdbd2cSJim Jagielski const Color aColor( ( (_rBackgrdBrush.GetColor() != COL_TRANSPARENT) || bFlyMetafile )
1529*b1cdbd2cSJim Jagielski ? _rBackgrdBrush.GetColor()
1530*b1cdbd2cSJim Jagielski : aGlobalRetoucheColor );
1531*b1cdbd2cSJim Jagielski
1532*b1cdbd2cSJim Jagielski /// determine, if background color have to be drawn transparent
1533*b1cdbd2cSJim Jagielski /// and calculate transparency percent value
1534*b1cdbd2cSJim Jagielski sal_Int8 nTransparencyPercent = 0;
1535*b1cdbd2cSJim Jagielski bool bDrawTransparent = false;
1536*b1cdbd2cSJim Jagielski if ( aColor.GetTransparency() != 0 )
1537*b1cdbd2cSJim Jagielski /// background color is transparent --> draw transparent.
1538*b1cdbd2cSJim Jagielski {
1539*b1cdbd2cSJim Jagielski bDrawTransparent = true;
1540*b1cdbd2cSJim Jagielski nTransparencyPercent = (aColor.GetTransparency()*100 + 0x7F)/0xFF;
1541*b1cdbd2cSJim Jagielski }
1542*b1cdbd2cSJim Jagielski else if ( (_rGraphicObj.GetAttr().GetTransparency() != 0) &&
1543*b1cdbd2cSJim Jagielski (_rBackgrdBrush.GetColor() == COL_TRANSPARENT) )
1544*b1cdbd2cSJim Jagielski /// graphic is drawn transparent and background color is
1545*b1cdbd2cSJim Jagielski /// "no fill"/"auto fill" --> draw transparent
1546*b1cdbd2cSJim Jagielski {
1547*b1cdbd2cSJim Jagielski bDrawTransparent = true;
1548*b1cdbd2cSJim Jagielski nTransparencyPercent = (_rGraphicObj.GetAttr().GetTransparency()*100 + 0x7F)/0xFF;
1549*b1cdbd2cSJim Jagielski }
1550*b1cdbd2cSJim Jagielski
1551*b1cdbd2cSJim Jagielski if ( bDrawTransparent )
1552*b1cdbd2cSJim Jagielski {
1553*b1cdbd2cSJim Jagielski /// draw background transparent
1554*b1cdbd2cSJim Jagielski if( _pOut->GetFillColor() != aColor.GetRGBColor() )
1555*b1cdbd2cSJim Jagielski _pOut->SetFillColor( aColor.GetRGBColor() );
1556*b1cdbd2cSJim Jagielski PolyPolygon aPoly( _rAlignedPaintRect.SVRect() );
1557*b1cdbd2cSJim Jagielski _pOut->DrawTransparent( aPoly, nTransparencyPercent );
1558*b1cdbd2cSJim Jagielski }
1559*b1cdbd2cSJim Jagielski else
1560*b1cdbd2cSJim Jagielski {
1561*b1cdbd2cSJim Jagielski /// draw background opaque
1562*b1cdbd2cSJim Jagielski if ( _pOut->GetFillColor() != aColor )
1563*b1cdbd2cSJim Jagielski _pOut->SetFillColor( aColor );
1564*b1cdbd2cSJim Jagielski _pOut->DrawRect( _rAlignedPaintRect.SVRect() );
1565*b1cdbd2cSJim Jagielski }
1566*b1cdbd2cSJim Jagielski }
1567*b1cdbd2cSJim Jagielski
lcl_DrawGraphicBackgrd(const SvxBrushItem & _rBackgrdBrush,OutputDevice * _pOut,const SwRect & _rAlignedPaintRect,const GraphicObject & _rGraphicObj,bool _bNumberingGraphic,bool _bBackgrdAlreadyDrawn=false)1568*b1cdbd2cSJim Jagielski inline void lcl_DrawGraphicBackgrd( const SvxBrushItem& _rBackgrdBrush,
1569*b1cdbd2cSJim Jagielski OutputDevice* _pOut,
1570*b1cdbd2cSJim Jagielski const SwRect& _rAlignedPaintRect,
1571*b1cdbd2cSJim Jagielski const GraphicObject& _rGraphicObj,
1572*b1cdbd2cSJim Jagielski bool _bNumberingGraphic,
1573*b1cdbd2cSJim Jagielski bool _bBackgrdAlreadyDrawn = false )
1574*b1cdbd2cSJim Jagielski {
1575*b1cdbd2cSJim Jagielski /// draw background with background color, if
1576*b1cdbd2cSJim Jagielski /// (1) graphic is not used as a numbering AND
1577*b1cdbd2cSJim Jagielski /// (2) background is not already drawn AND
1578*b1cdbd2cSJim Jagielski /// (3) intrinsic graphic is transparent OR intrinsic graphic doesn't exists
1579*b1cdbd2cSJim Jagielski if ( !_bNumberingGraphic &&
1580*b1cdbd2cSJim Jagielski !_bBackgrdAlreadyDrawn &&
1581*b1cdbd2cSJim Jagielski ( _rGraphicObj.IsTransparent() || _rGraphicObj.GetType() == GRAPHIC_NONE )
1582*b1cdbd2cSJim Jagielski )
1583*b1cdbd2cSJim Jagielski {
1584*b1cdbd2cSJim Jagielski lcl_implDrawGraphicBackgrd( _rBackgrdBrush, _pOut, _rAlignedPaintRect, _rGraphicObj );
1585*b1cdbd2cSJim Jagielski }
1586*b1cdbd2cSJim Jagielski }
1587*b1cdbd2cSJim Jagielski
1588*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - Note: the transparency of the background graphic
1589*b1cdbd2cSJim Jagielski /// is saved in SvxBrushItem.GetGraphicObject(<shell>).GetAttr().Set/GetTransparency()
1590*b1cdbd2cSJim Jagielski /// and is considered in the drawing of the graphic.
1591*b1cdbd2cSJim Jagielski /// Thus, to provide transparent background graphic for text frames nothing
1592*b1cdbd2cSJim Jagielski /// has to be coded.
1593*b1cdbd2cSJim Jagielski /// OD 25.09.2002 #99739# - use align rectangle for drawing graphic
1594*b1cdbd2cSJim Jagielski /// OD 25.09.2002 #99739# - pixel-align coordinations for drawing graphic.
1595*b1cdbd2cSJim Jagielski /// OD 17.10.2002 #103876# - outsource code for drawing background of the graphic
1596*b1cdbd2cSJim Jagielski /// with a background color in method <lcl_DrawGraphicBackgrd>
1597*b1cdbd2cSJim Jagielski /// Also, change type of <bGrfNum> and <bClip> from <sal_Bool> to <bool>.
lcl_DrawGraphic(const SvxBrushItem & rBrush,OutputDevice * pOut,ViewShell & rSh,const SwRect & rGrf,const SwRect & rOut,bool bClip,bool bGrfNum,bool bBackgrdAlreadyDrawn=false)1598*b1cdbd2cSJim Jagielski void lcl_DrawGraphic( const SvxBrushItem& rBrush, OutputDevice *pOut,
1599*b1cdbd2cSJim Jagielski ViewShell &rSh, const SwRect &rGrf, const SwRect &rOut,
1600*b1cdbd2cSJim Jagielski bool bClip, bool bGrfNum,
1601*b1cdbd2cSJim Jagielski bool bBackgrdAlreadyDrawn = false )
1602*b1cdbd2cSJim Jagielski /// OD 02.09.2002 #99657#
1603*b1cdbd2cSJim Jagielski /// add parameter <bBackgrdAlreadyDrawn> to indicate
1604*b1cdbd2cSJim Jagielski /// that the background is already drawn.
1605*b1cdbd2cSJim Jagielski {
1606*b1cdbd2cSJim Jagielski /// OD 25.09.2002 #99739# - calculate align rectangle from parameter <rGrf>
1607*b1cdbd2cSJim Jagielski /// and use aligned rectangle <aAlignedGrfRect> in the following code
1608*b1cdbd2cSJim Jagielski SwRect aAlignedGrfRect = rGrf;
1609*b1cdbd2cSJim Jagielski ::SwAlignRect( aAlignedGrfRect, &rSh );
1610*b1cdbd2cSJim Jagielski
1611*b1cdbd2cSJim Jagielski /// OD 17.10.2002 #103876# - change type from <sal_Bool> to <bool>.
1612*b1cdbd2cSJim Jagielski const bool bNotInside = bClip && !rOut.IsInside( aAlignedGrfRect );
1613*b1cdbd2cSJim Jagielski if ( bNotInside )
1614*b1cdbd2cSJim Jagielski {
1615*b1cdbd2cSJim Jagielski pOut->Push( PUSH_CLIPREGION );
1616*b1cdbd2cSJim Jagielski pOut->IntersectClipRegion( rOut.SVRect() );
1617*b1cdbd2cSJim Jagielski }
1618*b1cdbd2cSJim Jagielski
1619*b1cdbd2cSJim Jagielski //Hier kein Link, wir wollen die Grafik synchron laden!
1620*b1cdbd2cSJim Jagielski ((SvxBrushItem&)rBrush).SetDoneLink( Link() );
1621*b1cdbd2cSJim Jagielski GraphicObject *pGrf = (GraphicObject*)rBrush.GetGraphicObject();
1622*b1cdbd2cSJim Jagielski
1623*b1cdbd2cSJim Jagielski /// OD 17.10.2002 #103876# - outsourcing drawing of background with a background color.
1624*b1cdbd2cSJim Jagielski ::lcl_DrawGraphicBackgrd( rBrush, pOut, aAlignedGrfRect, *pGrf, bGrfNum, bBackgrdAlreadyDrawn );
1625*b1cdbd2cSJim Jagielski
1626*b1cdbd2cSJim Jagielski /// OD 25.09.2002 #99739# -
1627*b1cdbd2cSJim Jagielski /// Because for drawing a graphic left-top-corner and size coordinations are
1628*b1cdbd2cSJim Jagielski /// used, these coordinations have to be determined on pixel level.
1629*b1cdbd2cSJim Jagielski ::SwAlignGrfRect( &aAlignedGrfRect, *pOut );
1630*b1cdbd2cSJim Jagielski pGrf->DrawWithPDFHandling( *pOut, aAlignedGrfRect.Pos(), aAlignedGrfRect.SSize() );
1631*b1cdbd2cSJim Jagielski
1632*b1cdbd2cSJim Jagielski if ( bNotInside )
1633*b1cdbd2cSJim Jagielski pOut->Pop();
1634*b1cdbd2cSJim Jagielski } // end of method <lcl_DrawGraphic>
1635*b1cdbd2cSJim Jagielski
DrawGraphic(const SvxBrushItem * pBrush,OutputDevice * pOutDev,const SwRect & rOrg,const SwRect & rOut,const sal_uInt8 nGrfNum,const sal_Bool bConsiderBackgroundTransparency)1636*b1cdbd2cSJim Jagielski void MA_FASTCALL DrawGraphic( const SvxBrushItem *pBrush,
1637*b1cdbd2cSJim Jagielski OutputDevice *pOutDev,
1638*b1cdbd2cSJim Jagielski const SwRect &rOrg,
1639*b1cdbd2cSJim Jagielski const SwRect &rOut,
1640*b1cdbd2cSJim Jagielski const sal_uInt8 nGrfNum,
1641*b1cdbd2cSJim Jagielski const sal_Bool bConsiderBackgroundTransparency )
1642*b1cdbd2cSJim Jagielski /// OD 05.08.2002 #99657# - add 6th parameter to indicate that method should
1643*b1cdbd2cSJim Jagielski /// consider background transparency, saved in the color of the brush item
1644*b1cdbd2cSJim Jagielski {
1645*b1cdbd2cSJim Jagielski ViewShell &rSh = *pGlobalShell;
1646*b1cdbd2cSJim Jagielski /// OD 17.10.2002 #103876# - change type from <sal_Bool> to <bool>
1647*b1cdbd2cSJim Jagielski bool bReplaceGrfNum = GRFNUM_REPLACE == nGrfNum;
1648*b1cdbd2cSJim Jagielski bool bGrfNum = GRFNUM_NO != nGrfNum;
1649*b1cdbd2cSJim Jagielski Size aGrfSize;
1650*b1cdbd2cSJim Jagielski SvxGraphicPosition ePos = GPOS_NONE;
1651*b1cdbd2cSJim Jagielski if( pBrush && !bReplaceGrfNum )
1652*b1cdbd2cSJim Jagielski {
1653*b1cdbd2cSJim Jagielski if( rSh.GetViewOptions()->IsGraphic() )
1654*b1cdbd2cSJim Jagielski {
1655*b1cdbd2cSJim Jagielski //#125488#: load graphic directly in PDF import
1656*b1cdbd2cSJim Jagielski // --> OD 2006-08-25 #i68953# - also during print load graphic directly.
1657*b1cdbd2cSJim Jagielski if ( (rSh).GetViewOptions()->IsPDFExport() ||
1658*b1cdbd2cSJim Jagielski rSh.GetOut()->GetOutDevType() == OUTDEV_PRINTER )
1659*b1cdbd2cSJim Jagielski // <--
1660*b1cdbd2cSJim Jagielski {
1661*b1cdbd2cSJim Jagielski ((SvxBrushItem*)pBrush)->PurgeMedium();
1662*b1cdbd2cSJim Jagielski ((SvxBrushItem*)pBrush)->SetDoneLink( Link() );
1663*b1cdbd2cSJim Jagielski }
1664*b1cdbd2cSJim Jagielski else
1665*b1cdbd2cSJim Jagielski ((SvxBrushItem*)pBrush)->SetDoneLink( STATIC_LINK(
1666*b1cdbd2cSJim Jagielski rSh.GetDoc(), SwDoc, BackgroundDone ) );
1667*b1cdbd2cSJim Jagielski //SfxObjectShell &rObjSh = *GETOBJSHELL();
1668*b1cdbd2cSJim Jagielski const Graphic* pGrf = pBrush->GetGraphic();
1669*b1cdbd2cSJim Jagielski if( pGrf && GRAPHIC_NONE != pGrf->GetType() )
1670*b1cdbd2cSJim Jagielski {
1671*b1cdbd2cSJim Jagielski ePos = pBrush->GetGraphicPos();
1672*b1cdbd2cSJim Jagielski if( pGrf->IsSupportedGraphic() )
1673*b1cdbd2cSJim Jagielski // don't the use the specific output device! Bug 94802
1674*b1cdbd2cSJim Jagielski aGrfSize = ::GetGraphicSizeTwip( *pGrf, 0 );
1675*b1cdbd2cSJim Jagielski }
1676*b1cdbd2cSJim Jagielski }
1677*b1cdbd2cSJim Jagielski else
1678*b1cdbd2cSJim Jagielski bReplaceGrfNum = bGrfNum;
1679*b1cdbd2cSJim Jagielski }
1680*b1cdbd2cSJim Jagielski
1681*b1cdbd2cSJim Jagielski SwRect aGrf;
1682*b1cdbd2cSJim Jagielski aGrf.SSize( aGrfSize );
1683*b1cdbd2cSJim Jagielski sal_Bool bDraw = sal_True;
1684*b1cdbd2cSJim Jagielski sal_Bool bRetouche = sal_True;
1685*b1cdbd2cSJim Jagielski switch ( ePos )
1686*b1cdbd2cSJim Jagielski {
1687*b1cdbd2cSJim Jagielski case GPOS_LT:
1688*b1cdbd2cSJim Jagielski aGrf.Pos() = rOrg.Pos();
1689*b1cdbd2cSJim Jagielski break;
1690*b1cdbd2cSJim Jagielski
1691*b1cdbd2cSJim Jagielski case GPOS_MT:
1692*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Top();
1693*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Left() + rOrg.Width()/2 - aGrfSize.Width()/2;
1694*b1cdbd2cSJim Jagielski break;
1695*b1cdbd2cSJim Jagielski
1696*b1cdbd2cSJim Jagielski case GPOS_RT:
1697*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Top();
1698*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Right() - aGrfSize.Width();
1699*b1cdbd2cSJim Jagielski break;
1700*b1cdbd2cSJim Jagielski
1701*b1cdbd2cSJim Jagielski case GPOS_LM:
1702*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Top() + rOrg.Height()/2 - aGrfSize.Height()/2;
1703*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Left();
1704*b1cdbd2cSJim Jagielski break;
1705*b1cdbd2cSJim Jagielski
1706*b1cdbd2cSJim Jagielski case GPOS_MM:
1707*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Top() + rOrg.Height()/2 - aGrfSize.Height()/2;
1708*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Left() + rOrg.Width()/2 - aGrfSize.Width()/2;
1709*b1cdbd2cSJim Jagielski break;
1710*b1cdbd2cSJim Jagielski
1711*b1cdbd2cSJim Jagielski case GPOS_RM:
1712*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Top() + rOrg.Height()/2 - aGrfSize.Height()/2;
1713*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Right() - aGrfSize.Width();
1714*b1cdbd2cSJim Jagielski break;
1715*b1cdbd2cSJim Jagielski
1716*b1cdbd2cSJim Jagielski case GPOS_LB:
1717*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Bottom() - aGrfSize.Height();
1718*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Left();
1719*b1cdbd2cSJim Jagielski break;
1720*b1cdbd2cSJim Jagielski
1721*b1cdbd2cSJim Jagielski case GPOS_MB:
1722*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Bottom() - aGrfSize.Height();
1723*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Left() + rOrg.Width()/2 - aGrfSize.Width()/2;
1724*b1cdbd2cSJim Jagielski break;
1725*b1cdbd2cSJim Jagielski
1726*b1cdbd2cSJim Jagielski case GPOS_RB:
1727*b1cdbd2cSJim Jagielski aGrf.Pos().Y() = rOrg.Bottom() - aGrfSize.Height();
1728*b1cdbd2cSJim Jagielski aGrf.Pos().X() = rOrg.Right() - aGrfSize.Width();
1729*b1cdbd2cSJim Jagielski break;
1730*b1cdbd2cSJim Jagielski
1731*b1cdbd2cSJim Jagielski case GPOS_AREA:
1732*b1cdbd2cSJim Jagielski aGrf = rOrg;
1733*b1cdbd2cSJim Jagielski /// OD 05.09.2002 #102912#
1734*b1cdbd2cSJim Jagielski /// In spite the fact that the background graphic have to fill the complete
1735*b1cdbd2cSJim Jagielski /// area, it has been checked, if the graphic will completely fill out
1736*b1cdbd2cSJim Jagielski /// the region to be painted <rOut> and thus, nothing has to be retouched.
1737*b1cdbd2cSJim Jagielski /// For example, this is the case for a fly frame without a background
1738*b1cdbd2cSJim Jagielski /// brush positioned on the border of the page and inherited the
1739*b1cdbd2cSJim Jagielski /// background brush from the page.
1740*b1cdbd2cSJim Jagielski bRetouche = !rOut.IsInside( aGrf );
1741*b1cdbd2cSJim Jagielski break;
1742*b1cdbd2cSJim Jagielski
1743*b1cdbd2cSJim Jagielski case GPOS_TILED:
1744*b1cdbd2cSJim Jagielski {
1745*b1cdbd2cSJim Jagielski // OD 17.10.2002 #103876# - draw background of tiled graphic
1746*b1cdbd2cSJim Jagielski // before drawing tiled graphic in loop
1747*b1cdbd2cSJim Jagielski // determine graphic object
1748*b1cdbd2cSJim Jagielski GraphicObject* pGraphicObj = const_cast< GraphicObject* >(pBrush->GetGraphicObject());
1749*b1cdbd2cSJim Jagielski // calculate aligned paint rectangle
1750*b1cdbd2cSJim Jagielski SwRect aAlignedPaintRect = rOut;
1751*b1cdbd2cSJim Jagielski ::SwAlignRect( aAlignedPaintRect, &rSh );
1752*b1cdbd2cSJim Jagielski // OD 25.10.2002 #103876# - draw background color for aligned paint rectangle
1753*b1cdbd2cSJim Jagielski lcl_DrawGraphicBackgrd( *pBrush, pOutDev, aAlignedPaintRect, *pGraphicObj, bGrfNum );
1754*b1cdbd2cSJim Jagielski
1755*b1cdbd2cSJim Jagielski // set left-top-corner of background graphic to left-top-corner of the
1756*b1cdbd2cSJim Jagielski // area, from which the background brush is determined.
1757*b1cdbd2cSJim Jagielski aGrf.Pos() = rOrg.Pos();
1758*b1cdbd2cSJim Jagielski // setup clipping at output device
1759*b1cdbd2cSJim Jagielski pOutDev->Push( PUSH_CLIPREGION );
1760*b1cdbd2cSJim Jagielski pOutDev->IntersectClipRegion( rOut.SVRect() );
1761*b1cdbd2cSJim Jagielski // OD 28.10.2002 #103876# - use new method <GraphicObject::DrawTiled(::)>
1762*b1cdbd2cSJim Jagielski {
1763*b1cdbd2cSJim Jagielski // calculate paint offset
1764*b1cdbd2cSJim Jagielski Point aPaintOffset( aAlignedPaintRect.Pos() - aGrf.Pos() );
1765*b1cdbd2cSJim Jagielski // draw background graphic tiled for aligned paint rectangle
1766*b1cdbd2cSJim Jagielski // --> OD 2005-02-15 #i42643# - apply fix #104004# for Calc
1767*b1cdbd2cSJim Jagielski // also for Writer - see /sc/source/view/printfun.cxx
1768*b1cdbd2cSJim Jagielski // For PDF export, every draw operation for bitmaps takes a
1769*b1cdbd2cSJim Jagielski // noticeable amount of place (~50 characters). Thus, optimize
1770*b1cdbd2cSJim Jagielski // between tile bitmap size and number of drawing operations here.
1771*b1cdbd2cSJim Jagielski //
1772*b1cdbd2cSJim Jagielski // A_out
1773*b1cdbd2cSJim Jagielski // n_chars = k1 * ---------- + k2 * A_bitmap
1774*b1cdbd2cSJim Jagielski // A_bitmap
1775*b1cdbd2cSJim Jagielski //
1776*b1cdbd2cSJim Jagielski // minimum n_chars is obtained for (derive for A_bitmap,
1777*b1cdbd2cSJim Jagielski // set to 0, take positive solution):
1778*b1cdbd2cSJim Jagielski // k1
1779*b1cdbd2cSJim Jagielski // A_bitmap = Sqrt( ---- A_out )
1780*b1cdbd2cSJim Jagielski // k2
1781*b1cdbd2cSJim Jagielski //
1782*b1cdbd2cSJim Jagielski // where k1 is the number of chars per draw operation, and
1783*b1cdbd2cSJim Jagielski // k2 is the number of chars per bitmap pixel.
1784*b1cdbd2cSJim Jagielski // This is approximately 50 and 7 for current PDF writer, respectively.
1785*b1cdbd2cSJim Jagielski //
1786*b1cdbd2cSJim Jagielski const double k1( 50 );
1787*b1cdbd2cSJim Jagielski const double k2( 7 );
1788*b1cdbd2cSJim Jagielski const Size aSize( aAlignedPaintRect.SSize() );
1789*b1cdbd2cSJim Jagielski const double Abitmap( k1/k2 * static_cast<double>(aSize.Width())*aSize.Height() );
1790*b1cdbd2cSJim Jagielski
1791*b1cdbd2cSJim Jagielski pGraphicObj->DrawTiled( pOutDev,
1792*b1cdbd2cSJim Jagielski aAlignedPaintRect.SVRect(),
1793*b1cdbd2cSJim Jagielski aGrf.SSize(),
1794*b1cdbd2cSJim Jagielski Size( aPaintOffset.X(), aPaintOffset.Y() ),
1795*b1cdbd2cSJim Jagielski NULL, GRFMGR_DRAW_STANDARD,
1796*b1cdbd2cSJim Jagielski ::std::max( 128, static_cast<int>( sqrt(sqrt( Abitmap)) + .5 ) ) );
1797*b1cdbd2cSJim Jagielski // <--
1798*b1cdbd2cSJim Jagielski }
1799*b1cdbd2cSJim Jagielski // reset clipping at output device
1800*b1cdbd2cSJim Jagielski pOutDev->Pop();
1801*b1cdbd2cSJim Jagielski // set <bDraw> and <bRetouche> to false, indicating that background
1802*b1cdbd2cSJim Jagielski // graphic and background are already drawn.
1803*b1cdbd2cSJim Jagielski bDraw = bRetouche = sal_False;
1804*b1cdbd2cSJim Jagielski }
1805*b1cdbd2cSJim Jagielski break;
1806*b1cdbd2cSJim Jagielski
1807*b1cdbd2cSJim Jagielski case GPOS_NONE:
1808*b1cdbd2cSJim Jagielski bDraw = sal_False;
1809*b1cdbd2cSJim Jagielski break;
1810*b1cdbd2cSJim Jagielski
1811*b1cdbd2cSJim Jagielski default: ASSERT( !pOutDev, "new Graphic position?" );
1812*b1cdbd2cSJim Jagielski }
1813*b1cdbd2cSJim Jagielski
1814*b1cdbd2cSJim Jagielski /// OD 02.09.2002 #99657#
1815*b1cdbd2cSJim Jagielski /// init variable <bGrfBackgrdAlreadDrawn> to indicate, if background of
1816*b1cdbd2cSJim Jagielski /// graphic is already drawn or not.
1817*b1cdbd2cSJim Jagielski bool bGrfBackgrdAlreadyDrawn = false;
1818*b1cdbd2cSJim Jagielski if ( bRetouche )
1819*b1cdbd2cSJim Jagielski {
1820*b1cdbd2cSJim Jagielski // OD 2004-04-23 #116347#
1821*b1cdbd2cSJim Jagielski pOutDev->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
1822*b1cdbd2cSJim Jagielski pOutDev->SetLineColor();
1823*b1cdbd2cSJim Jagielski
1824*b1cdbd2cSJim Jagielski // OD 07.08.2002 #99657# #GetTransChg#
1825*b1cdbd2cSJim Jagielski // check, if a existing background graphic (not filling the complete
1826*b1cdbd2cSJim Jagielski // background) is transparent drawn and the background color is
1827*b1cdbd2cSJim Jagielski // "no fill" respectively "auto fill", if background transparency
1828*b1cdbd2cSJim Jagielski // has to be considered.
1829*b1cdbd2cSJim Jagielski // If YES, memorise transparency of background graphic.
1830*b1cdbd2cSJim Jagielski // check also, if background graphic bitmap is transparent.
1831*b1cdbd2cSJim Jagielski bool bTransparentGrfWithNoFillBackgrd = false;
1832*b1cdbd2cSJim Jagielski sal_Int32 nGrfTransparency = 0;
1833*b1cdbd2cSJim Jagielski bool bGrfIsTransparent = false;
1834*b1cdbd2cSJim Jagielski if ( (ePos != GPOS_NONE) &&
1835*b1cdbd2cSJim Jagielski (ePos != GPOS_TILED) && (ePos != GPOS_AREA)
1836*b1cdbd2cSJim Jagielski )
1837*b1cdbd2cSJim Jagielski {
1838*b1cdbd2cSJim Jagielski GraphicObject *pGrf = (GraphicObject*)pBrush->GetGraphicObject();
1839*b1cdbd2cSJim Jagielski if ( bConsiderBackgroundTransparency )
1840*b1cdbd2cSJim Jagielski {
1841*b1cdbd2cSJim Jagielski GraphicAttr pGrfAttr = pGrf->GetAttr();
1842*b1cdbd2cSJim Jagielski if ( (pGrfAttr.GetTransparency() != 0) &&
1843*b1cdbd2cSJim Jagielski ( pBrush && (pBrush->GetColor() == COL_TRANSPARENT) )
1844*b1cdbd2cSJim Jagielski )
1845*b1cdbd2cSJim Jagielski {
1846*b1cdbd2cSJim Jagielski bTransparentGrfWithNoFillBackgrd = true;
1847*b1cdbd2cSJim Jagielski nGrfTransparency = pGrfAttr.GetTransparency();
1848*b1cdbd2cSJim Jagielski }
1849*b1cdbd2cSJim Jagielski }
1850*b1cdbd2cSJim Jagielski if ( pGrf->IsTransparent() )
1851*b1cdbd2cSJim Jagielski {
1852*b1cdbd2cSJim Jagielski bGrfIsTransparent = true;
1853*b1cdbd2cSJim Jagielski }
1854*b1cdbd2cSJim Jagielski }
1855*b1cdbd2cSJim Jagielski
1856*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# #GetTransChg# - to get color of brush,
1857*b1cdbd2cSJim Jagielski /// check background color against COL_TRANSPARENT ("no fill"/"auto fill")
1858*b1cdbd2cSJim Jagielski /// instead of checking, if transparency is not set.
1859*b1cdbd2cSJim Jagielski const Color aColor( pBrush &&
1860*b1cdbd2cSJim Jagielski ( !(pBrush->GetColor() == COL_TRANSPARENT) ||
1861*b1cdbd2cSJim Jagielski bFlyMetafile )
1862*b1cdbd2cSJim Jagielski ? pBrush->GetColor()
1863*b1cdbd2cSJim Jagielski : aGlobalRetoucheColor );
1864*b1cdbd2cSJim Jagielski
1865*b1cdbd2cSJim Jagielski /// OD 08.08.2002 #99657# - determine, if background region have to be
1866*b1cdbd2cSJim Jagielski /// drawn transparent.
1867*b1cdbd2cSJim Jagielski /// background region has to be drawn transparent, if
1868*b1cdbd2cSJim Jagielski /// background transparency have to be considered
1869*b1cdbd2cSJim Jagielski /// AND
1870*b1cdbd2cSJim Jagielski /// ( background color is transparent OR
1871*b1cdbd2cSJim Jagielski /// background graphic is transparent and background color is "no fill"
1872*b1cdbd2cSJim Jagielski /// )
1873*b1cdbd2cSJim Jagielski sal_Bool bDrawTransparent = bConsiderBackgroundTransparency &&
1874*b1cdbd2cSJim Jagielski ( ( aColor.GetTransparency() != 0) ||
1875*b1cdbd2cSJim Jagielski bTransparentGrfWithNoFillBackgrd );
1876*b1cdbd2cSJim Jagielski
1877*b1cdbd2cSJim Jagielski // --> OD 2008-06-02 #i75614#
1878*b1cdbd2cSJim Jagielski // reset draw mode in high contrast mode in order to get fill color set
1879*b1cdbd2cSJim Jagielski const sal_uLong nOldDrawMode = pOutDev->GetDrawMode();
1880*b1cdbd2cSJim Jagielski if ( pGlobalShell->GetWin() &&
1881*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
1882*b1cdbd2cSJim Jagielski {
1883*b1cdbd2cSJim Jagielski pOutDev->SetDrawMode( 0 );
1884*b1cdbd2cSJim Jagielski }
1885*b1cdbd2cSJim Jagielski // <--
1886*b1cdbd2cSJim Jagielski
1887*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - if background region have to be drawn
1888*b1cdbd2cSJim Jagielski /// transparent, set only the RGB values of the background color as
1889*b1cdbd2cSJim Jagielski /// the fill color for the output device.
1890*b1cdbd2cSJim Jagielski if ( bDrawTransparent )
1891*b1cdbd2cSJim Jagielski {
1892*b1cdbd2cSJim Jagielski if( pOutDev->GetFillColor() != aColor.GetRGBColor() )
1893*b1cdbd2cSJim Jagielski pOutDev->SetFillColor( aColor.GetRGBColor() );
1894*b1cdbd2cSJim Jagielski }
1895*b1cdbd2cSJim Jagielski else
1896*b1cdbd2cSJim Jagielski {
1897*b1cdbd2cSJim Jagielski if( pOutDev->GetFillColor() != aColor )
1898*b1cdbd2cSJim Jagielski pOutDev->SetFillColor( aColor );
1899*b1cdbd2cSJim Jagielski }
1900*b1cdbd2cSJim Jagielski
1901*b1cdbd2cSJim Jagielski // --> OD 2008-06-02 #i75614#
1902*b1cdbd2cSJim Jagielski // restore draw mode
1903*b1cdbd2cSJim Jagielski pOutDev->SetDrawMode( nOldDrawMode );
1904*b1cdbd2cSJim Jagielski // <--
1905*b1cdbd2cSJim Jagielski
1906*b1cdbd2cSJim Jagielski /// OD 02.09.2002 #99657#
1907*b1cdbd2cSJim Jagielski if ( bDrawTransparent )
1908*b1cdbd2cSJim Jagielski {
1909*b1cdbd2cSJim Jagielski /// background region have to be drawn transparent.
1910*b1cdbd2cSJim Jagielski /// Thus, create a poly-polygon from the region and draw it with
1911*b1cdbd2cSJim Jagielski /// the corresponding transparency precent.
1912*b1cdbd2cSJim Jagielski PolyPolygon aDrawPoly( rOut.SVRect() );
1913*b1cdbd2cSJim Jagielski if ( aGrf.HasArea() )
1914*b1cdbd2cSJim Jagielski {
1915*b1cdbd2cSJim Jagielski if ( !bGrfIsTransparent )
1916*b1cdbd2cSJim Jagielski {
1917*b1cdbd2cSJim Jagielski /// substract area of background graphic from draw area
1918*b1cdbd2cSJim Jagielski /// OD 08.10.2002 #103898# - consider only that part of the
1919*b1cdbd2cSJim Jagielski /// graphic area that is overlapping with draw area.
1920*b1cdbd2cSJim Jagielski SwRect aTmpGrf = aGrf;
1921*b1cdbd2cSJim Jagielski aTmpGrf.Intersection( rOut );
1922*b1cdbd2cSJim Jagielski if ( aTmpGrf.HasArea() )
1923*b1cdbd2cSJim Jagielski {
1924*b1cdbd2cSJim Jagielski Polygon aGrfPoly( aTmpGrf.SVRect() );
1925*b1cdbd2cSJim Jagielski aDrawPoly.Insert( aGrfPoly );
1926*b1cdbd2cSJim Jagielski }
1927*b1cdbd2cSJim Jagielski }
1928*b1cdbd2cSJim Jagielski else
1929*b1cdbd2cSJim Jagielski bGrfBackgrdAlreadyDrawn = true;
1930*b1cdbd2cSJim Jagielski }
1931*b1cdbd2cSJim Jagielski /// calculate transparency percent:
1932*b1cdbd2cSJim Jagielski /// ( <transparency value[0x01..0xFF]>*100 + 0x7F ) / 0xFF
1933*b1cdbd2cSJim Jagielski /// If there is a background graphic with a background color "no fill"/"auto fill",
1934*b1cdbd2cSJim Jagielski /// the transparency value is taken from the background graphic,
1935*b1cdbd2cSJim Jagielski /// otherwise take the transparency value from the color.
1936*b1cdbd2cSJim Jagielski sal_Int8 nTransparencyPercent = static_cast<sal_Int8>(
1937*b1cdbd2cSJim Jagielski (( bTransparentGrfWithNoFillBackgrd ? nGrfTransparency : aColor.GetTransparency()
1938*b1cdbd2cSJim Jagielski )*100 + 0x7F)/0xFF);
1939*b1cdbd2cSJim Jagielski /// draw poly-polygon transparent
1940*b1cdbd2cSJim Jagielski pOutDev->DrawTransparent( aDrawPoly, nTransparencyPercent );
1941*b1cdbd2cSJim Jagielski }
1942*b1cdbd2cSJim Jagielski else
1943*b1cdbd2cSJim Jagielski {
1944*b1cdbd2cSJim Jagielski SwRegionRects aRegion( rOut, 4 );
1945*b1cdbd2cSJim Jagielski if ( !bGrfIsTransparent )
1946*b1cdbd2cSJim Jagielski aRegion -= aGrf;
1947*b1cdbd2cSJim Jagielski else
1948*b1cdbd2cSJim Jagielski bGrfBackgrdAlreadyDrawn = true;
1949*b1cdbd2cSJim Jagielski /// loop rectangles of background region, which has to be drawn
1950*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
1951*b1cdbd2cSJim Jagielski {
1952*b1cdbd2cSJim Jagielski pOutDev->DrawRect( aRegion[i].SVRect() );
1953*b1cdbd2cSJim Jagielski }
1954*b1cdbd2cSJim Jagielski }
1955*b1cdbd2cSJim Jagielski pOutDev ->Pop();
1956*b1cdbd2cSJim Jagielski }
1957*b1cdbd2cSJim Jagielski
1958*b1cdbd2cSJim Jagielski if( bDraw && aGrf.IsOver( rOut ) )
1959*b1cdbd2cSJim Jagielski /// OD 02.09.2002 #99657#
1960*b1cdbd2cSJim Jagielski /// add parameter <bGrfBackgrdAlreadyDrawn>
1961*b1cdbd2cSJim Jagielski lcl_DrawGraphic( *pBrush, pOutDev, rSh, aGrf, rOut, true, bGrfNum,
1962*b1cdbd2cSJim Jagielski bGrfBackgrdAlreadyDrawn );
1963*b1cdbd2cSJim Jagielski
1964*b1cdbd2cSJim Jagielski if( bReplaceGrfNum )
1965*b1cdbd2cSJim Jagielski {
1966*b1cdbd2cSJim Jagielski const BitmapEx& rBmp = ViewShell::GetReplacementBitmap( false );
1967*b1cdbd2cSJim Jagielski Font aTmp( pOutDev->GetFont() );
1968*b1cdbd2cSJim Jagielski Graphic::DrawEx( pOutDev, aEmptyStr, aTmp, rBmp, rOrg.Pos(), rOrg.SSize() );
1969*b1cdbd2cSJim Jagielski }
1970*b1cdbd2cSJim Jagielski }
1971*b1cdbd2cSJim Jagielski
1972*b1cdbd2cSJim Jagielski //------------------------------------------------------------------------
1973*b1cdbd2cSJim Jagielski
1974*b1cdbd2cSJim Jagielski /** local help method for SwRootFrm::Paint(..) - Adjust given rectangle to pixel size
1975*b1cdbd2cSJim Jagielski
1976*b1cdbd2cSJim Jagielski By OD at 27.09.2002 for #103636#
1977*b1cdbd2cSJim Jagielski In order to avoid paint errors caused by multiple alignments - e.g. method
1978*b1cdbd2cSJim Jagielski ::SwAlignRect(..) - and other changes to the rectangle to be painted,
1979*b1cdbd2cSJim Jagielski this method is called for the rectangle to be painted in order to
1980*b1cdbd2cSJim Jagielski adjust it to the pixel it is overlapping.
1981*b1cdbd2cSJim Jagielski
1982*b1cdbd2cSJim Jagielski @author OD
1983*b1cdbd2cSJim Jagielski */
lcl_AdjustRectToPixelSize(SwRect & io_aSwRect,const OutputDevice & aOut)1984*b1cdbd2cSJim Jagielski void lcl_AdjustRectToPixelSize( SwRect& io_aSwRect, const OutputDevice &aOut )
1985*b1cdbd2cSJim Jagielski {
1986*b1cdbd2cSJim Jagielski /// local constant object of class <Size> to determine number of Twips
1987*b1cdbd2cSJim Jagielski /// representing a pixel.
1988*b1cdbd2cSJim Jagielski const Size aTwipToPxSize( aOut.PixelToLogic( Size( 1,1 )) );
1989*b1cdbd2cSJim Jagielski
1990*b1cdbd2cSJim Jagielski /// local object of class <Rectangle> in Twip coordinates
1991*b1cdbd2cSJim Jagielski /// calculated from given rectangle aligned to pixel centers.
1992*b1cdbd2cSJim Jagielski const Rectangle aPxCenterRect = aOut.PixelToLogic(
1993*b1cdbd2cSJim Jagielski aOut.LogicToPixel( io_aSwRect.SVRect() ) );
1994*b1cdbd2cSJim Jagielski
1995*b1cdbd2cSJim Jagielski /// local constant object of class <Rectangle> representing given rectangle
1996*b1cdbd2cSJim Jagielski /// in pixel.
1997*b1cdbd2cSJim Jagielski const Rectangle aOrgPxRect = aOut.LogicToPixel( io_aSwRect.SVRect() );
1998*b1cdbd2cSJim Jagielski
1999*b1cdbd2cSJim Jagielski /// calculate adjusted rectangle from pixel centered rectangle.
2000*b1cdbd2cSJim Jagielski /// Due to rounding differences <aPxCenterRect> doesn't exactly represents
2001*b1cdbd2cSJim Jagielski /// the Twip-centers. Thus, adjust borders by half of pixel width/height plus 1.
2002*b1cdbd2cSJim Jagielski /// Afterwards, adjust calculated Twip-positions of the all borders.
2003*b1cdbd2cSJim Jagielski Rectangle aSizedRect = aPxCenterRect;
2004*b1cdbd2cSJim Jagielski aSizedRect.Left() -= (aTwipToPxSize.Width()/2 + 1);
2005*b1cdbd2cSJim Jagielski aSizedRect.Right() += (aTwipToPxSize.Width()/2 + 1);
2006*b1cdbd2cSJim Jagielski aSizedRect.Top() -= (aTwipToPxSize.Height()/2 + 1);
2007*b1cdbd2cSJim Jagielski aSizedRect.Bottom() += (aTwipToPxSize.Height()/2 + 1);
2008*b1cdbd2cSJim Jagielski
2009*b1cdbd2cSJim Jagielski /// adjust left()
2010*b1cdbd2cSJim Jagielski while ( (aOut.LogicToPixel(aSizedRect)).Left() < aOrgPxRect.Left() )
2011*b1cdbd2cSJim Jagielski {
2012*b1cdbd2cSJim Jagielski ++aSizedRect.Left();
2013*b1cdbd2cSJim Jagielski }
2014*b1cdbd2cSJim Jagielski /// adjust right()
2015*b1cdbd2cSJim Jagielski while ( (aOut.LogicToPixel(aSizedRect)).Right() > aOrgPxRect.Right() )
2016*b1cdbd2cSJim Jagielski {
2017*b1cdbd2cSJim Jagielski --aSizedRect.Right();
2018*b1cdbd2cSJim Jagielski }
2019*b1cdbd2cSJim Jagielski /// adjust top()
2020*b1cdbd2cSJim Jagielski while ( (aOut.LogicToPixel(aSizedRect)).Top() < aOrgPxRect.Top() )
2021*b1cdbd2cSJim Jagielski {
2022*b1cdbd2cSJim Jagielski ++aSizedRect.Top();
2023*b1cdbd2cSJim Jagielski }
2024*b1cdbd2cSJim Jagielski /// adjust bottom()
2025*b1cdbd2cSJim Jagielski while ( (aOut.LogicToPixel(aSizedRect)).Bottom() > aOrgPxRect.Bottom() )
2026*b1cdbd2cSJim Jagielski {
2027*b1cdbd2cSJim Jagielski --aSizedRect.Bottom();
2028*b1cdbd2cSJim Jagielski }
2029*b1cdbd2cSJim Jagielski
2030*b1cdbd2cSJim Jagielski io_aSwRect = SwRect( aSizedRect );
2031*b1cdbd2cSJim Jagielski
2032*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
2033*b1cdbd2cSJim Jagielski Rectangle aTestOrgPxRect = aOut.LogicToPixel( io_aSwRect.SVRect() );
2034*b1cdbd2cSJim Jagielski Rectangle aTestNewPxRect = aOut.LogicToPixel( aSizedRect );
2035*b1cdbd2cSJim Jagielski ASSERT( aTestOrgPxRect == aTestNewPxRect,
2036*b1cdbd2cSJim Jagielski "Error in lcl_AlignRectToPixelSize(..): Adjusted rectangle has incorrect position or size");
2037*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
2038*b1cdbd2cSJim Jagielski Rectangle aTestNewRect( aSizedRect );
2039*b1cdbd2cSJim Jagielski /// check Left()
2040*b1cdbd2cSJim Jagielski --aSizedRect.Left();
2041*b1cdbd2cSJim Jagielski aTestNewPxRect = aOut.LogicToPixel( aSizedRect );
2042*b1cdbd2cSJim Jagielski ASSERT( aTestOrgPxRect.Left() >= (aTestNewPxRect.Left()+1),
2043*b1cdbd2cSJim Jagielski "Error in lcl_AlignRectToPixelSize(..): Left() not correct adjusted");
2044*b1cdbd2cSJim Jagielski ++aSizedRect.Left();
2045*b1cdbd2cSJim Jagielski /// check Right()
2046*b1cdbd2cSJim Jagielski ++aSizedRect.Right();
2047*b1cdbd2cSJim Jagielski aTestNewPxRect = aOut.LogicToPixel( aSizedRect );
2048*b1cdbd2cSJim Jagielski ASSERT( aTestOrgPxRect.Right() <= (aTestNewPxRect.Right()-1),
2049*b1cdbd2cSJim Jagielski "Error in lcl_AlignRectToPixelSize(..): Right() not correct adjusted");
2050*b1cdbd2cSJim Jagielski --aSizedRect.Right();
2051*b1cdbd2cSJim Jagielski /// check Top()
2052*b1cdbd2cSJim Jagielski --aSizedRect.Top();
2053*b1cdbd2cSJim Jagielski aTestNewPxRect = aOut.LogicToPixel( aSizedRect );
2054*b1cdbd2cSJim Jagielski ASSERT( aTestOrgPxRect.Top() >= (aTestNewPxRect.Top()+1),
2055*b1cdbd2cSJim Jagielski "Error in lcl_AlignRectToPixelSize(..): Top() not correct adjusted");
2056*b1cdbd2cSJim Jagielski ++aSizedRect.Top();
2057*b1cdbd2cSJim Jagielski /// check Bottom()
2058*b1cdbd2cSJim Jagielski ++aSizedRect.Bottom();
2059*b1cdbd2cSJim Jagielski aTestNewPxRect = aOut.LogicToPixel( aSizedRect );
2060*b1cdbd2cSJim Jagielski ASSERT( aTestOrgPxRect.Bottom() <= (aTestNewPxRect.Bottom()-1),
2061*b1cdbd2cSJim Jagielski "Error in lcl_AlignRectToPixelSize(..): Bottom() not correct adjusted");
2062*b1cdbd2cSJim Jagielski --aSizedRect.Bottom();
2063*b1cdbd2cSJim Jagielski #endif
2064*b1cdbd2cSJim Jagielski #endif
2065*b1cdbd2cSJim Jagielski }
2066*b1cdbd2cSJim Jagielski
2067*b1cdbd2cSJim Jagielski
2068*b1cdbd2cSJim Jagielski //
2069*b1cdbd2cSJim Jagielski // FUNCTIONS USED FOR COLLAPSING TABLE BORDER LINES START
2070*b1cdbd2cSJim Jagielski //
2071*b1cdbd2cSJim Jagielski
2072*b1cdbd2cSJim Jagielski struct SwLineEntry
2073*b1cdbd2cSJim Jagielski {
2074*b1cdbd2cSJim Jagielski SwTwips mnKey;
2075*b1cdbd2cSJim Jagielski SwTwips mnStartPos;
2076*b1cdbd2cSJim Jagielski SwTwips mnEndPos;
2077*b1cdbd2cSJim Jagielski
2078*b1cdbd2cSJim Jagielski svx::frame::Style maAttribute;
2079*b1cdbd2cSJim Jagielski
2080*b1cdbd2cSJim Jagielski enum OverlapType { NO_OVERLAP, OVERLAP1, OVERLAP2, OVERLAP3 };
2081*b1cdbd2cSJim Jagielski
2082*b1cdbd2cSJim Jagielski public:
2083*b1cdbd2cSJim Jagielski SwLineEntry( SwTwips nKey,
2084*b1cdbd2cSJim Jagielski SwTwips nStartPos,
2085*b1cdbd2cSJim Jagielski SwTwips nEndPos,
2086*b1cdbd2cSJim Jagielski const svx::frame::Style& rAttribute );
2087*b1cdbd2cSJim Jagielski
2088*b1cdbd2cSJim Jagielski OverlapType Overlaps( const SwLineEntry& rComp ) const;
2089*b1cdbd2cSJim Jagielski };
2090*b1cdbd2cSJim Jagielski
SwLineEntry(SwTwips nKey,SwTwips nStartPos,SwTwips nEndPos,const svx::frame::Style & rAttribute)2091*b1cdbd2cSJim Jagielski SwLineEntry::SwLineEntry( SwTwips nKey,
2092*b1cdbd2cSJim Jagielski SwTwips nStartPos,
2093*b1cdbd2cSJim Jagielski SwTwips nEndPos,
2094*b1cdbd2cSJim Jagielski const svx::frame::Style& rAttribute )
2095*b1cdbd2cSJim Jagielski : mnKey( nKey ),
2096*b1cdbd2cSJim Jagielski mnStartPos( nStartPos ),
2097*b1cdbd2cSJim Jagielski mnEndPos( nEndPos ),
2098*b1cdbd2cSJim Jagielski maAttribute( rAttribute )
2099*b1cdbd2cSJim Jagielski {
2100*b1cdbd2cSJim Jagielski }
2101*b1cdbd2cSJim Jagielski
2102*b1cdbd2cSJim Jagielski /*
2103*b1cdbd2cSJim Jagielski
2104*b1cdbd2cSJim Jagielski 1. ---------- rOld
2105*b1cdbd2cSJim Jagielski ---------- rNew
2106*b1cdbd2cSJim Jagielski
2107*b1cdbd2cSJim Jagielski 2. ---------- rOld
2108*b1cdbd2cSJim Jagielski ------------- rNew
2109*b1cdbd2cSJim Jagielski
2110*b1cdbd2cSJim Jagielski 3. ------- rOld
2111*b1cdbd2cSJim Jagielski ------------- rNew
2112*b1cdbd2cSJim Jagielski
2113*b1cdbd2cSJim Jagielski 4. ------------- rOld
2114*b1cdbd2cSJim Jagielski ---------- rNew
2115*b1cdbd2cSJim Jagielski
2116*b1cdbd2cSJim Jagielski 5. ---------- rOld
2117*b1cdbd2cSJim Jagielski ---- rNew
2118*b1cdbd2cSJim Jagielski
2119*b1cdbd2cSJim Jagielski 6. ---------- rOld
2120*b1cdbd2cSJim Jagielski ---------- rNew
2121*b1cdbd2cSJim Jagielski
2122*b1cdbd2cSJim Jagielski 7. ------------- rOld
2123*b1cdbd2cSJim Jagielski ---------- rNew
2124*b1cdbd2cSJim Jagielski
2125*b1cdbd2cSJim Jagielski 8. ---------- rOld
2126*b1cdbd2cSJim Jagielski ------------- rNew
2127*b1cdbd2cSJim Jagielski
2128*b1cdbd2cSJim Jagielski 9. ---------- rOld
2129*b1cdbd2cSJim Jagielski ---------- rNew
2130*b1cdbd2cSJim Jagielski */
2131*b1cdbd2cSJim Jagielski
Overlaps(const SwLineEntry & rNew) const2132*b1cdbd2cSJim Jagielski SwLineEntry::OverlapType SwLineEntry::Overlaps( const SwLineEntry& rNew ) const
2133*b1cdbd2cSJim Jagielski {
2134*b1cdbd2cSJim Jagielski SwLineEntry::OverlapType eRet = OVERLAP3;
2135*b1cdbd2cSJim Jagielski
2136*b1cdbd2cSJim Jagielski if ( mnStartPos >= rNew.mnEndPos || mnEndPos <= rNew.mnStartPos )
2137*b1cdbd2cSJim Jagielski eRet = NO_OVERLAP;
2138*b1cdbd2cSJim Jagielski
2139*b1cdbd2cSJim Jagielski // 1, 2, 3
2140*b1cdbd2cSJim Jagielski else if ( mnEndPos < rNew.mnEndPos )
2141*b1cdbd2cSJim Jagielski eRet = OVERLAP1;
2142*b1cdbd2cSJim Jagielski
2143*b1cdbd2cSJim Jagielski // 4, 5, 6, 7
2144*b1cdbd2cSJim Jagielski else if ( mnStartPos <= rNew.mnStartPos && mnEndPos >= rNew.mnEndPos )
2145*b1cdbd2cSJim Jagielski eRet = OVERLAP2;
2146*b1cdbd2cSJim Jagielski
2147*b1cdbd2cSJim Jagielski // 8, 9
2148*b1cdbd2cSJim Jagielski return eRet;
2149*b1cdbd2cSJim Jagielski }
2150*b1cdbd2cSJim Jagielski
2151*b1cdbd2cSJim Jagielski struct lt_SwLineEntry
2152*b1cdbd2cSJim Jagielski {
operator ()lt_SwLineEntry2153*b1cdbd2cSJim Jagielski bool operator()( const SwLineEntry& e1, const SwLineEntry& e2 ) const
2154*b1cdbd2cSJim Jagielski {
2155*b1cdbd2cSJim Jagielski return e1.mnStartPos < e2.mnStartPos;
2156*b1cdbd2cSJim Jagielski }
2157*b1cdbd2cSJim Jagielski };
2158*b1cdbd2cSJim Jagielski
2159*b1cdbd2cSJim Jagielski typedef std::set< SwLineEntry, lt_SwLineEntry > SwLineEntrySet;
2160*b1cdbd2cSJim Jagielski typedef std::set< SwLineEntry, lt_SwLineEntry >::iterator SwLineEntrySetIter;
2161*b1cdbd2cSJim Jagielski typedef std::set< SwLineEntry, lt_SwLineEntry >::const_iterator SwLineEntrySetConstIter;
2162*b1cdbd2cSJim Jagielski typedef std::map< SwTwips, SwLineEntrySet > SwLineEntryMap;
2163*b1cdbd2cSJim Jagielski typedef std::map< SwTwips, SwLineEntrySet >::iterator SwLineEntryMapIter;
2164*b1cdbd2cSJim Jagielski typedef std::map< SwTwips, SwLineEntrySet >::const_iterator SwLineEntryMapConstIter;
2165*b1cdbd2cSJim Jagielski
2166*b1cdbd2cSJim Jagielski class SwTabFrmPainter
2167*b1cdbd2cSJim Jagielski {
2168*b1cdbd2cSJim Jagielski SwLineEntryMap maVertLines;
2169*b1cdbd2cSJim Jagielski SwLineEntryMap maHoriLines;
2170*b1cdbd2cSJim Jagielski const SwTabFrm& mrTabFrm;
2171*b1cdbd2cSJim Jagielski
2172*b1cdbd2cSJim Jagielski void Insert( SwLineEntry&, bool bHori );
2173*b1cdbd2cSJim Jagielski void Insert( const SwFrm& rFrm, const SvxBoxItem& rBoxItem );
2174*b1cdbd2cSJim Jagielski void HandleFrame( const SwLayoutFrm& rFrm );
2175*b1cdbd2cSJim Jagielski void FindStylesForLine( const Point&,
2176*b1cdbd2cSJim Jagielski const Point&,
2177*b1cdbd2cSJim Jagielski svx::frame::Style*,
2178*b1cdbd2cSJim Jagielski bool bHori ) const;
2179*b1cdbd2cSJim Jagielski
2180*b1cdbd2cSJim Jagielski public:
2181*b1cdbd2cSJim Jagielski SwTabFrmPainter( const SwTabFrm& rTabFrm );
2182*b1cdbd2cSJim Jagielski
2183*b1cdbd2cSJim Jagielski void PaintLines( OutputDevice& rDev, const SwRect& rRect ) const;
2184*b1cdbd2cSJim Jagielski };
2185*b1cdbd2cSJim Jagielski
SwTabFrmPainter(const SwTabFrm & rTabFrm)2186*b1cdbd2cSJim Jagielski SwTabFrmPainter::SwTabFrmPainter( const SwTabFrm& rTabFrm )
2187*b1cdbd2cSJim Jagielski : mrTabFrm( rTabFrm )
2188*b1cdbd2cSJim Jagielski {
2189*b1cdbd2cSJim Jagielski HandleFrame( rTabFrm );
2190*b1cdbd2cSJim Jagielski }
2191*b1cdbd2cSJim Jagielski
HandleFrame(const SwLayoutFrm & rLayoutFrm)2192*b1cdbd2cSJim Jagielski void SwTabFrmPainter::HandleFrame( const SwLayoutFrm& rLayoutFrm )
2193*b1cdbd2cSJim Jagielski {
2194*b1cdbd2cSJim Jagielski // Add border lines of cell frames. Skip covered cells. Skip cells
2195*b1cdbd2cSJim Jagielski // in special row span row, which do not have a negative row span:
2196*b1cdbd2cSJim Jagielski if ( rLayoutFrm.IsCellFrm() && !rLayoutFrm.IsCoveredCell() )
2197*b1cdbd2cSJim Jagielski {
2198*b1cdbd2cSJim Jagielski const SwCellFrm* pThisCell = static_cast<const SwCellFrm*>(&rLayoutFrm);
2199*b1cdbd2cSJim Jagielski const SwRowFrm* pRowFrm = static_cast<const SwRowFrm*>(pThisCell->GetUpper());
2200*b1cdbd2cSJim Jagielski const long nRowSpan = pThisCell->GetTabBox()->getRowSpan();
2201*b1cdbd2cSJim Jagielski if ( !pRowFrm->IsRowSpanLine() || nRowSpan > 1 || nRowSpan < -1 )
2202*b1cdbd2cSJim Jagielski {
2203*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), &rLayoutFrm );
2204*b1cdbd2cSJim Jagielski const SwBorderAttrs& rAttrs = *aAccess.Get();
2205*b1cdbd2cSJim Jagielski const SvxBoxItem& rBox = rAttrs.GetBox();
2206*b1cdbd2cSJim Jagielski Insert( rLayoutFrm, rBox );
2207*b1cdbd2cSJim Jagielski }
2208*b1cdbd2cSJim Jagielski }
2209*b1cdbd2cSJim Jagielski
2210*b1cdbd2cSJim Jagielski // Recurse into lower layout frames, but do not recurse into lower tabframes.
2211*b1cdbd2cSJim Jagielski const SwFrm* pLower = rLayoutFrm.Lower();
2212*b1cdbd2cSJim Jagielski while ( pLower )
2213*b1cdbd2cSJim Jagielski {
2214*b1cdbd2cSJim Jagielski const SwLayoutFrm* pLowerLayFrm = dynamic_cast<const SwLayoutFrm*>(pLower);
2215*b1cdbd2cSJim Jagielski if ( pLowerLayFrm && !pLowerLayFrm->IsTabFrm() )
2216*b1cdbd2cSJim Jagielski HandleFrame( *pLowerLayFrm );
2217*b1cdbd2cSJim Jagielski
2218*b1cdbd2cSJim Jagielski pLower = pLower->GetNext();
2219*b1cdbd2cSJim Jagielski }
2220*b1cdbd2cSJim Jagielski }
2221*b1cdbd2cSJim Jagielski
PaintLines(OutputDevice & rDev,const SwRect & rRect) const2222*b1cdbd2cSJim Jagielski void SwTabFrmPainter::PaintLines( OutputDevice& rDev, const SwRect& rRect ) const
2223*b1cdbd2cSJim Jagielski {
2224*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
2225*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, rDev );
2226*b1cdbd2cSJim Jagielski // <--
2227*b1cdbd2cSJim Jagielski
2228*b1cdbd2cSJim Jagielski const SwFrm* pTmpFrm = &mrTabFrm;
2229*b1cdbd2cSJim Jagielski const bool bVert = pTmpFrm->IsVertical();
2230*b1cdbd2cSJim Jagielski
2231*b1cdbd2cSJim Jagielski SwLineEntryMapConstIter aIter = maHoriLines.begin();
2232*b1cdbd2cSJim Jagielski bool bHori = true;
2233*b1cdbd2cSJim Jagielski
2234*b1cdbd2cSJim Jagielski // color for subsidiary lines:
2235*b1cdbd2cSJim Jagielski const Color& rCol( SwViewOption::GetTableBoundariesColor() );
2236*b1cdbd2cSJim Jagielski
2237*b1cdbd2cSJim Jagielski // high contrast mode:
2238*b1cdbd2cSJim Jagielski // overrides the color of non-subsidiary lines.
2239*b1cdbd2cSJim Jagielski const Color* pHCColor = 0;
2240*b1cdbd2cSJim Jagielski sal_uLong nOldDrawMode = rDev.GetDrawMode();
2241*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin() &&
2242*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
2243*b1cdbd2cSJim Jagielski {
2244*b1cdbd2cSJim Jagielski pHCColor = &SwViewOption::GetFontColor();
2245*b1cdbd2cSJim Jagielski rDev.SetDrawMode( 0 );
2246*b1cdbd2cSJim Jagielski }
2247*b1cdbd2cSJim Jagielski
2248*b1cdbd2cSJim Jagielski // set clip region:
2249*b1cdbd2cSJim Jagielski rDev.Push( PUSH_CLIPREGION );
2250*b1cdbd2cSJim Jagielski Size aSize( rRect.SSize() );
2251*b1cdbd2cSJim Jagielski // Hack! Necessary, because the layout is not pixel aligned!
2252*b1cdbd2cSJim Jagielski aSize.Width() += nPixelSzW; aSize.Height() += nPixelSzH;
2253*b1cdbd2cSJim Jagielski rDev.SetClipRegion( Rectangle( rRect.Pos(), aSize ) );
2254*b1cdbd2cSJim Jagielski
2255*b1cdbd2cSJim Jagielski // The following stuff if necessary to have the new table borders fit
2256*b1cdbd2cSJim Jagielski // into a ::SwAlignRect adjusted world.
2257*b1cdbd2cSJim Jagielski const SwTwips nTwipXCorr = bVert ? 0 : Max( 0L, nHalfPixelSzW - 2 ); // 1 < 2 < 3 ;-)
2258*b1cdbd2cSJim Jagielski const SwTwips nTwipYCorr = !bVert ? 0 : Max( 0L, nHalfPixelSzW - 2 ); // 1 < 2 < 3 ;-)
2259*b1cdbd2cSJim Jagielski const SwFrm* pUpper = mrTabFrm.GetUpper();
2260*b1cdbd2cSJim Jagielski SwRect aUpper( pUpper->Prt() );
2261*b1cdbd2cSJim Jagielski aUpper.Pos() += pUpper->Frm().Pos();
2262*b1cdbd2cSJim Jagielski SwRect aUpperAligned( aUpper );
2263*b1cdbd2cSJim Jagielski ::SwAlignRect( aUpperAligned, pGlobalShell );
2264*b1cdbd2cSJim Jagielski
2265*b1cdbd2cSJim Jagielski while ( true )
2266*b1cdbd2cSJim Jagielski {
2267*b1cdbd2cSJim Jagielski if ( bHori && aIter == maHoriLines.end() )
2268*b1cdbd2cSJim Jagielski {
2269*b1cdbd2cSJim Jagielski aIter = maVertLines.begin();
2270*b1cdbd2cSJim Jagielski bHori = false;
2271*b1cdbd2cSJim Jagielski }
2272*b1cdbd2cSJim Jagielski
2273*b1cdbd2cSJim Jagielski if ( !bHori && aIter == maVertLines.end() )
2274*b1cdbd2cSJim Jagielski break;
2275*b1cdbd2cSJim Jagielski
2276*b1cdbd2cSJim Jagielski const SwLineEntrySet& rEntrySet = (*aIter).second;
2277*b1cdbd2cSJim Jagielski SwLineEntrySetConstIter aSetIter = rEntrySet.begin();
2278*b1cdbd2cSJim Jagielski while ( aSetIter != rEntrySet.end() )
2279*b1cdbd2cSJim Jagielski {
2280*b1cdbd2cSJim Jagielski const SwLineEntry& rEntry = *aSetIter;
2281*b1cdbd2cSJim Jagielski const svx::frame::Style& rEntryStyle( (*aSetIter).maAttribute );
2282*b1cdbd2cSJim Jagielski
2283*b1cdbd2cSJim Jagielski Point aStart, aEnd;
2284*b1cdbd2cSJim Jagielski if ( bHori )
2285*b1cdbd2cSJim Jagielski {
2286*b1cdbd2cSJim Jagielski aStart.X() = rEntry.mnStartPos;
2287*b1cdbd2cSJim Jagielski aStart.Y() = rEntry.mnKey;
2288*b1cdbd2cSJim Jagielski aEnd.X() = rEntry.mnEndPos;
2289*b1cdbd2cSJim Jagielski aEnd.Y() = rEntry.mnKey;
2290*b1cdbd2cSJim Jagielski }
2291*b1cdbd2cSJim Jagielski else
2292*b1cdbd2cSJim Jagielski {
2293*b1cdbd2cSJim Jagielski aStart.X() = rEntry.mnKey;
2294*b1cdbd2cSJim Jagielski aStart.Y() = rEntry.mnStartPos;
2295*b1cdbd2cSJim Jagielski aEnd.X() = rEntry.mnKey;
2296*b1cdbd2cSJim Jagielski aEnd.Y() = rEntry.mnEndPos;
2297*b1cdbd2cSJim Jagielski }
2298*b1cdbd2cSJim Jagielski
2299*b1cdbd2cSJim Jagielski SwRect aRepaintRect( aStart, aEnd );
2300*b1cdbd2cSJim Jagielski
2301*b1cdbd2cSJim Jagielski // the repaint rectangle has to be moved a bit for the centered lines:
2302*b1cdbd2cSJim Jagielski SwTwips nRepaintRectSize = !rEntryStyle.GetWidth() ? 1 : rEntryStyle.GetWidth();
2303*b1cdbd2cSJim Jagielski if ( bHori )
2304*b1cdbd2cSJim Jagielski {
2305*b1cdbd2cSJim Jagielski aRepaintRect.Height( 2 * nRepaintRectSize );
2306*b1cdbd2cSJim Jagielski aRepaintRect.Pos().Y() -= nRepaintRectSize;
2307*b1cdbd2cSJim Jagielski }
2308*b1cdbd2cSJim Jagielski else
2309*b1cdbd2cSJim Jagielski {
2310*b1cdbd2cSJim Jagielski aRepaintRect.Width( 2 * nRepaintRectSize );
2311*b1cdbd2cSJim Jagielski aRepaintRect.Pos().X() -= nRepaintRectSize;
2312*b1cdbd2cSJim Jagielski }
2313*b1cdbd2cSJim Jagielski
2314*b1cdbd2cSJim Jagielski if ( rRect.IsOver( aRepaintRect ) )
2315*b1cdbd2cSJim Jagielski {
2316*b1cdbd2cSJim Jagielski svx::frame::Style aStyles[ 7 ];
2317*b1cdbd2cSJim Jagielski aStyles[ 0 ] = rEntryStyle;
2318*b1cdbd2cSJim Jagielski FindStylesForLine( aStart, aEnd, aStyles, bHori );
2319*b1cdbd2cSJim Jagielski
2320*b1cdbd2cSJim Jagielski // subsidiary lines
2321*b1cdbd2cSJim Jagielski const Color* pTmpColor = 0;
2322*b1cdbd2cSJim Jagielski if ( 0 == aStyles[ 0 ].GetWidth() )
2323*b1cdbd2cSJim Jagielski {
2324*b1cdbd2cSJim Jagielski if ( IS_SUBS_TABLE && pGlobalShell->GetWin() )
2325*b1cdbd2cSJim Jagielski aStyles[ 0 ].Set( rCol, 1, 0, 0 );
2326*b1cdbd2cSJim Jagielski }
2327*b1cdbd2cSJim Jagielski else
2328*b1cdbd2cSJim Jagielski pTmpColor = pHCColor;
2329*b1cdbd2cSJim Jagielski
2330*b1cdbd2cSJim Jagielski // The line sizes stored in the line style have to be adjusted as well.
2331*b1cdbd2cSJim Jagielski // This will guarantee that lines with the same twip size will have the
2332*b1cdbd2cSJim Jagielski // same pixel size.
2333*b1cdbd2cSJim Jagielski for ( int i = 0; i < 7; ++i )
2334*b1cdbd2cSJim Jagielski {
2335*b1cdbd2cSJim Jagielski sal_uInt16 nPrim = aStyles[ i ].Prim();
2336*b1cdbd2cSJim Jagielski sal_uInt16 nDist = aStyles[ i ].Dist();
2337*b1cdbd2cSJim Jagielski sal_uInt16 nSecn = aStyles[ i ].Secn();
2338*b1cdbd2cSJim Jagielski
2339*b1cdbd2cSJim Jagielski if ( nPrim > 0 )
2340*b1cdbd2cSJim Jagielski nPrim = (sal_uInt16)( Max( 1L, nPixelSzH * ( nPrim / nPixelSzH ) ) );
2341*b1cdbd2cSJim Jagielski if ( nDist > 0 )
2342*b1cdbd2cSJim Jagielski nDist = (sal_uInt16)( Max( 1L, nPixelSzH * ( nDist / nPixelSzH ) ) );
2343*b1cdbd2cSJim Jagielski if ( nSecn > 0 )
2344*b1cdbd2cSJim Jagielski nSecn = (sal_uInt16)( Max( 1L, nPixelSzH * ( nSecn / nPixelSzH ) ) );
2345*b1cdbd2cSJim Jagielski
2346*b1cdbd2cSJim Jagielski aStyles[ i ].Set( nPrim, nDist, nSecn );
2347*b1cdbd2cSJim Jagielski }
2348*b1cdbd2cSJim Jagielski
2349*b1cdbd2cSJim Jagielski // The (twip) positions will be adjusted to meet these requirements:
2350*b1cdbd2cSJim Jagielski // 1. The y coordinates are located in the middle of the pixel grid
2351*b1cdbd2cSJim Jagielski // 2. The x coordinated are located at the beginning of the pixel grid
2352*b1cdbd2cSJim Jagielski // This is done, because the horizontal lines are painted "at beginning",
2353*b1cdbd2cSJim Jagielski // whereas the vertical lines are painted "centered". By making the line
2354*b1cdbd2cSJim Jagielski // sizes a multiple of one pixel size, we can assure, that all lines having
2355*b1cdbd2cSJim Jagielski // the same twip size have the same pixel size, independent of their position
2356*b1cdbd2cSJim Jagielski // on the screen.
2357*b1cdbd2cSJim Jagielski Point aPaintStart = rDev.PixelToLogic( rDev.LogicToPixel( aStart ) );
2358*b1cdbd2cSJim Jagielski Point aPaintEnd = rDev.PixelToLogic( rDev.LogicToPixel( aEnd ) );
2359*b1cdbd2cSJim Jagielski
2360*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin() )
2361*b1cdbd2cSJim Jagielski {
2362*b1cdbd2cSJim Jagielski // The table borders do not use SwAlignRect, but all the other frames do.
2363*b1cdbd2cSJim Jagielski // Therefore we tweak the outer borders a bit to achieve that the outer
2364*b1cdbd2cSJim Jagielski // borders match the subsidiary lines of the upper:
2365*b1cdbd2cSJim Jagielski if ( aStart.X() == aUpper.Left() )
2366*b1cdbd2cSJim Jagielski aPaintStart.X() = aUpperAligned.Left();
2367*b1cdbd2cSJim Jagielski else if ( aStart.X() == aUpper._Right() )
2368*b1cdbd2cSJim Jagielski aPaintStart.X() = aUpperAligned._Right();
2369*b1cdbd2cSJim Jagielski if ( aStart.Y() == aUpper.Top() )
2370*b1cdbd2cSJim Jagielski aPaintStart.Y() = aUpperAligned.Top();
2371*b1cdbd2cSJim Jagielski else if ( aStart.Y() == aUpper._Bottom() )
2372*b1cdbd2cSJim Jagielski aPaintStart.Y() = aUpperAligned._Bottom();
2373*b1cdbd2cSJim Jagielski
2374*b1cdbd2cSJim Jagielski if ( aEnd.X() == aUpper.Left() )
2375*b1cdbd2cSJim Jagielski aPaintEnd.X() = aUpperAligned.Left();
2376*b1cdbd2cSJim Jagielski else if ( aEnd.X() == aUpper._Right() )
2377*b1cdbd2cSJim Jagielski aPaintEnd.X() = aUpperAligned._Right();
2378*b1cdbd2cSJim Jagielski if ( aEnd.Y() == aUpper.Top() )
2379*b1cdbd2cSJim Jagielski aPaintEnd.Y() = aUpperAligned.Top();
2380*b1cdbd2cSJim Jagielski else if ( aEnd.Y() == aUpper._Bottom() )
2381*b1cdbd2cSJim Jagielski aPaintEnd.Y() = aUpperAligned._Bottom();
2382*b1cdbd2cSJim Jagielski }
2383*b1cdbd2cSJim Jagielski
2384*b1cdbd2cSJim Jagielski aPaintStart.X() -= nTwipXCorr; // nHalfPixelSzW - 2 to assure that we do not leave the pixel
2385*b1cdbd2cSJim Jagielski aPaintEnd.X() -= nTwipXCorr;
2386*b1cdbd2cSJim Jagielski aPaintStart.Y() -= nTwipYCorr;
2387*b1cdbd2cSJim Jagielski aPaintEnd.Y() -= nTwipYCorr;
2388*b1cdbd2cSJim Jagielski
2389*b1cdbd2cSJim Jagielski // Here comes the painting stuff: Thank you, DR, great job!!!
2390*b1cdbd2cSJim Jagielski if ( bHori )
2391*b1cdbd2cSJim Jagielski {
2392*b1cdbd2cSJim Jagielski svx::frame::DrawHorFrameBorder
2393*b1cdbd2cSJim Jagielski (
2394*b1cdbd2cSJim Jagielski rDev,
2395*b1cdbd2cSJim Jagielski aPaintStart,
2396*b1cdbd2cSJim Jagielski aPaintEnd,
2397*b1cdbd2cSJim Jagielski aStyles[ 0 ], // current style
2398*b1cdbd2cSJim Jagielski aStyles[ 1 ], // aLFromT
2399*b1cdbd2cSJim Jagielski aStyles[ 2 ], // aLFromL
2400*b1cdbd2cSJim Jagielski aStyles[ 3 ], // aLFromB
2401*b1cdbd2cSJim Jagielski aStyles[ 4 ], // aRFromT
2402*b1cdbd2cSJim Jagielski aStyles[ 5 ], // aRFromR
2403*b1cdbd2cSJim Jagielski aStyles[ 6 ], // aRFromB
2404*b1cdbd2cSJim Jagielski pTmpColor
2405*b1cdbd2cSJim Jagielski );
2406*b1cdbd2cSJim Jagielski }
2407*b1cdbd2cSJim Jagielski else
2408*b1cdbd2cSJim Jagielski {
2409*b1cdbd2cSJim Jagielski svx::frame::DrawVerFrameBorder
2410*b1cdbd2cSJim Jagielski (
2411*b1cdbd2cSJim Jagielski rDev,
2412*b1cdbd2cSJim Jagielski aPaintStart,
2413*b1cdbd2cSJim Jagielski aPaintEnd,
2414*b1cdbd2cSJim Jagielski aStyles[ 0 ], // current style
2415*b1cdbd2cSJim Jagielski aStyles[ 1 ], // aTFromL
2416*b1cdbd2cSJim Jagielski aStyles[ 2 ], // aTFromT
2417*b1cdbd2cSJim Jagielski aStyles[ 3 ], // aTFromR
2418*b1cdbd2cSJim Jagielski aStyles[ 4 ], // aBFromL
2419*b1cdbd2cSJim Jagielski aStyles[ 5 ], // aBFromB
2420*b1cdbd2cSJim Jagielski aStyles[ 6 ], // aBFromR
2421*b1cdbd2cSJim Jagielski pTmpColor
2422*b1cdbd2cSJim Jagielski );
2423*b1cdbd2cSJim Jagielski }
2424*b1cdbd2cSJim Jagielski }
2425*b1cdbd2cSJim Jagielski
2426*b1cdbd2cSJim Jagielski ++aSetIter;
2427*b1cdbd2cSJim Jagielski }
2428*b1cdbd2cSJim Jagielski
2429*b1cdbd2cSJim Jagielski ++aIter;
2430*b1cdbd2cSJim Jagielski }
2431*b1cdbd2cSJim Jagielski
2432*b1cdbd2cSJim Jagielski // restore output device:
2433*b1cdbd2cSJim Jagielski rDev.Pop();
2434*b1cdbd2cSJim Jagielski rDev.SetDrawMode( nOldDrawMode );
2435*b1cdbd2cSJim Jagielski }
2436*b1cdbd2cSJim Jagielski
2437*b1cdbd2cSJim Jagielski // Finds the lines that join the line defined by (StartPoint, EndPoint) in either
2438*b1cdbd2cSJim Jagielski // StartPoint or Endpoint. The styles of these lines are required for DR's magic
2439*b1cdbd2cSJim Jagielski // line painting functions.
FindStylesForLine(const Point & rStartPoint,const Point & rEndPoint,svx::frame::Style * pStyles,bool bHori) const2440*b1cdbd2cSJim Jagielski void SwTabFrmPainter::FindStylesForLine( const Point& rStartPoint,
2441*b1cdbd2cSJim Jagielski const Point& rEndPoint,
2442*b1cdbd2cSJim Jagielski svx::frame::Style* pStyles,
2443*b1cdbd2cSJim Jagielski bool bHori ) const
2444*b1cdbd2cSJim Jagielski {
2445*b1cdbd2cSJim Jagielski // pStyles[ 1 ] = bHori ? aLFromT : TFromL
2446*b1cdbd2cSJim Jagielski // pStyles[ 2 ] = bHori ? aLFromL : TFromT,
2447*b1cdbd2cSJim Jagielski // pStyles[ 3 ] = bHori ? aLFromB : TFromR,
2448*b1cdbd2cSJim Jagielski // pStyles[ 4 ] = bHori ? aRFromT : BFromL,
2449*b1cdbd2cSJim Jagielski // pStyles[ 5 ] = bHori ? aRFromR : BFromB,
2450*b1cdbd2cSJim Jagielski // pStyles[ 6 ] = bHori ? aRFromB : BFromR,
2451*b1cdbd2cSJim Jagielski
2452*b1cdbd2cSJim Jagielski SwLineEntryMapConstIter aMapIter = maVertLines.find( rStartPoint.X() );
2453*b1cdbd2cSJim Jagielski ASSERT( aMapIter != maVertLines.end(), "FindStylesForLine: Error" )
2454*b1cdbd2cSJim Jagielski const SwLineEntrySet& rVertSet = (*aMapIter).second;
2455*b1cdbd2cSJim Jagielski SwLineEntrySetConstIter aIter = rVertSet.begin();
2456*b1cdbd2cSJim Jagielski
2457*b1cdbd2cSJim Jagielski while ( aIter != rVertSet.end() )
2458*b1cdbd2cSJim Jagielski {
2459*b1cdbd2cSJim Jagielski const SwLineEntry& rEntry = *aIter;
2460*b1cdbd2cSJim Jagielski if ( bHori )
2461*b1cdbd2cSJim Jagielski {
2462*b1cdbd2cSJim Jagielski if ( rStartPoint.Y() == rEntry.mnStartPos )
2463*b1cdbd2cSJim Jagielski pStyles[ 3 ] = rEntry.maAttribute;
2464*b1cdbd2cSJim Jagielski else if ( rStartPoint.Y() == rEntry.mnEndPos )
2465*b1cdbd2cSJim Jagielski pStyles[ 1 ] = rEntry.maAttribute;
2466*b1cdbd2cSJim Jagielski }
2467*b1cdbd2cSJim Jagielski else
2468*b1cdbd2cSJim Jagielski {
2469*b1cdbd2cSJim Jagielski if ( rStartPoint.Y() == rEntry.mnEndPos )
2470*b1cdbd2cSJim Jagielski pStyles[ 2 ] = rEntry.maAttribute;
2471*b1cdbd2cSJim Jagielski else if ( rEndPoint.Y() == rEntry.mnStartPos )
2472*b1cdbd2cSJim Jagielski pStyles[ 5 ] = rEntry.maAttribute;
2473*b1cdbd2cSJim Jagielski }
2474*b1cdbd2cSJim Jagielski ++aIter;
2475*b1cdbd2cSJim Jagielski }
2476*b1cdbd2cSJim Jagielski
2477*b1cdbd2cSJim Jagielski aMapIter = maHoriLines.find( rStartPoint.Y() );
2478*b1cdbd2cSJim Jagielski ASSERT( aMapIter != maHoriLines.end(), "FindStylesForLine: Error" )
2479*b1cdbd2cSJim Jagielski const SwLineEntrySet& rHoriSet = (*aMapIter).second;
2480*b1cdbd2cSJim Jagielski aIter = rHoriSet.begin();
2481*b1cdbd2cSJim Jagielski
2482*b1cdbd2cSJim Jagielski while ( aIter != rHoriSet.end() )
2483*b1cdbd2cSJim Jagielski {
2484*b1cdbd2cSJim Jagielski const SwLineEntry& rEntry = *aIter;
2485*b1cdbd2cSJim Jagielski if ( bHori )
2486*b1cdbd2cSJim Jagielski {
2487*b1cdbd2cSJim Jagielski if ( rStartPoint.X() == rEntry.mnEndPos )
2488*b1cdbd2cSJim Jagielski pStyles[ 2 ] = rEntry.maAttribute;
2489*b1cdbd2cSJim Jagielski else if ( rEndPoint.X() == rEntry.mnStartPos )
2490*b1cdbd2cSJim Jagielski pStyles[ 5 ] = rEntry.maAttribute;
2491*b1cdbd2cSJim Jagielski }
2492*b1cdbd2cSJim Jagielski else
2493*b1cdbd2cSJim Jagielski {
2494*b1cdbd2cSJim Jagielski if ( rStartPoint.X() == rEntry.mnEndPos )
2495*b1cdbd2cSJim Jagielski pStyles[ 1 ] = rEntry.maAttribute;
2496*b1cdbd2cSJim Jagielski else if ( rStartPoint.X() == rEntry.mnStartPos )
2497*b1cdbd2cSJim Jagielski pStyles[ 3 ] = rEntry.maAttribute;
2498*b1cdbd2cSJim Jagielski }
2499*b1cdbd2cSJim Jagielski ++aIter;
2500*b1cdbd2cSJim Jagielski }
2501*b1cdbd2cSJim Jagielski
2502*b1cdbd2cSJim Jagielski if ( bHori )
2503*b1cdbd2cSJim Jagielski {
2504*b1cdbd2cSJim Jagielski aMapIter = maVertLines.find( rEndPoint.X() );
2505*b1cdbd2cSJim Jagielski ASSERT( aMapIter != maVertLines.end(), "FindStylesForLine: Error" )
2506*b1cdbd2cSJim Jagielski const SwLineEntrySet& rVertSet2 = (*aMapIter).second;
2507*b1cdbd2cSJim Jagielski aIter = rVertSet2.begin();
2508*b1cdbd2cSJim Jagielski
2509*b1cdbd2cSJim Jagielski while ( aIter != rVertSet2.end() )
2510*b1cdbd2cSJim Jagielski {
2511*b1cdbd2cSJim Jagielski const SwLineEntry& rEntry = *aIter;
2512*b1cdbd2cSJim Jagielski if ( rEndPoint.Y() == rEntry.mnStartPos )
2513*b1cdbd2cSJim Jagielski pStyles[ 6 ] = rEntry.maAttribute;
2514*b1cdbd2cSJim Jagielski else if ( rEndPoint.Y() == rEntry.mnEndPos )
2515*b1cdbd2cSJim Jagielski pStyles[ 4 ] = rEntry.maAttribute;
2516*b1cdbd2cSJim Jagielski ++aIter;
2517*b1cdbd2cSJim Jagielski }
2518*b1cdbd2cSJim Jagielski }
2519*b1cdbd2cSJim Jagielski else
2520*b1cdbd2cSJim Jagielski {
2521*b1cdbd2cSJim Jagielski aMapIter = maHoriLines.find( rEndPoint.Y() );
2522*b1cdbd2cSJim Jagielski ASSERT( aMapIter != maHoriLines.end(), "FindStylesForLine: Error" )
2523*b1cdbd2cSJim Jagielski const SwLineEntrySet& rHoriSet2 = (*aMapIter).second;
2524*b1cdbd2cSJim Jagielski aIter = rHoriSet2.begin();
2525*b1cdbd2cSJim Jagielski
2526*b1cdbd2cSJim Jagielski while ( aIter != rHoriSet2.end() )
2527*b1cdbd2cSJim Jagielski {
2528*b1cdbd2cSJim Jagielski const SwLineEntry& rEntry = *aIter;
2529*b1cdbd2cSJim Jagielski if ( rEndPoint.X() == rEntry.mnEndPos )
2530*b1cdbd2cSJim Jagielski pStyles[ 4 ] = rEntry.maAttribute;
2531*b1cdbd2cSJim Jagielski else if ( rEndPoint.X() == rEntry.mnStartPos )
2532*b1cdbd2cSJim Jagielski pStyles[ 6 ] = rEntry.maAttribute;
2533*b1cdbd2cSJim Jagielski ++aIter;
2534*b1cdbd2cSJim Jagielski }
2535*b1cdbd2cSJim Jagielski }
2536*b1cdbd2cSJim Jagielski }
2537*b1cdbd2cSJim Jagielski
Insert(const SwFrm & rFrm,const SvxBoxItem & rBoxItem)2538*b1cdbd2cSJim Jagielski void SwTabFrmPainter::Insert( const SwFrm& rFrm, const SvxBoxItem& rBoxItem )
2539*b1cdbd2cSJim Jagielski {
2540*b1cdbd2cSJim Jagielski std::vector< const SwFrm* > aTestVec;
2541*b1cdbd2cSJim Jagielski aTestVec.push_back( &rFrm );
2542*b1cdbd2cSJim Jagielski aTestVec.push_back( &rFrm );
2543*b1cdbd2cSJim Jagielski aTestVec.push_back( &rFrm );
2544*b1cdbd2cSJim Jagielski
2545*b1cdbd2cSJim Jagielski // build 4 line entries for the 4 borders:
2546*b1cdbd2cSJim Jagielski SwRect aBorderRect = rFrm.Frm();
2547*b1cdbd2cSJim Jagielski if ( rFrm.IsTabFrm() )
2548*b1cdbd2cSJim Jagielski {
2549*b1cdbd2cSJim Jagielski aBorderRect = rFrm.Prt();
2550*b1cdbd2cSJim Jagielski aBorderRect.Pos() += rFrm.Frm().Pos();
2551*b1cdbd2cSJim Jagielski }
2552*b1cdbd2cSJim Jagielski
2553*b1cdbd2cSJim Jagielski const SwTwips nLeft = aBorderRect._Left();
2554*b1cdbd2cSJim Jagielski const SwTwips nRight = aBorderRect._Right();
2555*b1cdbd2cSJim Jagielski const SwTwips nTop = aBorderRect._Top();
2556*b1cdbd2cSJim Jagielski const SwTwips nBottom = aBorderRect._Bottom();
2557*b1cdbd2cSJim Jagielski
2558*b1cdbd2cSJim Jagielski svx::frame::Style aL( rBoxItem.GetLeft() );
2559*b1cdbd2cSJim Jagielski svx::frame::Style aR( rBoxItem.GetRight() );
2560*b1cdbd2cSJim Jagielski svx::frame::Style aT( rBoxItem.GetTop() );
2561*b1cdbd2cSJim Jagielski svx::frame::Style aB( rBoxItem.GetBottom() );
2562*b1cdbd2cSJim Jagielski
2563*b1cdbd2cSJim Jagielski aR.MirrorSelf();
2564*b1cdbd2cSJim Jagielski aB.MirrorSelf();
2565*b1cdbd2cSJim Jagielski
2566*b1cdbd2cSJim Jagielski bool bVert = mrTabFrm.IsVertical();
2567*b1cdbd2cSJim Jagielski bool bR2L = mrTabFrm.IsRightToLeft();
2568*b1cdbd2cSJim Jagielski
2569*b1cdbd2cSJim Jagielski aL.SetRefMode( svx::frame::REFMODE_CENTERED );
2570*b1cdbd2cSJim Jagielski aR.SetRefMode( svx::frame::REFMODE_CENTERED );
2571*b1cdbd2cSJim Jagielski aT.SetRefMode( !bVert ? svx::frame::REFMODE_BEGIN : svx::frame::REFMODE_END );
2572*b1cdbd2cSJim Jagielski aB.SetRefMode( !bVert ? svx::frame::REFMODE_BEGIN : svx::frame::REFMODE_END );
2573*b1cdbd2cSJim Jagielski
2574*b1cdbd2cSJim Jagielski SwLineEntry aLeft ( nLeft, nTop, nBottom, bVert ? aB : ( bR2L ? aR : aL ) );
2575*b1cdbd2cSJim Jagielski SwLineEntry aRight ( nRight, nTop, nBottom, bVert ? aT : ( bR2L ? aL : aR ) );
2576*b1cdbd2cSJim Jagielski SwLineEntry aTop ( nTop, nLeft, nRight, bVert ? aL : aT );
2577*b1cdbd2cSJim Jagielski SwLineEntry aBottom( nBottom, nLeft, nRight, bVert ? aR : aB );
2578*b1cdbd2cSJim Jagielski
2579*b1cdbd2cSJim Jagielski Insert( aLeft, false );
2580*b1cdbd2cSJim Jagielski Insert( aRight, false );
2581*b1cdbd2cSJim Jagielski Insert( aTop, true );
2582*b1cdbd2cSJim Jagielski Insert( aBottom, true );
2583*b1cdbd2cSJim Jagielski
2584*b1cdbd2cSJim Jagielski const SwRowFrm* pThisRowFrm = dynamic_cast<const SwRowFrm*>(rFrm.GetUpper());
2585*b1cdbd2cSJim Jagielski
2586*b1cdbd2cSJim Jagielski // special case: #i9860#
2587*b1cdbd2cSJim Jagielski // first line in follow table without repeated headlines
2588*b1cdbd2cSJim Jagielski if ( pThisRowFrm &&
2589*b1cdbd2cSJim Jagielski pThisRowFrm->GetUpper() == &mrTabFrm &&
2590*b1cdbd2cSJim Jagielski mrTabFrm.IsFollow() &&
2591*b1cdbd2cSJim Jagielski !mrTabFrm.GetTable()->GetRowsToRepeat() &&
2592*b1cdbd2cSJim Jagielski (!pThisRowFrm->GetPrev() || static_cast<const SwRowFrm*>(pThisRowFrm->GetPrev())->IsRowSpanLine()) &&
2593*b1cdbd2cSJim Jagielski !rBoxItem.GetTop() &&
2594*b1cdbd2cSJim Jagielski rBoxItem.GetBottom() )
2595*b1cdbd2cSJim Jagielski {
2596*b1cdbd2cSJim Jagielski SwLineEntry aFollowTop( !bVert ? nTop : nRight, !bVert ? nLeft : nTop, !bVert ? nRight : nBottom, aB );
2597*b1cdbd2cSJim Jagielski Insert( aFollowTop, !bVert );
2598*b1cdbd2cSJim Jagielski }
2599*b1cdbd2cSJim Jagielski }
2600*b1cdbd2cSJim Jagielski
Insert(SwLineEntry & rNew,bool bHori)2601*b1cdbd2cSJim Jagielski void SwTabFrmPainter::Insert( SwLineEntry& rNew, bool bHori )
2602*b1cdbd2cSJim Jagielski {
2603*b1cdbd2cSJim Jagielski // get all lines from structure, that have key entry of pLE
2604*b1cdbd2cSJim Jagielski SwLineEntryMap* pLine2 = bHori ? &maHoriLines : &maVertLines;
2605*b1cdbd2cSJim Jagielski const SwTwips nKey = rNew.mnKey;
2606*b1cdbd2cSJim Jagielski SwLineEntryMapIter aMapIter = pLine2->find( nKey );
2607*b1cdbd2cSJim Jagielski
2608*b1cdbd2cSJim Jagielski SwLineEntrySet* pLineSet = aMapIter != pLine2->end() ? &((*aMapIter).second) : 0;
2609*b1cdbd2cSJim Jagielski if ( !pLineSet )
2610*b1cdbd2cSJim Jagielski {
2611*b1cdbd2cSJim Jagielski SwLineEntrySet aNewSet;
2612*b1cdbd2cSJim Jagielski (*pLine2)[ nKey ] = aNewSet;
2613*b1cdbd2cSJim Jagielski pLineSet = &(*pLine2)[ nKey ];
2614*b1cdbd2cSJim Jagielski }
2615*b1cdbd2cSJim Jagielski SwLineEntrySetIter aIter = pLineSet->begin();
2616*b1cdbd2cSJim Jagielski
2617*b1cdbd2cSJim Jagielski while ( pLineSet && aIter != pLineSet->end() && rNew.mnStartPos < rNew.mnEndPos )
2618*b1cdbd2cSJim Jagielski {
2619*b1cdbd2cSJim Jagielski const SwLineEntry& rOld = *aIter;
2620*b1cdbd2cSJim Jagielski const SwLineEntry::OverlapType nOverlapType = rOld.Overlaps( rNew );
2621*b1cdbd2cSJim Jagielski
2622*b1cdbd2cSJim Jagielski const svx::frame::Style& rOldAttr = rOld.maAttribute;
2623*b1cdbd2cSJim Jagielski const svx::frame::Style& rNewAttr = rNew.maAttribute;
2624*b1cdbd2cSJim Jagielski const svx::frame::Style& rCmpAttr = rNewAttr > rOldAttr ? rNewAttr : rOldAttr;
2625*b1cdbd2cSJim Jagielski
2626*b1cdbd2cSJim Jagielski if ( SwLineEntry::OVERLAP1 == nOverlapType )
2627*b1cdbd2cSJim Jagielski {
2628*b1cdbd2cSJim Jagielski ASSERT( rNew.mnStartPos >= rOld.mnStartPos, "Overlap type 3? How this?" )
2629*b1cdbd2cSJim Jagielski
2630*b1cdbd2cSJim Jagielski // new left segment
2631*b1cdbd2cSJim Jagielski const SwLineEntry aLeft( nKey, rOld.mnStartPos, rNew.mnStartPos, rOldAttr );
2632*b1cdbd2cSJim Jagielski
2633*b1cdbd2cSJim Jagielski // new middle segment
2634*b1cdbd2cSJim Jagielski const SwLineEntry aMiddle( nKey, rNew.mnStartPos, rOld.mnEndPos, rCmpAttr );
2635*b1cdbd2cSJim Jagielski
2636*b1cdbd2cSJim Jagielski // new right segment
2637*b1cdbd2cSJim Jagielski rNew.mnStartPos = rOld.mnEndPos;
2638*b1cdbd2cSJim Jagielski
2639*b1cdbd2cSJim Jagielski // update current lines set
2640*b1cdbd2cSJim Jagielski pLineSet->erase( aIter );
2641*b1cdbd2cSJim Jagielski if ( aLeft.mnStartPos < aLeft.mnEndPos ) pLineSet->insert( aLeft );
2642*b1cdbd2cSJim Jagielski if ( aMiddle.mnStartPos < aMiddle.mnEndPos ) pLineSet->insert( aMiddle );
2643*b1cdbd2cSJim Jagielski
2644*b1cdbd2cSJim Jagielski aIter = pLineSet->begin();
2645*b1cdbd2cSJim Jagielski
2646*b1cdbd2cSJim Jagielski continue; // start over
2647*b1cdbd2cSJim Jagielski }
2648*b1cdbd2cSJim Jagielski else if ( SwLineEntry::OVERLAP2 == nOverlapType )
2649*b1cdbd2cSJim Jagielski {
2650*b1cdbd2cSJim Jagielski // new left segment
2651*b1cdbd2cSJim Jagielski const SwLineEntry aLeft( nKey, rOld.mnStartPos, rNew.mnStartPos, rOldAttr );
2652*b1cdbd2cSJim Jagielski
2653*b1cdbd2cSJim Jagielski // new middle segment
2654*b1cdbd2cSJim Jagielski const SwLineEntry aMiddle( nKey, rNew.mnStartPos, rNew.mnEndPos, rCmpAttr );
2655*b1cdbd2cSJim Jagielski
2656*b1cdbd2cSJim Jagielski // new right segment
2657*b1cdbd2cSJim Jagielski const SwLineEntry aRight( nKey, rNew.mnEndPos, rOld.mnEndPos, rOldAttr );
2658*b1cdbd2cSJim Jagielski
2659*b1cdbd2cSJim Jagielski // update current lines set
2660*b1cdbd2cSJim Jagielski pLineSet->erase( aIter );
2661*b1cdbd2cSJim Jagielski if ( aLeft.mnStartPos < aLeft.mnEndPos ) pLineSet->insert( aLeft );
2662*b1cdbd2cSJim Jagielski if ( aMiddle.mnStartPos < aMiddle.mnEndPos ) pLineSet->insert( aMiddle );
2663*b1cdbd2cSJim Jagielski if ( aRight.mnStartPos < aRight.mnEndPos ) pLineSet->insert( aRight );
2664*b1cdbd2cSJim Jagielski
2665*b1cdbd2cSJim Jagielski rNew.mnStartPos = rNew.mnEndPos; // rNew should not be inserted!
2666*b1cdbd2cSJim Jagielski
2667*b1cdbd2cSJim Jagielski break; // we are finished
2668*b1cdbd2cSJim Jagielski }
2669*b1cdbd2cSJim Jagielski else if ( SwLineEntry::OVERLAP3 == nOverlapType )
2670*b1cdbd2cSJim Jagielski {
2671*b1cdbd2cSJim Jagielski // new left segment
2672*b1cdbd2cSJim Jagielski const SwLineEntry aLeft( nKey, rNew.mnStartPos, rOld.mnStartPos, rNewAttr );
2673*b1cdbd2cSJim Jagielski
2674*b1cdbd2cSJim Jagielski // new middle segment
2675*b1cdbd2cSJim Jagielski const SwLineEntry aMiddle( nKey, rOld.mnStartPos, rNew.mnEndPos, rCmpAttr );
2676*b1cdbd2cSJim Jagielski
2677*b1cdbd2cSJim Jagielski // new right segment
2678*b1cdbd2cSJim Jagielski const SwLineEntry aRight( nKey, rNew.mnEndPos, rOld.mnEndPos, rOldAttr );
2679*b1cdbd2cSJim Jagielski
2680*b1cdbd2cSJim Jagielski // update current lines set
2681*b1cdbd2cSJim Jagielski pLineSet->erase( aIter );
2682*b1cdbd2cSJim Jagielski if ( aLeft.mnStartPos < aLeft.mnEndPos ) pLineSet->insert( aLeft );
2683*b1cdbd2cSJim Jagielski if ( aMiddle.mnStartPos < aMiddle.mnEndPos ) pLineSet->insert( aMiddle );
2684*b1cdbd2cSJim Jagielski if ( aRight.mnStartPos < aRight.mnEndPos ) pLineSet->insert( aRight );
2685*b1cdbd2cSJim Jagielski
2686*b1cdbd2cSJim Jagielski rNew.mnStartPos = rNew.mnEndPos; // rNew should not be inserted!
2687*b1cdbd2cSJim Jagielski
2688*b1cdbd2cSJim Jagielski break; // we are finished
2689*b1cdbd2cSJim Jagielski }
2690*b1cdbd2cSJim Jagielski
2691*b1cdbd2cSJim Jagielski ++aIter;
2692*b1cdbd2cSJim Jagielski }
2693*b1cdbd2cSJim Jagielski
2694*b1cdbd2cSJim Jagielski if ( rNew.mnStartPos < rNew.mnEndPos ) // insert rest
2695*b1cdbd2cSJim Jagielski pLineSet->insert( rNew );
2696*b1cdbd2cSJim Jagielski }
2697*b1cdbd2cSJim Jagielski
2698*b1cdbd2cSJim Jagielski //
2699*b1cdbd2cSJim Jagielski // FUNCTIONS USED FOR COLLAPSING TABLE BORDER LINES END
2700*b1cdbd2cSJim Jagielski //
2701*b1cdbd2cSJim Jagielski
2702*b1cdbd2cSJim Jagielski // --> OD #i76669#
2703*b1cdbd2cSJim Jagielski namespace
2704*b1cdbd2cSJim Jagielski {
2705*b1cdbd2cSJim Jagielski class SwViewObjectContactRedirector : public ::sdr::contact::ViewObjectContactRedirector
2706*b1cdbd2cSJim Jagielski {
2707*b1cdbd2cSJim Jagielski private:
2708*b1cdbd2cSJim Jagielski const ViewShell& mrViewShell;
2709*b1cdbd2cSJim Jagielski
2710*b1cdbd2cSJim Jagielski public:
SwViewObjectContactRedirector(const ViewShell & rSh)2711*b1cdbd2cSJim Jagielski SwViewObjectContactRedirector( const ViewShell& rSh )
2712*b1cdbd2cSJim Jagielski : mrViewShell( rSh )
2713*b1cdbd2cSJim Jagielski {};
2714*b1cdbd2cSJim Jagielski
~SwViewObjectContactRedirector()2715*b1cdbd2cSJim Jagielski virtual ~SwViewObjectContactRedirector()
2716*b1cdbd2cSJim Jagielski {}
2717*b1cdbd2cSJim Jagielski
createRedirectedPrimitive2DSequence(const sdr::contact::ViewObjectContact & rOriginal,const sdr::contact::DisplayInfo & rDisplayInfo)2718*b1cdbd2cSJim Jagielski virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
2719*b1cdbd2cSJim Jagielski const sdr::contact::ViewObjectContact& rOriginal,
2720*b1cdbd2cSJim Jagielski const sdr::contact::DisplayInfo& rDisplayInfo)
2721*b1cdbd2cSJim Jagielski {
2722*b1cdbd2cSJim Jagielski sal_Bool bPaint( sal_True );
2723*b1cdbd2cSJim Jagielski
2724*b1cdbd2cSJim Jagielski SdrObject* pObj = rOriginal.GetViewContact().TryToGetSdrObject();
2725*b1cdbd2cSJim Jagielski if ( pObj )
2726*b1cdbd2cSJim Jagielski {
2727*b1cdbd2cSJim Jagielski bPaint = SwFlyFrm::IsPaint( pObj, &mrViewShell );
2728*b1cdbd2cSJim Jagielski }
2729*b1cdbd2cSJim Jagielski
2730*b1cdbd2cSJim Jagielski if ( !bPaint )
2731*b1cdbd2cSJim Jagielski {
2732*b1cdbd2cSJim Jagielski return drawinglayer::primitive2d::Primitive2DSequence();
2733*b1cdbd2cSJim Jagielski }
2734*b1cdbd2cSJim Jagielski
2735*b1cdbd2cSJim Jagielski return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(
2736*b1cdbd2cSJim Jagielski rOriginal, rDisplayInfo );
2737*b1cdbd2cSJim Jagielski }
2738*b1cdbd2cSJim Jagielski };
2739*b1cdbd2cSJim Jagielski
2740*b1cdbd2cSJim Jagielski } // end of anonymous namespace
2741*b1cdbd2cSJim Jagielski // <--
2742*b1cdbd2cSJim Jagielski
2743*b1cdbd2cSJim Jagielski /*************************************************************************
2744*b1cdbd2cSJim Jagielski |*
2745*b1cdbd2cSJim Jagielski |* SwRootFrm::Paint()
2746*b1cdbd2cSJim Jagielski |*
2747*b1cdbd2cSJim Jagielski |* Beschreibung
2748*b1cdbd2cSJim Jagielski |* Fuer jede sichtbare Seite, die von Rect ber?hrt wird einmal Painten.
2749*b1cdbd2cSJim Jagielski |* 1. Umrandungen und Hintergruende Painten.
2750*b1cdbd2cSJim Jagielski |* 2. Den Draw Layer (Ramen und Zeichenobjekte) der unter dem Dokument
2751*b1cdbd2cSJim Jagielski |* liegt painten (Hoelle).
2752*b1cdbd2cSJim Jagielski |* 3. Den Dokumentinhalt (Text) Painten.
2753*b1cdbd2cSJim Jagielski |* 4. Den Drawlayer der ueber dem Dokuemnt liegt painten.
2754*b1cdbd2cSJim Jagielski |*
2755*b1cdbd2cSJim Jagielski |* Ersterstellung MA 01. Jun. 92
2756*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 10. Oct. 97
2757*b1cdbd2cSJim Jagielski |*
2758*b1cdbd2cSJim Jagielski |*************************************************************************/
2759*b1cdbd2cSJim Jagielski
2760*b1cdbd2cSJim Jagielski void
Paint(SwRect const & rRect,SwPrintData const * const pPrintData) const2761*b1cdbd2cSJim Jagielski SwRootFrm::Paint(SwRect const& rRect, SwPrintData const*const pPrintData) const
2762*b1cdbd2cSJim Jagielski {
2763*b1cdbd2cSJim Jagielski ASSERT( Lower() && Lower()->IsPageFrm(), "Lower der Root keine Seite." );
2764*b1cdbd2cSJim Jagielski
2765*b1cdbd2cSJim Jagielski PROTOCOL( this, PROT_FILE_INIT, 0, 0)
2766*b1cdbd2cSJim Jagielski
2767*b1cdbd2cSJim Jagielski sal_Bool bResetRootPaint = sal_False;
2768*b1cdbd2cSJim Jagielski ViewShell *pSh = pCurrShell;
2769*b1cdbd2cSJim Jagielski
2770*b1cdbd2cSJim Jagielski if ( pSh->GetWin() )
2771*b1cdbd2cSJim Jagielski {
2772*b1cdbd2cSJim Jagielski if ( pSh->GetOut() == pSh->GetWin() && !pSh->GetWin()->IsVisible() )
2773*b1cdbd2cSJim Jagielski {
2774*b1cdbd2cSJim Jagielski return;
2775*b1cdbd2cSJim Jagielski }
2776*b1cdbd2cSJim Jagielski if ( SwRootFrm::bInPaint )
2777*b1cdbd2cSJim Jagielski {
2778*b1cdbd2cSJim Jagielski SwPaintQueue::Add( pSh, rRect );
2779*b1cdbd2cSJim Jagielski return;
2780*b1cdbd2cSJim Jagielski }
2781*b1cdbd2cSJim Jagielski }
2782*b1cdbd2cSJim Jagielski else
2783*b1cdbd2cSJim Jagielski SwRootFrm::bInPaint = bResetRootPaint = sal_True;
2784*b1cdbd2cSJim Jagielski
2785*b1cdbd2cSJim Jagielski SwSavePaintStatics *pStatics = 0;
2786*b1cdbd2cSJim Jagielski if ( pGlobalShell )
2787*b1cdbd2cSJim Jagielski pStatics = new SwSavePaintStatics();
2788*b1cdbd2cSJim Jagielski pGlobalShell = pSh;
2789*b1cdbd2cSJim Jagielski
2790*b1cdbd2cSJim Jagielski if( !pSh->GetWin() )
2791*b1cdbd2cSJim Jagielski pProgress = SfxProgress::GetActiveProgress( (SfxObjectShell*) pSh->GetDoc()->GetDocShell() );
2792*b1cdbd2cSJim Jagielski
2793*b1cdbd2cSJim Jagielski ::SwCalcPixStatics( pSh->GetOut() );
2794*b1cdbd2cSJim Jagielski aGlobalRetoucheColor = pSh->Imp()->GetRetoucheColor();
2795*b1cdbd2cSJim Jagielski
2796*b1cdbd2cSJim Jagielski //Ggf. eine Action ausloesen um klare Verhaeltnisse zu schaffen.
2797*b1cdbd2cSJim Jagielski //Durch diesen Kunstgriff kann in allen Paints davon ausgegangen werden,
2798*b1cdbd2cSJim Jagielski //das alle Werte gueltigt sind - keine Probleme, keine Sonderbehandlung(en).
2799*b1cdbd2cSJim Jagielski // --> OD 2008-10-07 #i92745#
2800*b1cdbd2cSJim Jagielski // Extend check on certain states of the 'current' <ViewShell> instance to
2801*b1cdbd2cSJim Jagielski // all existing <ViewShell> instances.
2802*b1cdbd2cSJim Jagielski bool bPerformLayoutAction( true );
2803*b1cdbd2cSJim Jagielski {
2804*b1cdbd2cSJim Jagielski ViewShell* pTmpViewShell = pSh;
2805*b1cdbd2cSJim Jagielski do {
2806*b1cdbd2cSJim Jagielski if ( pTmpViewShell->IsInEndAction() ||
2807*b1cdbd2cSJim Jagielski pTmpViewShell->IsPaintInProgress() ||
2808*b1cdbd2cSJim Jagielski ( pTmpViewShell->Imp()->IsAction() &&
2809*b1cdbd2cSJim Jagielski pTmpViewShell->Imp()->GetLayAction().IsActionInProgress() ) )
2810*b1cdbd2cSJim Jagielski {
2811*b1cdbd2cSJim Jagielski bPerformLayoutAction = false;
2812*b1cdbd2cSJim Jagielski }
2813*b1cdbd2cSJim Jagielski
2814*b1cdbd2cSJim Jagielski pTmpViewShell = static_cast<ViewShell*>(pTmpViewShell->GetNext());
2815*b1cdbd2cSJim Jagielski } while ( bPerformLayoutAction && pTmpViewShell != pSh );
2816*b1cdbd2cSJim Jagielski }
2817*b1cdbd2cSJim Jagielski if ( bPerformLayoutAction )
2818*b1cdbd2cSJim Jagielski // <--
2819*b1cdbd2cSJim Jagielski {
2820*b1cdbd2cSJim Jagielski ((SwRootFrm*)this)->ResetTurbo();
2821*b1cdbd2cSJim Jagielski SwLayAction aAction( (SwRootFrm*)this, pSh->Imp() );
2822*b1cdbd2cSJim Jagielski aAction.SetPaint( sal_False );
2823*b1cdbd2cSJim Jagielski aAction.SetComplete( sal_False );
2824*b1cdbd2cSJim Jagielski aAction.SetReschedule( pProgress ? sal_True : sal_False );
2825*b1cdbd2cSJim Jagielski aAction.Action();
2826*b1cdbd2cSJim Jagielski ((SwRootFrm*)this)->ResetTurboFlag();
2827*b1cdbd2cSJim Jagielski if ( !pSh->ActionPend() )
2828*b1cdbd2cSJim Jagielski pSh->Imp()->DelRegion();
2829*b1cdbd2cSJim Jagielski }
2830*b1cdbd2cSJim Jagielski
2831*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
2832*b1cdbd2cSJim Jagielski aRect.Intersection( pSh->VisArea() );
2833*b1cdbd2cSJim Jagielski
2834*b1cdbd2cSJim Jagielski const sal_Bool bExtraData = ::IsExtraData( GetFmt()->GetDoc() );
2835*b1cdbd2cSJim Jagielski
2836*b1cdbd2cSJim Jagielski pLines = new SwLineRects; //Sammler fuer Umrandungen.
2837*b1cdbd2cSJim Jagielski
2838*b1cdbd2cSJim Jagielski // #104289#. During painting, something (OLE) can
2839*b1cdbd2cSJim Jagielski // load the linguistic, which in turn can cause a reformat
2840*b1cdbd2cSJim Jagielski // of the document. Dangerous! We better set this flag to
2841*b1cdbd2cSJim Jagielski // avoid the reformat.
2842*b1cdbd2cSJim Jagielski const sal_Bool bOldAction = IsCallbackActionEnabled();
2843*b1cdbd2cSJim Jagielski ((SwRootFrm*)this)->SetCallbackActionEnabled( sal_False );
2844*b1cdbd2cSJim Jagielski
2845*b1cdbd2cSJim Jagielski const SwPageFrm *pPage = pSh->Imp()->GetFirstVisPage();
2846*b1cdbd2cSJim Jagielski
2847*b1cdbd2cSJim Jagielski const bool bBookMode = pGlobalShell->GetViewOptions()->IsViewLayoutBookMode();
2848*b1cdbd2cSJim Jagielski if ( bBookMode && pPage->GetPrev() && static_cast<const SwPageFrm*>(pPage->GetPrev())->IsEmptyPage() )
2849*b1cdbd2cSJim Jagielski pPage = static_cast<const SwPageFrm*>(pPage->GetPrev());
2850*b1cdbd2cSJim Jagielski
2851*b1cdbd2cSJim Jagielski const bool bLTR = IsLeftToRightViewLayout();
2852*b1cdbd2cSJim Jagielski
2853*b1cdbd2cSJim Jagielski // #i68597#
2854*b1cdbd2cSJim Jagielski const bool bGridPainting(pSh->GetWin() && pSh->Imp()->HasDrawView() && pSh->Imp()->GetDrawView()->IsGridVisible());
2855*b1cdbd2cSJim Jagielski
2856*b1cdbd2cSJim Jagielski // --> OD #i76669#
2857*b1cdbd2cSJim Jagielski SwViewObjectContactRedirector aSwRedirector( *pSh );
2858*b1cdbd2cSJim Jagielski // <--
2859*b1cdbd2cSJim Jagielski
2860*b1cdbd2cSJim Jagielski while ( pPage )
2861*b1cdbd2cSJim Jagielski {
2862*b1cdbd2cSJim Jagielski const bool bPaintRightShadow = !bBookMode || (pPage == Lower()) || (!bLTR && !pPage->OnRightPage()) || (bLTR && pPage->OnRightPage());
2863*b1cdbd2cSJim Jagielski const bool bRightSidebar = pPage->SidebarPosition() == sw::sidebarwindows::SIDEBAR_RIGHT;
2864*b1cdbd2cSJim Jagielski
2865*b1cdbd2cSJim Jagielski if ( !pPage->IsEmptyPage() )
2866*b1cdbd2cSJim Jagielski {
2867*b1cdbd2cSJim Jagielski SwRect aPaintRect;
2868*b1cdbd2cSJim Jagielski SwPageFrm::GetBorderAndShadowBoundRect( pPage->Frm(), pSh, aPaintRect, bRightSidebar );
2869*b1cdbd2cSJim Jagielski
2870*b1cdbd2cSJim Jagielski if ( aRect.IsOver( aPaintRect ) )
2871*b1cdbd2cSJim Jagielski {
2872*b1cdbd2cSJim Jagielski if ( pSh->GetWin() )
2873*b1cdbd2cSJim Jagielski {
2874*b1cdbd2cSJim Jagielski pSubsLines = new SwSubsRects;
2875*b1cdbd2cSJim Jagielski pSpecSubsLines = new SwSubsRects;
2876*b1cdbd2cSJim Jagielski }
2877*b1cdbd2cSJim Jagielski
2878*b1cdbd2cSJim Jagielski aPaintRect._Intersection( aRect );
2879*b1cdbd2cSJim Jagielski
2880*b1cdbd2cSJim Jagielski // --> OD 2007-11-14 #i82616#
2881*b1cdbd2cSJim Jagielski // Invalidate area for extra data (line numbers or change tracking
2882*b1cdbd2cSJim Jagielski // marks), if painting on a window and the paint is trigger by an
2883*b1cdbd2cSJim Jagielski // end action. The inefficient and simple enlargement of the
2884*b1cdbd2cSJim Jagielski // paint area is replaced by this invalidation.
2885*b1cdbd2cSJim Jagielski if ( bExtraData &&
2886*b1cdbd2cSJim Jagielski pSh->GetWin() && pSh->IsInEndAction() )
2887*b1cdbd2cSJim Jagielski {
2888*b1cdbd2cSJim Jagielski // enlarge paint rectangle to complete page width, subtract
2889*b1cdbd2cSJim Jagielski // current paint area and invalidate the resulting region.
2890*b1cdbd2cSJim Jagielski SWRECTFN( pPage )
2891*b1cdbd2cSJim Jagielski SwRect aPageRectTemp( aPaintRect );
2892*b1cdbd2cSJim Jagielski (aPageRectTemp.*fnRect->fnSetLeftAndWidth)(
2893*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetLeft)(),
2894*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetWidth)() );
2895*b1cdbd2cSJim Jagielski aPageRectTemp._Intersection( pSh->VisArea() );
2896*b1cdbd2cSJim Jagielski Region aPageRectRegion( aPageRectTemp.SVRect() );
2897*b1cdbd2cSJim Jagielski aPageRectRegion.Exclude( aPaintRect.SVRect() );
2898*b1cdbd2cSJim Jagielski pSh->GetWin()->Invalidate( aPageRectRegion, INVALIDATE_CHILDREN );
2899*b1cdbd2cSJim Jagielski }
2900*b1cdbd2cSJim Jagielski // <--
2901*b1cdbd2cSJim Jagielski
2902*b1cdbd2cSJim Jagielski // --> OD 2007-08-20 #i80793#
2903*b1cdbd2cSJim Jagielski // enlarge paint rectangle for objects overlapping the same pixel
2904*b1cdbd2cSJim Jagielski // in all cases and before the DrawingLayer overlay is initialized.
2905*b1cdbd2cSJim Jagielski lcl_AdjustRectToPixelSize( aPaintRect, *(pSh->GetOut()) );
2906*b1cdbd2cSJim Jagielski // <--
2907*b1cdbd2cSJim Jagielski
2908*b1cdbd2cSJim Jagielski // #i68597#
2909*b1cdbd2cSJim Jagielski // moved paint pre-process for DrawingLayer overlay here since the above
2910*b1cdbd2cSJim Jagielski // code dependent from bExtraData may expand the PaintRect
2911*b1cdbd2cSJim Jagielski {
2912*b1cdbd2cSJim Jagielski // #i75172# if called from ViewShell::ImplEndAction it sould no longer
2913*b1cdbd2cSJim Jagielski // really be used but handled by ViewShell::ImplEndAction already
2914*b1cdbd2cSJim Jagielski const Region aDLRegion(aPaintRect.SVRect());
2915*b1cdbd2cSJim Jagielski pSh->DLPrePaint2(aDLRegion);
2916*b1cdbd2cSJim Jagielski }
2917*b1cdbd2cSJim Jagielski
2918*b1cdbd2cSJim Jagielski if(OUTDEV_WINDOW == pGlobalShell->GetOut()->GetOutDevType())
2919*b1cdbd2cSJim Jagielski {
2920*b1cdbd2cSJim Jagielski /// OD 27.09.2002 #103636# - changed method SwLayVout::Enter(..)
2921*b1cdbd2cSJim Jagielski /// 2nd parameter is no longer <const> and will be set to the
2922*b1cdbd2cSJim Jagielski /// rectangle the virtual output device is calculated from <aPaintRect>,
2923*b1cdbd2cSJim Jagielski /// if the virtual output is used.
2924*b1cdbd2cSJim Jagielski pVout->Enter( pSh, aPaintRect, !bNoVirDev );
2925*b1cdbd2cSJim Jagielski
2926*b1cdbd2cSJim Jagielski /// OD 27.09.2002 #103636# - adjust paint rectangle to pixel size
2927*b1cdbd2cSJim Jagielski /// Thus, all objects overlapping on pixel level with the unadjusted
2928*b1cdbd2cSJim Jagielski /// paint rectangle will be considered in the paint.
2929*b1cdbd2cSJim Jagielski lcl_AdjustRectToPixelSize( aPaintRect, *(pSh->GetOut()) );
2930*b1cdbd2cSJim Jagielski }
2931*b1cdbd2cSJim Jagielski
2932*b1cdbd2cSJim Jagielski // maybe this can be put in the above scope. Since we are not sure, just leave it ATM
2933*b1cdbd2cSJim Jagielski pVout->SetOrgRect( aPaintRect );
2934*b1cdbd2cSJim Jagielski
2935*b1cdbd2cSJim Jagielski /// OD 29.08.2002 #102450#
2936*b1cdbd2cSJim Jagielski /// determine background color of page for <PaintLayer> method
2937*b1cdbd2cSJim Jagielski /// calls, paint <hell> or <heaven>
2938*b1cdbd2cSJim Jagielski const Color aPageBackgrdColor = pPage->GetDrawBackgrdColor();
2939*b1cdbd2cSJim Jagielski
2940*b1cdbd2cSJim Jagielski pPage->PaintBaBo( aPaintRect, pPage, sal_True );
2941*b1cdbd2cSJim Jagielski
2942*b1cdbd2cSJim Jagielski if ( pSh->Imp()->HasDrawView() )
2943*b1cdbd2cSJim Jagielski {
2944*b1cdbd2cSJim Jagielski pLines->LockLines( sal_True );
2945*b1cdbd2cSJim Jagielski const IDocumentDrawModelAccess* pIDDMA = pSh->getIDocumentDrawModelAccess();
2946*b1cdbd2cSJim Jagielski pSh->Imp()->PaintLayer( pIDDMA->GetHellId(),
2947*b1cdbd2cSJim Jagielski pPrintData,
2948*b1cdbd2cSJim Jagielski aPaintRect,
2949*b1cdbd2cSJim Jagielski &aPageBackgrdColor,
2950*b1cdbd2cSJim Jagielski (pPage->IsRightToLeft() ? true : false),
2951*b1cdbd2cSJim Jagielski &aSwRedirector );
2952*b1cdbd2cSJim Jagielski pLines->PaintLines( pSh->GetOut() );
2953*b1cdbd2cSJim Jagielski pLines->LockLines( sal_False );
2954*b1cdbd2cSJim Jagielski }
2955*b1cdbd2cSJim Jagielski
2956*b1cdbd2cSJim Jagielski if( pSh->GetWin() )
2957*b1cdbd2cSJim Jagielski {
2958*b1cdbd2cSJim Jagielski // collect sub-lines
2959*b1cdbd2cSJim Jagielski pPage->RefreshSubsidiary( aPaintRect );
2960*b1cdbd2cSJim Jagielski // paint special sub-lines
2961*b1cdbd2cSJim Jagielski pSpecSubsLines->PaintSubsidiary( pSh->GetOut(), NULL );
2962*b1cdbd2cSJim Jagielski }
2963*b1cdbd2cSJim Jagielski
2964*b1cdbd2cSJim Jagielski pPage->Paint( aPaintRect );
2965*b1cdbd2cSJim Jagielski
2966*b1cdbd2cSJim Jagielski // no paint of page border and shadow, if writer is in place mode.
2967*b1cdbd2cSJim Jagielski if( pSh->GetWin() && pSh->GetDoc()->GetDocShell() &&
2968*b1cdbd2cSJim Jagielski !pSh->GetDoc()->GetDocShell()->IsInPlaceActive() )
2969*b1cdbd2cSJim Jagielski {
2970*b1cdbd2cSJim Jagielski SwPageFrm::PaintBorderAndShadow( pPage->Frm(), pSh, bPaintRightShadow, bRightSidebar );
2971*b1cdbd2cSJim Jagielski SwPageFrm::PaintNotesSidebar( pPage->Frm(), pSh, pPage->GetPhyPageNum(), bRightSidebar);
2972*b1cdbd2cSJim Jagielski }
2973*b1cdbd2cSJim Jagielski
2974*b1cdbd2cSJim Jagielski pLines->PaintLines( pSh->GetOut() );
2975*b1cdbd2cSJim Jagielski
2976*b1cdbd2cSJim Jagielski if ( pSh->Imp()->HasDrawView() )
2977*b1cdbd2cSJim Jagielski {
2978*b1cdbd2cSJim Jagielski /// OD 29.08.2002 #102450# - add 3rd parameter
2979*b1cdbd2cSJim Jagielski // OD 09.12.2002 #103045# - add 4th parameter for horizontal text direction.
2980*b1cdbd2cSJim Jagielski pSh->Imp()->PaintLayer( pSh->GetDoc()->GetHeavenId(),
2981*b1cdbd2cSJim Jagielski pPrintData,
2982*b1cdbd2cSJim Jagielski aPaintRect,
2983*b1cdbd2cSJim Jagielski &aPageBackgrdColor,
2984*b1cdbd2cSJim Jagielski (pPage->IsRightToLeft() ? true : false),
2985*b1cdbd2cSJim Jagielski &aSwRedirector );
2986*b1cdbd2cSJim Jagielski }
2987*b1cdbd2cSJim Jagielski
2988*b1cdbd2cSJim Jagielski if ( bExtraData )
2989*b1cdbd2cSJim Jagielski pPage->RefreshExtraData( aPaintRect );
2990*b1cdbd2cSJim Jagielski
2991*b1cdbd2cSJim Jagielski if ( pSh->GetWin() )
2992*b1cdbd2cSJim Jagielski {
2993*b1cdbd2cSJim Jagielski pSubsLines->PaintSubsidiary( pSh->GetOut(), pLines );
2994*b1cdbd2cSJim Jagielski DELETEZ( pSubsLines );
2995*b1cdbd2cSJim Jagielski DELETEZ( pSpecSubsLines );
2996*b1cdbd2cSJim Jagielski }
2997*b1cdbd2cSJim Jagielski pVout->Leave();
2998*b1cdbd2cSJim Jagielski
2999*b1cdbd2cSJim Jagielski // #i68597#
3000*b1cdbd2cSJim Jagielski // needed to move grid painting inside Begin/EndDrawLayer bounds and to change
3001*b1cdbd2cSJim Jagielski // output rect for it accordingly
3002*b1cdbd2cSJim Jagielski if(bGridPainting)
3003*b1cdbd2cSJim Jagielski {
3004*b1cdbd2cSJim Jagielski SdrPaintView* pPaintView = pSh->Imp()->GetDrawView();
3005*b1cdbd2cSJim Jagielski SdrPageView* pPageView = pPaintView->GetSdrPageView();
3006*b1cdbd2cSJim Jagielski pPageView->DrawPageViewGrid(*pSh->GetOut(), aPaintRect.SVRect(), SwViewOption::GetTextGridColor() );
3007*b1cdbd2cSJim Jagielski }
3008*b1cdbd2cSJim Jagielski
3009*b1cdbd2cSJim Jagielski // #i68597#
3010*b1cdbd2cSJim Jagielski // moved paint post-process for DrawingLayer overlay here, see above
3011*b1cdbd2cSJim Jagielski {
3012*b1cdbd2cSJim Jagielski pSh->DLPostPaint2(true);
3013*b1cdbd2cSJim Jagielski }
3014*b1cdbd2cSJim Jagielski }
3015*b1cdbd2cSJim Jagielski }
3016*b1cdbd2cSJim Jagielski else if ( bBookMode && pSh->GetWin() && !pSh->GetDoc()->GetDocShell()->IsInPlaceActive() )
3017*b1cdbd2cSJim Jagielski {
3018*b1cdbd2cSJim Jagielski // paint empty page
3019*b1cdbd2cSJim Jagielski SwRect aPaintRect;
3020*b1cdbd2cSJim Jagielski SwRect aEmptyPageRect( pPage->Frm() );
3021*b1cdbd2cSJim Jagielski
3022*b1cdbd2cSJim Jagielski // code from vprint.cxx
3023*b1cdbd2cSJim Jagielski const SwPageFrm& rFormatPage = pPage->GetFormatPage();
3024*b1cdbd2cSJim Jagielski aEmptyPageRect.SSize() = rFormatPage.Frm().SSize();
3025*b1cdbd2cSJim Jagielski
3026*b1cdbd2cSJim Jagielski SwPageFrm::GetBorderAndShadowBoundRect( aEmptyPageRect, pSh, aPaintRect, bRightSidebar );
3027*b1cdbd2cSJim Jagielski aPaintRect._Intersection( aRect );
3028*b1cdbd2cSJim Jagielski
3029*b1cdbd2cSJim Jagielski if ( aRect.IsOver( aEmptyPageRect ) )
3030*b1cdbd2cSJim Jagielski {
3031*b1cdbd2cSJim Jagielski // #i75172# if called from ViewShell::ImplEndAction it sould no longer
3032*b1cdbd2cSJim Jagielski // really be used but handled by ViewShell::ImplEndAction already
3033*b1cdbd2cSJim Jagielski {
3034*b1cdbd2cSJim Jagielski const Region aDLRegion(aPaintRect.SVRect());
3035*b1cdbd2cSJim Jagielski pSh->DLPrePaint2(aDLRegion);
3036*b1cdbd2cSJim Jagielski }
3037*b1cdbd2cSJim Jagielski
3038*b1cdbd2cSJim Jagielski if( pSh->GetOut()->GetFillColor() != aGlobalRetoucheColor )
3039*b1cdbd2cSJim Jagielski pSh->GetOut()->SetFillColor( aGlobalRetoucheColor );
3040*b1cdbd2cSJim Jagielski
3041*b1cdbd2cSJim Jagielski pSh->GetOut()->SetLineColor(); // OD 20.02.2003 #107369# - no line color
3042*b1cdbd2cSJim Jagielski // OD 20.02.2003 #107369# - use aligned page rectangle
3043*b1cdbd2cSJim Jagielski {
3044*b1cdbd2cSJim Jagielski SwRect aTmpPageRect( aEmptyPageRect );
3045*b1cdbd2cSJim Jagielski ::SwAlignRect( aTmpPageRect, pSh );
3046*b1cdbd2cSJim Jagielski aEmptyPageRect = aTmpPageRect;
3047*b1cdbd2cSJim Jagielski }
3048*b1cdbd2cSJim Jagielski
3049*b1cdbd2cSJim Jagielski pSh->GetOut()->DrawRect( aEmptyPageRect.SVRect() );
3050*b1cdbd2cSJim Jagielski
3051*b1cdbd2cSJim Jagielski // paint empty page text
3052*b1cdbd2cSJim Jagielski const Font& rEmptyPageFont = SwPageFrm::GetEmptyPageFont();
3053*b1cdbd2cSJim Jagielski const Font aOldFont( pSh->GetOut()->GetFont() );
3054*b1cdbd2cSJim Jagielski
3055*b1cdbd2cSJim Jagielski pSh->GetOut()->SetFont( rEmptyPageFont );
3056*b1cdbd2cSJim Jagielski pSh->GetOut()->DrawText( aEmptyPageRect.SVRect(), SW_RESSTR( STR_EMPTYPAGE ),
3057*b1cdbd2cSJim Jagielski TEXT_DRAW_VCENTER |
3058*b1cdbd2cSJim Jagielski TEXT_DRAW_CENTER |
3059*b1cdbd2cSJim Jagielski TEXT_DRAW_CLIP );
3060*b1cdbd2cSJim Jagielski
3061*b1cdbd2cSJim Jagielski pSh->GetOut()->SetFont( aOldFont );
3062*b1cdbd2cSJim Jagielski // paint shadow and border for empty page
3063*b1cdbd2cSJim Jagielski // OD 19.02.2003 #107369# - use new method to paint page border and
3064*b1cdbd2cSJim Jagielski // shadow
3065*b1cdbd2cSJim Jagielski SwPageFrm::PaintBorderAndShadow( aEmptyPageRect, pSh, bPaintRightShadow, bRightSidebar );
3066*b1cdbd2cSJim Jagielski SwPageFrm::PaintNotesSidebar( aEmptyPageRect, pSh, pPage->GetPhyPageNum(), bRightSidebar);
3067*b1cdbd2cSJim Jagielski
3068*b1cdbd2cSJim Jagielski {
3069*b1cdbd2cSJim Jagielski pSh->DLPostPaint2(true);
3070*b1cdbd2cSJim Jagielski }
3071*b1cdbd2cSJim Jagielski }
3072*b1cdbd2cSJim Jagielski }
3073*b1cdbd2cSJim Jagielski
3074*b1cdbd2cSJim Jagielski ASSERT( !pPage->GetNext() || pPage->GetNext()->IsPageFrm(),
3075*b1cdbd2cSJim Jagielski "Nachbar von Seite keine Seite." );
3076*b1cdbd2cSJim Jagielski pPage = (SwPageFrm*)pPage->GetNext();
3077*b1cdbd2cSJim Jagielski }
3078*b1cdbd2cSJim Jagielski
3079*b1cdbd2cSJim Jagielski DELETEZ( pLines );
3080*b1cdbd2cSJim Jagielski
3081*b1cdbd2cSJim Jagielski #ifdef FRANK_TEST
3082*b1cdbd2cSJim Jagielski if ( pSh->GetWin() )
3083*b1cdbd2cSJim Jagielski {
3084*b1cdbd2cSJim Jagielski Rectangle aRect( aFrm.SVRect() );
3085*b1cdbd2cSJim Jagielski pSh->GetWin()->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
3086*b1cdbd2cSJim Jagielski pSh->GetWin()->SetFillColor();
3087*b1cdbd2cSJim Jagielski pSh->GetWin()->SetLineColor( COL_LIGHTRED );
3088*b1cdbd2cSJim Jagielski pSh->GetWin()->DrawRect( aRect );
3089*b1cdbd2cSJim Jagielski pSh->GetWin()->Pop();
3090*b1cdbd2cSJim Jagielski }
3091*b1cdbd2cSJim Jagielski #endif
3092*b1cdbd2cSJim Jagielski
3093*b1cdbd2cSJim Jagielski if ( bResetRootPaint )
3094*b1cdbd2cSJim Jagielski SwRootFrm::bInPaint = sal_False;
3095*b1cdbd2cSJim Jagielski if ( pStatics )
3096*b1cdbd2cSJim Jagielski delete pStatics;
3097*b1cdbd2cSJim Jagielski else
3098*b1cdbd2cSJim Jagielski {
3099*b1cdbd2cSJim Jagielski pProgress = 0;
3100*b1cdbd2cSJim Jagielski pGlobalShell = 0;
3101*b1cdbd2cSJim Jagielski }
3102*b1cdbd2cSJim Jagielski
3103*b1cdbd2cSJim Jagielski ((SwRootFrm*)this)->SetCallbackActionEnabled( bOldAction );
3104*b1cdbd2cSJim Jagielski }
3105*b1cdbd2cSJim Jagielski
3106*b1cdbd2cSJim Jagielski #ifdef LONG_TABLE_HACK
3107*b1cdbd2cSJim Jagielski
3108*b1cdbd2cSJim Jagielski /*************************************************************************
3109*b1cdbd2cSJim Jagielski |*
3110*b1cdbd2cSJim Jagielski |* SwRootFrm::HackPrepareLongTblPaint()
3111*b1cdbd2cSJim Jagielski |*
3112*b1cdbd2cSJim Jagielski |* Ersterstellung MA 27. Sep. 96
3113*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 18. Nov. 97
3114*b1cdbd2cSJim Jagielski |*
3115*b1cdbd2cSJim Jagielski |*************************************************************************/
3116*b1cdbd2cSJim Jagielski
HackPrepareLongTblPaint(int nMode)3117*b1cdbd2cSJim Jagielski void SwRootFrm::HackPrepareLongTblPaint( int nMode )
3118*b1cdbd2cSJim Jagielski {
3119*b1cdbd2cSJim Jagielski switch ( nMode )
3120*b1cdbd2cSJim Jagielski {
3121*b1cdbd2cSJim Jagielski case HACK_TABLEMODE_INIT : ASSERT( !pLines, "HackPrepare: already prepared" );
3122*b1cdbd2cSJim Jagielski pLines = new SwLineRects;
3123*b1cdbd2cSJim Jagielski ASSERT( !pGlobalShell, "old GlobalShell lost" );
3124*b1cdbd2cSJim Jagielski pGlobalShell = GetCurrShell();
3125*b1cdbd2cSJim Jagielski bTableHack = sal_True;
3126*b1cdbd2cSJim Jagielski break;
3127*b1cdbd2cSJim Jagielski case HACK_TABLEMODE_LOCKLINES : pLines->LockLines( sal_True ); break;
3128*b1cdbd2cSJim Jagielski case HACK_TABLEMODE_PAINTLINES : pLines->PaintLines( GetShell()->GetOut() );
3129*b1cdbd2cSJim Jagielski break;
3130*b1cdbd2cSJim Jagielski case HACK_TABLEMODE_UNLOCKLINES: pLines->LockLines( sal_False ); break;
3131*b1cdbd2cSJim Jagielski case HACK_TABLEMODE_EXIT : pLines->PaintLines( GetCurrShell()->GetOut() );
3132*b1cdbd2cSJim Jagielski DELETEZ( pLines );
3133*b1cdbd2cSJim Jagielski pGlobalShell = 0;
3134*b1cdbd2cSJim Jagielski bTableHack = sal_False;
3135*b1cdbd2cSJim Jagielski break;
3136*b1cdbd2cSJim Jagielski }
3137*b1cdbd2cSJim Jagielski }
3138*b1cdbd2cSJim Jagielski
3139*b1cdbd2cSJim Jagielski #endif
3140*b1cdbd2cSJim Jagielski
3141*b1cdbd2cSJim Jagielski
3142*b1cdbd2cSJim Jagielski /*************************************************************************
3143*b1cdbd2cSJim Jagielski |*
3144*b1cdbd2cSJim Jagielski |* SwLayoutFrm::Paint()
3145*b1cdbd2cSJim Jagielski |*
3146*b1cdbd2cSJim Jagielski |* Ersterstellung MA 19. May. 92
3147*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 19. Apr. 95
3148*b1cdbd2cSJim Jagielski |*
3149*b1cdbd2cSJim Jagielski |*************************************************************************/
3150*b1cdbd2cSJim Jagielski
lcl_EmergencyFormatFtnCont(SwFtnContFrm * pCont)3151*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_EmergencyFormatFtnCont( SwFtnContFrm *pCont )
3152*b1cdbd2cSJim Jagielski {
3153*b1cdbd2cSJim Jagielski //Es kann sein, dass der Cont vernichtet wird.
3154*b1cdbd2cSJim Jagielski SwCntntFrm *pCnt = pCont->ContainsCntnt();
3155*b1cdbd2cSJim Jagielski while ( pCnt && pCnt->IsInFtn() )
3156*b1cdbd2cSJim Jagielski {
3157*b1cdbd2cSJim Jagielski pCnt->Calc();
3158*b1cdbd2cSJim Jagielski pCnt = pCnt->GetNextCntntFrm();
3159*b1cdbd2cSJim Jagielski }
3160*b1cdbd2cSJim Jagielski }
3161*b1cdbd2cSJim Jagielski
3162*b1cdbd2cSJim Jagielski class SwShortCut
3163*b1cdbd2cSJim Jagielski {
3164*b1cdbd2cSJim Jagielski SwRectDist fnCheck;
3165*b1cdbd2cSJim Jagielski long nLimit;
3166*b1cdbd2cSJim Jagielski public:
3167*b1cdbd2cSJim Jagielski SwShortCut( const SwFrm& rFrm, const SwRect& rRect );
Stop(const SwRect & rRect) const3168*b1cdbd2cSJim Jagielski sal_Bool Stop( const SwRect& rRect ) const
3169*b1cdbd2cSJim Jagielski { return (rRect.*fnCheck)( nLimit ) > 0; }
3170*b1cdbd2cSJim Jagielski };
3171*b1cdbd2cSJim Jagielski
SwShortCut(const SwFrm & rFrm,const SwRect & rRect)3172*b1cdbd2cSJim Jagielski SwShortCut::SwShortCut( const SwFrm& rFrm, const SwRect& rRect )
3173*b1cdbd2cSJim Jagielski {
3174*b1cdbd2cSJim Jagielski sal_Bool bVert = rFrm.IsVertical();
3175*b1cdbd2cSJim Jagielski sal_Bool bR2L = rFrm.IsRightToLeft();
3176*b1cdbd2cSJim Jagielski if( rFrm.IsNeighbourFrm() && bVert == bR2L )
3177*b1cdbd2cSJim Jagielski {
3178*b1cdbd2cSJim Jagielski if( bVert )
3179*b1cdbd2cSJim Jagielski {
3180*b1cdbd2cSJim Jagielski fnCheck = &SwRect::GetBottomDistance;
3181*b1cdbd2cSJim Jagielski nLimit = rRect.Top();
3182*b1cdbd2cSJim Jagielski }
3183*b1cdbd2cSJim Jagielski else
3184*b1cdbd2cSJim Jagielski {
3185*b1cdbd2cSJim Jagielski fnCheck = &SwRect::GetLeftDistance;
3186*b1cdbd2cSJim Jagielski nLimit = rRect.Left() + rRect.Width();
3187*b1cdbd2cSJim Jagielski }
3188*b1cdbd2cSJim Jagielski }
3189*b1cdbd2cSJim Jagielski else if( bVert == rFrm.IsNeighbourFrm() )
3190*b1cdbd2cSJim Jagielski {
3191*b1cdbd2cSJim Jagielski fnCheck = &SwRect::GetTopDistance;
3192*b1cdbd2cSJim Jagielski nLimit = rRect.Top() + rRect.Height();
3193*b1cdbd2cSJim Jagielski }
3194*b1cdbd2cSJim Jagielski else
3195*b1cdbd2cSJim Jagielski {
3196*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
3197*b1cdbd2cSJim Jagielski if ( rFrm.IsVertLR() )
3198*b1cdbd2cSJim Jagielski {
3199*b1cdbd2cSJim Jagielski fnCheck = &SwRect::GetLeftDistance;
3200*b1cdbd2cSJim Jagielski nLimit = rRect.Right();
3201*b1cdbd2cSJim Jagielski }
3202*b1cdbd2cSJim Jagielski else
3203*b1cdbd2cSJim Jagielski {
3204*b1cdbd2cSJim Jagielski fnCheck = &SwRect::GetRightDistance;
3205*b1cdbd2cSJim Jagielski nLimit = rRect.Left();
3206*b1cdbd2cSJim Jagielski }
3207*b1cdbd2cSJim Jagielski }
3208*b1cdbd2cSJim Jagielski }
3209*b1cdbd2cSJim Jagielski
Paint(SwRect const & rRect,SwPrintData const * const) const3210*b1cdbd2cSJim Jagielski void SwLayoutFrm::Paint(SwRect const& rRect, SwPrintData const*const) const
3211*b1cdbd2cSJim Jagielski {
3212*b1cdbd2cSJim Jagielski ViewShell *pSh = getRootFrm()->GetCurrShell();
3213*b1cdbd2cSJim Jagielski
3214*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
3215*b1cdbd2cSJim Jagielski Frm_Info aFrmInfo( *this );
3216*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, &aFrmInfo, 0, *pSh->GetOut() );
3217*b1cdbd2cSJim Jagielski // <--
3218*b1cdbd2cSJim Jagielski
3219*b1cdbd2cSJim Jagielski const SwFrm *pFrm = Lower();
3220*b1cdbd2cSJim Jagielski if ( !pFrm )
3221*b1cdbd2cSJim Jagielski return;
3222*b1cdbd2cSJim Jagielski
3223*b1cdbd2cSJim Jagielski SwShortCut aShortCut( *pFrm, rRect );
3224*b1cdbd2cSJim Jagielski sal_Bool bCnt;
3225*b1cdbd2cSJim Jagielski if ( sal_True == (bCnt = pFrm->IsCntntFrm()) )
3226*b1cdbd2cSJim Jagielski pFrm->Calc();
3227*b1cdbd2cSJim Jagielski
3228*b1cdbd2cSJim Jagielski if ( pFrm->IsFtnContFrm() )
3229*b1cdbd2cSJim Jagielski {
3230*b1cdbd2cSJim Jagielski ::lcl_EmergencyFormatFtnCont( (SwFtnContFrm*)pFrm );
3231*b1cdbd2cSJim Jagielski pFrm = Lower();
3232*b1cdbd2cSJim Jagielski }
3233*b1cdbd2cSJim Jagielski
3234*b1cdbd2cSJim Jagielski const SwPageFrm *pPage = 0;
3235*b1cdbd2cSJim Jagielski const sal_Bool bWin = pGlobalShell->GetWin() ? sal_True : sal_False;
3236*b1cdbd2cSJim Jagielski
3237*b1cdbd2cSJim Jagielski while ( IsAnLower( pFrm ) )
3238*b1cdbd2cSJim Jagielski {
3239*b1cdbd2cSJim Jagielski SwRect aPaintRect( pFrm->PaintArea() );
3240*b1cdbd2cSJim Jagielski if( aShortCut.Stop( aPaintRect ) )
3241*b1cdbd2cSJim Jagielski break;
3242*b1cdbd2cSJim Jagielski if ( bCnt && pProgress )
3243*b1cdbd2cSJim Jagielski pProgress->Reschedule();
3244*b1cdbd2cSJim Jagielski
3245*b1cdbd2cSJim Jagielski //Wenn ein Frm es explizit will muss retouchiert werden.
3246*b1cdbd2cSJim Jagielski //Erst die Retouche, denn selbige koennte die aligned'en Raender
3247*b1cdbd2cSJim Jagielski //plaetten.
3248*b1cdbd2cSJim Jagielski if ( pFrm->IsRetouche() )
3249*b1cdbd2cSJim Jagielski {
3250*b1cdbd2cSJim Jagielski if ( pFrm->IsRetoucheFrm() && bWin && !pFrm->GetNext() )
3251*b1cdbd2cSJim Jagielski { if ( !pPage )
3252*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
3253*b1cdbd2cSJim Jagielski pFrm->Retouche( pPage, rRect );
3254*b1cdbd2cSJim Jagielski }
3255*b1cdbd2cSJim Jagielski pFrm->ResetRetouche();
3256*b1cdbd2cSJim Jagielski }
3257*b1cdbd2cSJim Jagielski
3258*b1cdbd2cSJim Jagielski if ( rRect.IsOver( aPaintRect ) )
3259*b1cdbd2cSJim Jagielski {
3260*b1cdbd2cSJim Jagielski if ( bCnt && pFrm->IsCompletePaint() &&
3261*b1cdbd2cSJim Jagielski !rRect.IsInside( aPaintRect ) && GetpApp()->AnyInput( INPUT_KEYBOARD ) )
3262*b1cdbd2cSJim Jagielski {
3263*b1cdbd2cSJim Jagielski //fix(8104): Es kann vorkommen, dass die Verarbeitung nicht
3264*b1cdbd2cSJim Jagielski //vollstaendig war, aber trotzdem Teile des Absatzes gepaintet
3265*b1cdbd2cSJim Jagielski //werden. In der Folge werden dann evtl. wiederum andere Teile
3266*b1cdbd2cSJim Jagielski //des Absatzes garnicht mehr gepaintet. Einziger Ausweg scheint
3267*b1cdbd2cSJim Jagielski //hier ein Invalidieren der Windows zu sein.
3268*b1cdbd2cSJim Jagielski //Um es nicht alzu Heftig werden zu lassen versuche ich hier
3269*b1cdbd2cSJim Jagielski //das Rechteck zu begrenzen indem der gewuenschte Teil gepaintet
3270*b1cdbd2cSJim Jagielski //und nur die uebrigen Absatzanteile invalidiert werden.
3271*b1cdbd2cSJim Jagielski if ( aPaintRect.Left() == rRect.Left() &&
3272*b1cdbd2cSJim Jagielski aPaintRect.Right() == rRect.Right() )
3273*b1cdbd2cSJim Jagielski {
3274*b1cdbd2cSJim Jagielski aPaintRect.Bottom( rRect.Top() - 1 );
3275*b1cdbd2cSJim Jagielski if ( aPaintRect.Height() > 0 )
3276*b1cdbd2cSJim Jagielski pGlobalShell->InvalidateWindows(aPaintRect);
3277*b1cdbd2cSJim Jagielski aPaintRect.Top( rRect.Bottom() + 1 );
3278*b1cdbd2cSJim Jagielski aPaintRect.Bottom( pFrm->Frm().Bottom() );
3279*b1cdbd2cSJim Jagielski if ( aPaintRect.Height() > 0 )
3280*b1cdbd2cSJim Jagielski pGlobalShell->InvalidateWindows(aPaintRect);
3281*b1cdbd2cSJim Jagielski aPaintRect.Top( pFrm->Frm().Top() );
3282*b1cdbd2cSJim Jagielski aPaintRect.Bottom( pFrm->Frm().Bottom() );
3283*b1cdbd2cSJim Jagielski }
3284*b1cdbd2cSJim Jagielski else
3285*b1cdbd2cSJim Jagielski {
3286*b1cdbd2cSJim Jagielski pGlobalShell->InvalidateWindows( aPaintRect );
3287*b1cdbd2cSJim Jagielski pFrm = pFrm->GetNext();
3288*b1cdbd2cSJim Jagielski if ( pFrm && (sal_True == (bCnt = pFrm->IsCntntFrm())) )
3289*b1cdbd2cSJim Jagielski pFrm->Calc();
3290*b1cdbd2cSJim Jagielski continue;
3291*b1cdbd2cSJim Jagielski }
3292*b1cdbd2cSJim Jagielski }
3293*b1cdbd2cSJim Jagielski pFrm->ResetCompletePaint();
3294*b1cdbd2cSJim Jagielski aPaintRect._Intersection( rRect );
3295*b1cdbd2cSJim Jagielski
3296*b1cdbd2cSJim Jagielski pFrm->Paint( aPaintRect );
3297*b1cdbd2cSJim Jagielski
3298*b1cdbd2cSJim Jagielski if ( Lower() && Lower()->IsColumnFrm() )
3299*b1cdbd2cSJim Jagielski {
3300*b1cdbd2cSJim Jagielski //Ggf. die Spaltentrennlinien malen. Fuer den Seitenbody ist
3301*b1cdbd2cSJim Jagielski //nicht der Upper sondern die Seite Zustaendig.
3302*b1cdbd2cSJim Jagielski const SwFrmFmt *pFmt = GetUpper() && GetUpper()->IsPageFrm()
3303*b1cdbd2cSJim Jagielski ? GetUpper()->GetFmt()
3304*b1cdbd2cSJim Jagielski : GetFmt();
3305*b1cdbd2cSJim Jagielski const SwFmtCol &rCol = pFmt->GetCol();
3306*b1cdbd2cSJim Jagielski if ( rCol.GetLineAdj() != COLADJ_NONE )
3307*b1cdbd2cSJim Jagielski {
3308*b1cdbd2cSJim Jagielski if ( !pPage )
3309*b1cdbd2cSJim Jagielski pPage = pFrm->FindPageFrm();
3310*b1cdbd2cSJim Jagielski
3311*b1cdbd2cSJim Jagielski PaintColLines( aPaintRect, rCol, pPage );
3312*b1cdbd2cSJim Jagielski }
3313*b1cdbd2cSJim Jagielski }
3314*b1cdbd2cSJim Jagielski }
3315*b1cdbd2cSJim Jagielski if ( !bCnt && pFrm->GetNext() && pFrm->GetNext()->IsFtnContFrm() )
3316*b1cdbd2cSJim Jagielski ::lcl_EmergencyFormatFtnCont( (SwFtnContFrm*)pFrm->GetNext() );
3317*b1cdbd2cSJim Jagielski
3318*b1cdbd2cSJim Jagielski pFrm = pFrm->GetNext();
3319*b1cdbd2cSJim Jagielski if ( pFrm && (sal_True == (bCnt = pFrm->IsCntntFrm())) )
3320*b1cdbd2cSJim Jagielski pFrm->Calc();
3321*b1cdbd2cSJim Jagielski }
3322*b1cdbd2cSJim Jagielski }
3323*b1cdbd2cSJim Jagielski
3324*b1cdbd2cSJim Jagielski
3325*b1cdbd2cSJim Jagielski /** FlyFrm::IsBackgroundTransparent - for feature #99657#
3326*b1cdbd2cSJim Jagielski
3327*b1cdbd2cSJim Jagielski OD 12.08.2002
3328*b1cdbd2cSJim Jagielski determines, if background of fly frame has to be drawn transparent
3329*b1cdbd2cSJim Jagielski declaration found in /core/inc/flyfrm.cxx
3330*b1cdbd2cSJim Jagielski OD 08.10.2002 #103898# - If the background of the fly frame itself is not
3331*b1cdbd2cSJim Jagielski transparent and the background is inherited from its parent/grandparent,
3332*b1cdbd2cSJim Jagielski the background brush, used for drawing, has to be investigated for transparency.
3333*b1cdbd2cSJim Jagielski
3334*b1cdbd2cSJim Jagielski @author OD
3335*b1cdbd2cSJim Jagielski
3336*b1cdbd2cSJim Jagielski @return true, if background is transparent drawn.
3337*b1cdbd2cSJim Jagielski */
IsBackgroundTransparent() const3338*b1cdbd2cSJim Jagielski sal_Bool SwFlyFrm::IsBackgroundTransparent() const
3339*b1cdbd2cSJim Jagielski {
3340*b1cdbd2cSJim Jagielski sal_Bool bBackgroundTransparent = GetFmt()->IsBackgroundTransparent();
3341*b1cdbd2cSJim Jagielski if ( !bBackgroundTransparent &&
3342*b1cdbd2cSJim Jagielski static_cast<const SwFlyFrmFmt*>(GetFmt())->IsBackgroundBrushInherited() )
3343*b1cdbd2cSJim Jagielski {
3344*b1cdbd2cSJim Jagielski const SvxBrushItem* pBackgrdBrush = 0;
3345*b1cdbd2cSJim Jagielski const Color* pSectionTOXColor = 0;
3346*b1cdbd2cSJim Jagielski SwRect aDummyRect;
3347*b1cdbd2cSJim Jagielski if ( GetBackgroundBrush( pBackgrdBrush, pSectionTOXColor, aDummyRect, false) )
3348*b1cdbd2cSJim Jagielski {
3349*b1cdbd2cSJim Jagielski if ( pSectionTOXColor &&
3350*b1cdbd2cSJim Jagielski (pSectionTOXColor->GetTransparency() != 0) &&
3351*b1cdbd2cSJim Jagielski (pSectionTOXColor->GetColor() != COL_TRANSPARENT) )
3352*b1cdbd2cSJim Jagielski {
3353*b1cdbd2cSJim Jagielski bBackgroundTransparent = sal_True;
3354*b1cdbd2cSJim Jagielski }
3355*b1cdbd2cSJim Jagielski else if ( pBackgrdBrush )
3356*b1cdbd2cSJim Jagielski {
3357*b1cdbd2cSJim Jagielski if ( (pBackgrdBrush->GetColor().GetTransparency() != 0) &&
3358*b1cdbd2cSJim Jagielski (pBackgrdBrush->GetColor() != COL_TRANSPARENT) )
3359*b1cdbd2cSJim Jagielski {
3360*b1cdbd2cSJim Jagielski bBackgroundTransparent = sal_True;
3361*b1cdbd2cSJim Jagielski }
3362*b1cdbd2cSJim Jagielski else
3363*b1cdbd2cSJim Jagielski {
3364*b1cdbd2cSJim Jagielski const GraphicObject *pTmpGrf =
3365*b1cdbd2cSJim Jagielski static_cast<const GraphicObject*>(pBackgrdBrush->GetGraphicObject());
3366*b1cdbd2cSJim Jagielski if ( (pTmpGrf) &&
3367*b1cdbd2cSJim Jagielski (pTmpGrf->GetAttr().GetTransparency() != 0)
3368*b1cdbd2cSJim Jagielski )
3369*b1cdbd2cSJim Jagielski {
3370*b1cdbd2cSJim Jagielski bBackgroundTransparent = sal_True;
3371*b1cdbd2cSJim Jagielski }
3372*b1cdbd2cSJim Jagielski }
3373*b1cdbd2cSJim Jagielski }
3374*b1cdbd2cSJim Jagielski }
3375*b1cdbd2cSJim Jagielski }
3376*b1cdbd2cSJim Jagielski
3377*b1cdbd2cSJim Jagielski return bBackgroundTransparent;
3378*b1cdbd2cSJim Jagielski };
3379*b1cdbd2cSJim Jagielski
3380*b1cdbd2cSJim Jagielski /** FlyFrm::IsShadowTransparent - for feature #99657#
3381*b1cdbd2cSJim Jagielski
3382*b1cdbd2cSJim Jagielski OD 13.08.2002
3383*b1cdbd2cSJim Jagielski determine, if shadow color of fly frame has to be drawn transparent
3384*b1cdbd2cSJim Jagielski declaration found in /core/inc/flyfrm.cxx
3385*b1cdbd2cSJim Jagielski
3386*b1cdbd2cSJim Jagielski @author OD
3387*b1cdbd2cSJim Jagielski
3388*b1cdbd2cSJim Jagielski @return true, if shadow color is transparent.
3389*b1cdbd2cSJim Jagielski */
IsShadowTransparent() const3390*b1cdbd2cSJim Jagielski sal_Bool SwFlyFrm::IsShadowTransparent() const
3391*b1cdbd2cSJim Jagielski {
3392*b1cdbd2cSJim Jagielski return GetFmt()->IsShadowTransparent();
3393*b1cdbd2cSJim Jagielski };
3394*b1cdbd2cSJim Jagielski
3395*b1cdbd2cSJim Jagielski /*************************************************************************
3396*b1cdbd2cSJim Jagielski |*
3397*b1cdbd2cSJim Jagielski |* SwFlyFrm::IsPaint()
3398*b1cdbd2cSJim Jagielski |*
3399*b1cdbd2cSJim Jagielski |* Ersterstellung MA 16. Jan. 97
3400*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 16. Jan. 97
3401*b1cdbd2cSJim Jagielski |*
3402*b1cdbd2cSJim Jagielski |*************************************************************************/
3403*b1cdbd2cSJim Jagielski
IsPaint(SdrObject * pObj,const ViewShell * pSh)3404*b1cdbd2cSJim Jagielski sal_Bool SwFlyFrm::IsPaint( SdrObject *pObj, const ViewShell *pSh )
3405*b1cdbd2cSJim Jagielski {
3406*b1cdbd2cSJim Jagielski SdrObjUserCall *pUserCall;
3407*b1cdbd2cSJim Jagielski
3408*b1cdbd2cSJim Jagielski if ( 0 == ( pUserCall = GetUserCall(pObj) ) )
3409*b1cdbd2cSJim Jagielski return sal_True;
3410*b1cdbd2cSJim Jagielski
3411*b1cdbd2cSJim Jagielski //Attributabhaengig nicht fuer Drucker oder PreView painten
3412*b1cdbd2cSJim Jagielski sal_Bool bPaint = pFlyOnlyDraw ||
3413*b1cdbd2cSJim Jagielski ((SwContact*)pUserCall)->GetFmt()->GetPrint().GetValue();
3414*b1cdbd2cSJim Jagielski if ( !bPaint )
3415*b1cdbd2cSJim Jagielski bPaint = pSh->GetWin() && !pSh->IsPreView();
3416*b1cdbd2cSJim Jagielski
3417*b1cdbd2cSJim Jagielski if ( bPaint )
3418*b1cdbd2cSJim Jagielski {
3419*b1cdbd2cSJim Jagielski //Das Paint kann evtl. von von uebergeordneten Flys verhindert werden.
3420*b1cdbd2cSJim Jagielski SwFrm *pAnch = 0;
3421*b1cdbd2cSJim Jagielski // --> OD #i117962#
3422*b1cdbd2cSJim Jagielski if ( pObj->ISA(SwFlyDrawObj) )
3423*b1cdbd2cSJim Jagielski {
3424*b1cdbd2cSJim Jagielski bPaint = false;
3425*b1cdbd2cSJim Jagielski }
3426*b1cdbd2cSJim Jagielski // <--
3427*b1cdbd2cSJim Jagielski else if ( pObj->ISA(SwVirtFlyDrawObj) )
3428*b1cdbd2cSJim Jagielski {
3429*b1cdbd2cSJim Jagielski SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
3430*b1cdbd2cSJim Jagielski if ( pFlyOnlyDraw && pFlyOnlyDraw == pFly )
3431*b1cdbd2cSJim Jagielski return sal_True;
3432*b1cdbd2cSJim Jagielski
3433*b1cdbd2cSJim Jagielski //Die Anzeige eines Zwischenstadiums vermeiden, Flys die nicht mit
3434*b1cdbd2cSJim Jagielski //der Seite auf der sie verankert sind ueberlappen werden auch
3435*b1cdbd2cSJim Jagielski //nicht gepaintet.
3436*b1cdbd2cSJim Jagielski //HACK: Ausnahme: Drucken von Rahmen in Tabellen, diese koennen
3437*b1cdbd2cSJim Jagielski //bei uebergrossen Tabellen (HTML) schon mal auserhalb der Seite
3438*b1cdbd2cSJim Jagielski //stehen.
3439*b1cdbd2cSJim Jagielski SwPageFrm *pPage = pFly->FindPageFrm();
3440*b1cdbd2cSJim Jagielski if ( pPage )
3441*b1cdbd2cSJim Jagielski {
3442*b1cdbd2cSJim Jagielski if ( pPage->Frm().IsOver( pFly->Frm() ) )
3443*b1cdbd2cSJim Jagielski pAnch = pFly->AnchorFrm();
3444*b1cdbd2cSJim Jagielski else if ( bTableHack &&
3445*b1cdbd2cSJim Jagielski pFly->Frm().Top() >= pFly->GetAnchorFrm()->Frm().Top() &&
3446*b1cdbd2cSJim Jagielski pFly->Frm().Top() < pFly->GetAnchorFrm()->Frm().Bottom() &&
3447*b1cdbd2cSJim Jagielski long(pSh->GetOut()) ==
3448*b1cdbd2cSJim Jagielski long(pSh->getIDocumentDeviceAccess()->getPrinter( false ) ) )
3449*b1cdbd2cSJim Jagielski {
3450*b1cdbd2cSJim Jagielski pAnch = pFly->AnchorFrm();
3451*b1cdbd2cSJim Jagielski }
3452*b1cdbd2cSJim Jagielski }
3453*b1cdbd2cSJim Jagielski
3454*b1cdbd2cSJim Jagielski }
3455*b1cdbd2cSJim Jagielski else
3456*b1cdbd2cSJim Jagielski {
3457*b1cdbd2cSJim Jagielski // OD 13.10.2003 #i19919# - consider 'virtual' drawing objects
3458*b1cdbd2cSJim Jagielski // OD 2004-03-29 #i26791#
3459*b1cdbd2cSJim Jagielski pAnch = ((SwDrawContact*)pUserCall)->GetAnchorFrm( pObj );
3460*b1cdbd2cSJim Jagielski if ( pAnch )
3461*b1cdbd2cSJim Jagielski {
3462*b1cdbd2cSJim Jagielski if ( !pAnch->GetValidPosFlag() )
3463*b1cdbd2cSJim Jagielski pAnch = 0;
3464*b1cdbd2cSJim Jagielski else if ( long(pSh->GetOut()) == long(pSh->getIDocumentDeviceAccess()->getPrinter( false )))
3465*b1cdbd2cSJim Jagielski {
3466*b1cdbd2cSJim Jagielski //HACK: fuer das Drucken muessen wir ein paar Objekte
3467*b1cdbd2cSJim Jagielski //weglassen, da diese sonst doppelt gedruckt werden.
3468*b1cdbd2cSJim Jagielski //Die Objekte sollen gedruckt werden, wenn der TableHack
3469*b1cdbd2cSJim Jagielski //gerade greift. In der Folge duerfen sie nicht gedruckt werden
3470*b1cdbd2cSJim Jagielski //wenn sie mit der Seite dran sind, ueber der sie von der
3471*b1cdbd2cSJim Jagielski //Position her gerade schweben.
3472*b1cdbd2cSJim Jagielski const SwPageFrm *pPage = pAnch->FindPageFrm();
3473*b1cdbd2cSJim Jagielski if ( !bTableHack &&
3474*b1cdbd2cSJim Jagielski !pPage->Frm().IsOver( pObj->GetCurrentBoundRect() ) )
3475*b1cdbd2cSJim Jagielski pAnch = 0;
3476*b1cdbd2cSJim Jagielski }
3477*b1cdbd2cSJim Jagielski }
3478*b1cdbd2cSJim Jagielski else
3479*b1cdbd2cSJim Jagielski {
3480*b1cdbd2cSJim Jagielski // OD 02.07.2003 #108784# - debug assert
3481*b1cdbd2cSJim Jagielski if ( !pObj->ISA(SdrObjGroup) )
3482*b1cdbd2cSJim Jagielski {
3483*b1cdbd2cSJim Jagielski ASSERT( false, "<SwFlyFrm::IsPaint(..)> - paint of drawing object without anchor frame!?" );
3484*b1cdbd2cSJim Jagielski }
3485*b1cdbd2cSJim Jagielski }
3486*b1cdbd2cSJim Jagielski }
3487*b1cdbd2cSJim Jagielski if ( pAnch )
3488*b1cdbd2cSJim Jagielski {
3489*b1cdbd2cSJim Jagielski if ( pAnch->IsInFly() )
3490*b1cdbd2cSJim Jagielski bPaint = SwFlyFrm::IsPaint( pAnch->FindFlyFrm()->GetVirtDrawObj(),
3491*b1cdbd2cSJim Jagielski pSh );
3492*b1cdbd2cSJim Jagielski else if ( pFlyOnlyDraw )
3493*b1cdbd2cSJim Jagielski bPaint = sal_False;
3494*b1cdbd2cSJim Jagielski }
3495*b1cdbd2cSJim Jagielski else
3496*b1cdbd2cSJim Jagielski bPaint = sal_False;
3497*b1cdbd2cSJim Jagielski }
3498*b1cdbd2cSJim Jagielski return bPaint;
3499*b1cdbd2cSJim Jagielski }
3500*b1cdbd2cSJim Jagielski
3501*b1cdbd2cSJim Jagielski /*************************************************************************
3502*b1cdbd2cSJim Jagielski |* SwCellFrm::Paint( const SwRect& ) const
3503*b1cdbd2cSJim Jagielski |*************************************************************************/
Paint(SwRect const & rRect,SwPrintData const * const) const3504*b1cdbd2cSJim Jagielski void SwCellFrm::Paint(SwRect const& rRect, SwPrintData const*const) const
3505*b1cdbd2cSJim Jagielski {
3506*b1cdbd2cSJim Jagielski if ( GetLayoutRowSpan() >= 1 )
3507*b1cdbd2cSJim Jagielski SwLayoutFrm::Paint( rRect );
3508*b1cdbd2cSJim Jagielski }
3509*b1cdbd2cSJim Jagielski
3510*b1cdbd2cSJim Jagielski /*************************************************************************
3511*b1cdbd2cSJim Jagielski |*
3512*b1cdbd2cSJim Jagielski |* SwFlyFrm::Paint()
3513*b1cdbd2cSJim Jagielski |*
3514*b1cdbd2cSJim Jagielski |* Ersterstellung MA ??
3515*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 16. Jan. 97
3516*b1cdbd2cSJim Jagielski |*
3517*b1cdbd2cSJim Jagielski |*************************************************************************/
3518*b1cdbd2cSJim Jagielski
3519*b1cdbd2cSJim Jagielski //Weiter unten definiert
3520*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_PaintLowerBorders( const SwLayoutFrm *pLay,
3521*b1cdbd2cSJim Jagielski const SwRect &rRect, const SwPageFrm *pPage );
3522*b1cdbd2cSJim Jagielski
Paint(SwRect const & rRect,SwPrintData const * const) const3523*b1cdbd2cSJim Jagielski void SwFlyFrm::Paint(SwRect const& rRect, SwPrintData const*const) const
3524*b1cdbd2cSJim Jagielski {
3525*b1cdbd2cSJim Jagielski //begin:optimize thumbnail generate and store procedure to improve odt saving performance, i120030
3526*b1cdbd2cSJim Jagielski ViewShell *pShell = getRootFrm()->GetCurrShell();
3527*b1cdbd2cSJim Jagielski if (pShell && pShell->GetDoc() && pShell->GetDoc()->GetDocShell())
3528*b1cdbd2cSJim Jagielski {
3529*b1cdbd2cSJim Jagielski sal_Bool bInGenerateThumbnail = pShell->GetDoc()->GetDocShell()->IsInGenerateAndStoreThumbnail();
3530*b1cdbd2cSJim Jagielski if (bInGenerateThumbnail)
3531*b1cdbd2cSJim Jagielski {
3532*b1cdbd2cSJim Jagielski SwRect aVisRect = pShell->VisArea();
3533*b1cdbd2cSJim Jagielski if (!aVisRect.IsOver(Frm()))
3534*b1cdbd2cSJim Jagielski return;
3535*b1cdbd2cSJim Jagielski }
3536*b1cdbd2cSJim Jagielski }
3537*b1cdbd2cSJim Jagielski //end:i120030
3538*b1cdbd2cSJim Jagielski
3539*b1cdbd2cSJim Jagielski //wegen der Ueberlappung von Rahmen und Zeichenobjekten muessen die
3540*b1cdbd2cSJim Jagielski //Flys ihre Umrandung (und die der Innenliegenden) direkt ausgeben.
3541*b1cdbd2cSJim Jagielski //z.B. #33066#
3542*b1cdbd2cSJim Jagielski pLines->LockLines(sal_True);
3543*b1cdbd2cSJim Jagielski
3544*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
3545*b1cdbd2cSJim Jagielski aRect._Intersection( Frm() );
3546*b1cdbd2cSJim Jagielski
3547*b1cdbd2cSJim Jagielski OutputDevice* pOut = pGlobalShell->GetOut();
3548*b1cdbd2cSJim Jagielski pOut->Push( PUSH_CLIPREGION );
3549*b1cdbd2cSJim Jagielski pOut->SetClipRegion();
3550*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = FindPageFrm();
3551*b1cdbd2cSJim Jagielski
3552*b1cdbd2cSJim Jagielski const SwNoTxtFrm *pNoTxt = Lower() && Lower()->IsNoTxtFrm()
3553*b1cdbd2cSJim Jagielski ? (SwNoTxtFrm*)Lower() : 0;
3554*b1cdbd2cSJim Jagielski
3555*b1cdbd2cSJim Jagielski bool bIsChart = false; //#i102950# don't paint additional borders for charts
3556*b1cdbd2cSJim Jagielski //check whether we have a chart
3557*b1cdbd2cSJim Jagielski if(pNoTxt)
3558*b1cdbd2cSJim Jagielski {
3559*b1cdbd2cSJim Jagielski const SwNoTxtNode* pNoTNd = dynamic_cast<const SwNoTxtNode*>(pNoTxt->GetNode());
3560*b1cdbd2cSJim Jagielski if( pNoTNd )
3561*b1cdbd2cSJim Jagielski {
3562*b1cdbd2cSJim Jagielski SwOLENode* pOLENd = const_cast<SwOLENode*>(pNoTNd->GetOLENode());
3563*b1cdbd2cSJim Jagielski if( pOLENd && ChartHelper::IsChart( pOLENd->GetOLEObj().GetObject() ) )
3564*b1cdbd2cSJim Jagielski bIsChart = true;
3565*b1cdbd2cSJim Jagielski }
3566*b1cdbd2cSJim Jagielski }
3567*b1cdbd2cSJim Jagielski
3568*b1cdbd2cSJim Jagielski {
3569*b1cdbd2cSJim Jagielski bool bContour = GetFmt()->GetSurround().IsContour();
3570*b1cdbd2cSJim Jagielski PolyPolygon aPoly;
3571*b1cdbd2cSJim Jagielski if ( bContour )
3572*b1cdbd2cSJim Jagielski {
3573*b1cdbd2cSJim Jagielski // OD 16.04.2003 #i13147# - add 2nd parameter with value <sal_True>
3574*b1cdbd2cSJim Jagielski // to indicate that method is called for paint in order to avoid
3575*b1cdbd2cSJim Jagielski // load of the intrinsic graphic.
3576*b1cdbd2cSJim Jagielski bContour = GetContour( aPoly, sal_True );
3577*b1cdbd2cSJim Jagielski }
3578*b1cdbd2cSJim Jagielski
3579*b1cdbd2cSJim Jagielski // --> OD 2005-06-08 #i47804# - distinguish complete background paint
3580*b1cdbd2cSJim Jagielski // and margin paint.
3581*b1cdbd2cSJim Jagielski // paint complete background for Writer text fly frames
3582*b1cdbd2cSJim Jagielski bool bPaintCompleteBack( !pNoTxt );
3583*b1cdbd2cSJim Jagielski // <--
3584*b1cdbd2cSJim Jagielski // paint complete background for transparent graphic and contour,
3585*b1cdbd2cSJim Jagielski // if own background color exists.
3586*b1cdbd2cSJim Jagielski const bool bIsGraphicTransparent = pNoTxt ? pNoTxt->IsTransparent() : false;
3587*b1cdbd2cSJim Jagielski if ( !bPaintCompleteBack &&
3588*b1cdbd2cSJim Jagielski ( bIsGraphicTransparent|| bContour ) )
3589*b1cdbd2cSJim Jagielski {
3590*b1cdbd2cSJim Jagielski const SvxBrushItem &rBack = GetFmt()->GetBackground();
3591*b1cdbd2cSJim Jagielski // OD 07.08.2002 #99657# #GetTransChg#
3592*b1cdbd2cSJim Jagielski // to determine, if background has to be painted, by checking, if
3593*b1cdbd2cSJim Jagielski // background color is not COL_TRANSPARENT ("no fill"/"auto fill")
3594*b1cdbd2cSJim Jagielski // or a background graphic exists.
3595*b1cdbd2cSJim Jagielski bPaintCompleteBack = !(rBack.GetColor() == COL_TRANSPARENT) ||
3596*b1cdbd2cSJim Jagielski rBack.GetGraphicPos() != GPOS_NONE;
3597*b1cdbd2cSJim Jagielski }
3598*b1cdbd2cSJim Jagielski // paint of margin needed.
3599*b1cdbd2cSJim Jagielski const bool bPaintMarginOnly( !bPaintCompleteBack &&
3600*b1cdbd2cSJim Jagielski Prt().SSize() != Frm().SSize() );
3601*b1cdbd2cSJim Jagielski
3602*b1cdbd2cSJim Jagielski // --> OD 2005-06-08 #i47804# - paint background of parent fly frame
3603*b1cdbd2cSJim Jagielski // for transparent graphics in layer Hell, if parent fly frame isn't
3604*b1cdbd2cSJim Jagielski // in layer Hell. It's only painted the intersection between the
3605*b1cdbd2cSJim Jagielski // parent fly frame area and the paint area <aRect>
3606*b1cdbd2cSJim Jagielski const IDocumentDrawModelAccess* pIDDMA = GetFmt()->getIDocumentDrawModelAccess();
3607*b1cdbd2cSJim Jagielski
3608*b1cdbd2cSJim Jagielski if ( bIsGraphicTransparent &&
3609*b1cdbd2cSJim Jagielski GetVirtDrawObj()->GetLayer() == pIDDMA->GetHellId() &&
3610*b1cdbd2cSJim Jagielski GetAnchorFrm()->FindFlyFrm() )
3611*b1cdbd2cSJim Jagielski {
3612*b1cdbd2cSJim Jagielski const SwFlyFrm* pParentFlyFrm = GetAnchorFrm()->FindFlyFrm();
3613*b1cdbd2cSJim Jagielski if ( pParentFlyFrm->GetDrawObj()->GetLayer() !=
3614*b1cdbd2cSJim Jagielski pIDDMA->GetHellId() )
3615*b1cdbd2cSJim Jagielski {
3616*b1cdbd2cSJim Jagielski SwFlyFrm* pOldRet = pRetoucheFly2;
3617*b1cdbd2cSJim Jagielski pRetoucheFly2 = const_cast<SwFlyFrm*>(this);
3618*b1cdbd2cSJim Jagielski
3619*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), pParentFlyFrm );
3620*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
3621*b1cdbd2cSJim Jagielski SwRect aPaintRect( aRect );
3622*b1cdbd2cSJim Jagielski aPaintRect._Intersection( pParentFlyFrm->Frm() );
3623*b1cdbd2cSJim Jagielski pParentFlyFrm->PaintBackground( aPaintRect, pPage, rAttrs, sal_False, sal_False );
3624*b1cdbd2cSJim Jagielski
3625*b1cdbd2cSJim Jagielski pRetoucheFly2 = pOldRet;
3626*b1cdbd2cSJim Jagielski }
3627*b1cdbd2cSJim Jagielski }
3628*b1cdbd2cSJim Jagielski
3629*b1cdbd2cSJim Jagielski if ( bPaintCompleteBack || bPaintMarginOnly )
3630*b1cdbd2cSJim Jagielski {
3631*b1cdbd2cSJim Jagielski //#24926# JP 01.02.96, PaintBaBo in teilen hier, damit PaintBorder
3632*b1cdbd2cSJim Jagielski //das orig. Rect bekommt, aber PaintBackground das begrenzte.
3633*b1cdbd2cSJim Jagielski
3634*b1cdbd2cSJim Jagielski // OD 2004-04-23 #116347#
3635*b1cdbd2cSJim Jagielski pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
3636*b1cdbd2cSJim Jagielski pOut->SetLineColor();
3637*b1cdbd2cSJim Jagielski
3638*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
3639*b1cdbd2cSJim Jagielski
3640*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)this );
3641*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
3642*b1cdbd2cSJim Jagielski
3643*b1cdbd2cSJim Jagielski // OD 06.08.2002 #99657# - paint border before painting background
3644*b1cdbd2cSJim Jagielski // paint border
3645*b1cdbd2cSJim Jagielski {
3646*b1cdbd2cSJim Jagielski SwRect aTmp( rRect );
3647*b1cdbd2cSJim Jagielski PaintBorder( aTmp, pPage, rAttrs );
3648*b1cdbd2cSJim Jagielski }
3649*b1cdbd2cSJim Jagielski
3650*b1cdbd2cSJim Jagielski // paint background
3651*b1cdbd2cSJim Jagielski {
3652*b1cdbd2cSJim Jagielski SwRegionRects aRegion( aRect );
3653*b1cdbd2cSJim Jagielski // --> OD 2007-12-13 #i80822#
3654*b1cdbd2cSJim Jagielski // suppress painting of background in printing area for
3655*b1cdbd2cSJim Jagielski // non-transparent graphics.
3656*b1cdbd2cSJim Jagielski // if ( bPaintMarginOnly )
3657*b1cdbd2cSJim Jagielski if ( bPaintMarginOnly ||
3658*b1cdbd2cSJim Jagielski ( pNoTxt && !bIsGraphicTransparent ) )
3659*b1cdbd2cSJim Jagielski // <--
3660*b1cdbd2cSJim Jagielski {
3661*b1cdbd2cSJim Jagielski //Was wir eigentlich Painten wollen ist der schmale Streifen
3662*b1cdbd2cSJim Jagielski //zwischen PrtArea und aeusserer Umrandung.
3663*b1cdbd2cSJim Jagielski SwRect aTmp( Prt() ); aTmp += Frm().Pos();
3664*b1cdbd2cSJim Jagielski aRegion -= aTmp;
3665*b1cdbd2cSJim Jagielski }
3666*b1cdbd2cSJim Jagielski if ( bContour )
3667*b1cdbd2cSJim Jagielski {
3668*b1cdbd2cSJim Jagielski pOut->Push();
3669*b1cdbd2cSJim Jagielski // --> OD 2007-12-13 #i80822#
3670*b1cdbd2cSJim Jagielski // apply clip region under the same conditions, which are
3671*b1cdbd2cSJim Jagielski // used in <SwNoTxtFrm::Paint(..)> to set the clip region
3672*b1cdbd2cSJim Jagielski // for painting the graphic/OLE. Thus, the clip region is
3673*b1cdbd2cSJim Jagielski // also applied for the PDF export.
3674*b1cdbd2cSJim Jagielski // if ( !pOut->GetConnectMetaFile() || pOut->GetOutDevType() == OUTDEV_PRINTER )
3675*b1cdbd2cSJim Jagielski ViewShell *pSh = getRootFrm()->GetCurrShell();
3676*b1cdbd2cSJim Jagielski if ( !pOut->GetConnectMetaFile() || !pSh || !pSh->GetWin() )
3677*b1cdbd2cSJim Jagielski // <--
3678*b1cdbd2cSJim Jagielski {
3679*b1cdbd2cSJim Jagielski pOut->SetClipRegion( aPoly );
3680*b1cdbd2cSJim Jagielski }
3681*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
3682*b1cdbd2cSJim Jagielski PaintBackground( aRegion[i], pPage, rAttrs, sal_False, sal_True );
3683*b1cdbd2cSJim Jagielski pOut->Pop();
3684*b1cdbd2cSJim Jagielski }
3685*b1cdbd2cSJim Jagielski else
3686*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
3687*b1cdbd2cSJim Jagielski PaintBackground( aRegion[i], pPage, rAttrs, sal_False, sal_True );
3688*b1cdbd2cSJim Jagielski }
3689*b1cdbd2cSJim Jagielski
3690*b1cdbd2cSJim Jagielski pOut->Pop();
3691*b1cdbd2cSJim Jagielski }
3692*b1cdbd2cSJim Jagielski }
3693*b1cdbd2cSJim Jagielski
3694*b1cdbd2cSJim Jagielski // OD 19.12.2002 #106318# - fly frame will paint it's subsidiary lines and
3695*b1cdbd2cSJim Jagielski // the subsidiary lines of its lowers on its own, due to overlapping with
3696*b1cdbd2cSJim Jagielski // other fly frames or other objects.
3697*b1cdbd2cSJim Jagielski if( pGlobalShell->GetWin()
3698*b1cdbd2cSJim Jagielski && !bIsChart ) //#i102950# don't paint additional borders for charts
3699*b1cdbd2cSJim Jagielski {
3700*b1cdbd2cSJim Jagielski bool bSubsLineRectsCreated;
3701*b1cdbd2cSJim Jagielski if ( pSubsLines )
3702*b1cdbd2cSJim Jagielski {
3703*b1cdbd2cSJim Jagielski // Lock already existing subsidiary lines
3704*b1cdbd2cSJim Jagielski pSubsLines->LockLines( sal_True );
3705*b1cdbd2cSJim Jagielski bSubsLineRectsCreated = false;
3706*b1cdbd2cSJim Jagielski }
3707*b1cdbd2cSJim Jagielski else
3708*b1cdbd2cSJim Jagielski {
3709*b1cdbd2cSJim Jagielski // create new subsidiardy lines
3710*b1cdbd2cSJim Jagielski pSubsLines = new SwSubsRects;
3711*b1cdbd2cSJim Jagielski bSubsLineRectsCreated = true;
3712*b1cdbd2cSJim Jagielski }
3713*b1cdbd2cSJim Jagielski
3714*b1cdbd2cSJim Jagielski bool bSpecSubsLineRectsCreated;
3715*b1cdbd2cSJim Jagielski if ( pSpecSubsLines )
3716*b1cdbd2cSJim Jagielski {
3717*b1cdbd2cSJim Jagielski // Lock already existing special subsidiary lines
3718*b1cdbd2cSJim Jagielski pSpecSubsLines->LockLines( sal_True );
3719*b1cdbd2cSJim Jagielski bSpecSubsLineRectsCreated = false;
3720*b1cdbd2cSJim Jagielski }
3721*b1cdbd2cSJim Jagielski else
3722*b1cdbd2cSJim Jagielski {
3723*b1cdbd2cSJim Jagielski // create new special subsidiardy lines
3724*b1cdbd2cSJim Jagielski pSpecSubsLines = new SwSubsRects;
3725*b1cdbd2cSJim Jagielski bSpecSubsLineRectsCreated = true;
3726*b1cdbd2cSJim Jagielski }
3727*b1cdbd2cSJim Jagielski // Add subsidiary lines of fly frame and its lowers
3728*b1cdbd2cSJim Jagielski RefreshLaySubsidiary( pPage, aRect );
3729*b1cdbd2cSJim Jagielski // paint subsidiary lines of fly frame and its lowers
3730*b1cdbd2cSJim Jagielski pSpecSubsLines->PaintSubsidiary( pOut, NULL );
3731*b1cdbd2cSJim Jagielski pSubsLines->PaintSubsidiary( pOut, pLines );
3732*b1cdbd2cSJim Jagielski if ( !bSubsLineRectsCreated )
3733*b1cdbd2cSJim Jagielski // unlock subsidiary lines
3734*b1cdbd2cSJim Jagielski pSubsLines->LockLines( sal_False );
3735*b1cdbd2cSJim Jagielski else
3736*b1cdbd2cSJim Jagielski // delete created subsidiary lines container
3737*b1cdbd2cSJim Jagielski DELETEZ( pSubsLines );
3738*b1cdbd2cSJim Jagielski
3739*b1cdbd2cSJim Jagielski if ( !bSpecSubsLineRectsCreated )
3740*b1cdbd2cSJim Jagielski // unlock special subsidiary lines
3741*b1cdbd2cSJim Jagielski pSpecSubsLines->LockLines( sal_False );
3742*b1cdbd2cSJim Jagielski else
3743*b1cdbd2cSJim Jagielski {
3744*b1cdbd2cSJim Jagielski // delete created special subsidiary lines container
3745*b1cdbd2cSJim Jagielski DELETEZ( pSpecSubsLines );
3746*b1cdbd2cSJim Jagielski }
3747*b1cdbd2cSJim Jagielski }
3748*b1cdbd2cSJim Jagielski
3749*b1cdbd2cSJim Jagielski SwLayoutFrm::Paint( aRect );
3750*b1cdbd2cSJim Jagielski
3751*b1cdbd2cSJim Jagielski Validate();
3752*b1cdbd2cSJim Jagielski
3753*b1cdbd2cSJim Jagielski // OD 19.12.2002 #106318# - first paint lines added by fly frame paint
3754*b1cdbd2cSJim Jagielski // and then unlock other lines.
3755*b1cdbd2cSJim Jagielski pLines->PaintLines( pOut );
3756*b1cdbd2cSJim Jagielski pLines->LockLines( sal_False );
3757*b1cdbd2cSJim Jagielski
3758*b1cdbd2cSJim Jagielski pOut->Pop();
3759*b1cdbd2cSJim Jagielski
3760*b1cdbd2cSJim Jagielski if ( pProgress && pNoTxt )
3761*b1cdbd2cSJim Jagielski pProgress->Reschedule();
3762*b1cdbd2cSJim Jagielski }
3763*b1cdbd2cSJim Jagielski /*************************************************************************
3764*b1cdbd2cSJim Jagielski |*
3765*b1cdbd2cSJim Jagielski |* SwTabFrm::Paint()
3766*b1cdbd2cSJim Jagielski |*
3767*b1cdbd2cSJim Jagielski |* Ersterstellung MA 11. May. 93
3768*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 23. Mar. 95
3769*b1cdbd2cSJim Jagielski |*
3770*b1cdbd2cSJim Jagielski |*************************************************************************/
3771*b1cdbd2cSJim Jagielski
Paint(SwRect const & rRect,SwPrintData const * const) const3772*b1cdbd2cSJim Jagielski void SwTabFrm::Paint(SwRect const& rRect, SwPrintData const*const) const
3773*b1cdbd2cSJim Jagielski {
3774*b1cdbd2cSJim Jagielski if ( pGlobalShell->GetViewOptions()->IsTable() )
3775*b1cdbd2cSJim Jagielski {
3776*b1cdbd2cSJim Jagielski // --> collapsing borders FME 2005-05-27 #i29550#
3777*b1cdbd2cSJim Jagielski if ( IsCollapsingBorders() )
3778*b1cdbd2cSJim Jagielski {
3779*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)this );
3780*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
3781*b1cdbd2cSJim Jagielski
3782*b1cdbd2cSJim Jagielski // paint shadow
3783*b1cdbd2cSJim Jagielski if ( rAttrs.GetShadow().GetLocation() != SVX_SHADOW_NONE )
3784*b1cdbd2cSJim Jagielski {
3785*b1cdbd2cSJim Jagielski SwRect aRect;
3786*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( aRect, this, rAttrs, sal_True );
3787*b1cdbd2cSJim Jagielski PaintShadow( rRect, aRect, rAttrs );
3788*b1cdbd2cSJim Jagielski }
3789*b1cdbd2cSJim Jagielski
3790*b1cdbd2cSJim Jagielski // paint lines
3791*b1cdbd2cSJim Jagielski SwTabFrmPainter aHelper( *this );
3792*b1cdbd2cSJim Jagielski aHelper.PaintLines( *pGlobalShell->GetOut(), rRect );
3793*b1cdbd2cSJim Jagielski }
3794*b1cdbd2cSJim Jagielski // <-- collapsing
3795*b1cdbd2cSJim Jagielski
3796*b1cdbd2cSJim Jagielski SwLayoutFrm::Paint( rRect );
3797*b1cdbd2cSJim Jagielski }
3798*b1cdbd2cSJim Jagielski // OD 10.01.2003 #i6467# - no light grey rectangle for page preview
3799*b1cdbd2cSJim Jagielski else if ( pGlobalShell->GetWin() && !pGlobalShell->IsPreView() )
3800*b1cdbd2cSJim Jagielski {
3801*b1cdbd2cSJim Jagielski // OD 10.01.2003 #i6467# - intersect output rectangle with table frame
3802*b1cdbd2cSJim Jagielski SwRect aTabRect( Prt() );
3803*b1cdbd2cSJim Jagielski aTabRect.Pos() += Frm().Pos();
3804*b1cdbd2cSJim Jagielski SwRect aTabOutRect( rRect );
3805*b1cdbd2cSJim Jagielski aTabOutRect.Intersection( aTabRect );
3806*b1cdbd2cSJim Jagielski pGlobalShell->GetViewOptions()->
3807*b1cdbd2cSJim Jagielski DrawRect( pGlobalShell->GetOut(), aTabOutRect, COL_LIGHTGRAY );
3808*b1cdbd2cSJim Jagielski }
3809*b1cdbd2cSJim Jagielski ((SwTabFrm*)this)->ResetComplete();
3810*b1cdbd2cSJim Jagielski }
3811*b1cdbd2cSJim Jagielski
3812*b1cdbd2cSJim Jagielski /*************************************************************************
3813*b1cdbd2cSJim Jagielski |*
3814*b1cdbd2cSJim Jagielski |* SwFrm::PaintShadow()
3815*b1cdbd2cSJim Jagielski |*
3816*b1cdbd2cSJim Jagielski |* Beschreibung Malt einen Schatten wenns das FrmFormat fordert.
3817*b1cdbd2cSJim Jagielski |* Der Schatten wird immer an den auesseren Rand des OutRect gemalt.
3818*b1cdbd2cSJim Jagielski |* Das OutRect wird ggf. so verkleinert, dass auf diesem das
3819*b1cdbd2cSJim Jagielski |* malen der Umrandung stattfinden kann.
3820*b1cdbd2cSJim Jagielski |* Ersterstellung MA 21. Dec. 92
3821*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 29. May. 97
3822*b1cdbd2cSJim Jagielski |*
3823*b1cdbd2cSJim Jagielski |*************************************************************************/
3824*b1cdbd2cSJim Jagielski /// OD 23.08.2002 #99657#
3825*b1cdbd2cSJim Jagielski /// draw full shadow rectangle for frames with transparent drawn backgrounds.
PaintShadow(const SwRect & rRect,SwRect & rOutRect,const SwBorderAttrs & rAttrs) const3826*b1cdbd2cSJim Jagielski void SwFrm::PaintShadow( const SwRect& rRect, SwRect& rOutRect,
3827*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs ) const
3828*b1cdbd2cSJim Jagielski {
3829*b1cdbd2cSJim Jagielski const SvxShadowItem &rShadow = rAttrs.GetShadow();
3830*b1cdbd2cSJim Jagielski const long nWidth = ::lcl_AlignWidth ( rShadow.GetWidth() );
3831*b1cdbd2cSJim Jagielski const long nHeight = ::lcl_AlignHeight( rShadow.GetWidth() );
3832*b1cdbd2cSJim Jagielski
3833*b1cdbd2cSJim Jagielski SwRects aRegion( 2, 2 );
3834*b1cdbd2cSJim Jagielski SwRect aOut( rOutRect );
3835*b1cdbd2cSJim Jagielski
3836*b1cdbd2cSJim Jagielski const sal_Bool bCnt = IsCntntFrm();
3837*b1cdbd2cSJim Jagielski const sal_Bool bTop = !bCnt || rAttrs.GetTopLine ( *(this) ) ? sal_True : sal_False;
3838*b1cdbd2cSJim Jagielski const sal_Bool bBottom = !bCnt || rAttrs.GetBottomLine( *(this) ) ? sal_True : sal_False;
3839*b1cdbd2cSJim Jagielski
3840*b1cdbd2cSJim Jagielski SvxShadowLocation eLoc = rShadow.GetLocation();
3841*b1cdbd2cSJim Jagielski
3842*b1cdbd2cSJim Jagielski SWRECTFN( this )
3843*b1cdbd2cSJim Jagielski if( IsVertical() )
3844*b1cdbd2cSJim Jagielski {
3845*b1cdbd2cSJim Jagielski switch( eLoc )
3846*b1cdbd2cSJim Jagielski {
3847*b1cdbd2cSJim Jagielski case SVX_SHADOW_BOTTOMRIGHT: eLoc = SVX_SHADOW_BOTTOMLEFT; break;
3848*b1cdbd2cSJim Jagielski case SVX_SHADOW_TOPLEFT: eLoc = SVX_SHADOW_TOPRIGHT; break;
3849*b1cdbd2cSJim Jagielski case SVX_SHADOW_TOPRIGHT: eLoc = SVX_SHADOW_BOTTOMRIGHT; break;
3850*b1cdbd2cSJim Jagielski case SVX_SHADOW_BOTTOMLEFT: eLoc = SVX_SHADOW_TOPLEFT; break;
3851*b1cdbd2cSJim Jagielski default: break;
3852*b1cdbd2cSJim Jagielski }
3853*b1cdbd2cSJim Jagielski }
3854*b1cdbd2cSJim Jagielski
3855*b1cdbd2cSJim Jagielski /// OD 23.08.2002 #99657# - determine, if full shadow rectangle have to
3856*b1cdbd2cSJim Jagielski /// be drawn or only two shadow rectangles beside the frame.
3857*b1cdbd2cSJim Jagielski /// draw full shadow rectangle, if frame background is drawn transparent.
3858*b1cdbd2cSJim Jagielski /// Status Quo:
3859*b1cdbd2cSJim Jagielski /// SwLayoutFrm can have transparent drawn backgrounds. Thus,
3860*b1cdbd2cSJim Jagielski /// "asked" their frame format.
3861*b1cdbd2cSJim Jagielski sal_Bool bDrawFullShadowRectangle =
3862*b1cdbd2cSJim Jagielski ( IsLayoutFrm() &&
3863*b1cdbd2cSJim Jagielski (static_cast<const SwLayoutFrm*>(this))->GetFmt()->IsBackgroundTransparent()
3864*b1cdbd2cSJim Jagielski );
3865*b1cdbd2cSJim Jagielski switch ( eLoc )
3866*b1cdbd2cSJim Jagielski {
3867*b1cdbd2cSJim Jagielski case SVX_SHADOW_BOTTOMRIGHT:
3868*b1cdbd2cSJim Jagielski {
3869*b1cdbd2cSJim Jagielski if ( bDrawFullShadowRectangle )
3870*b1cdbd2cSJim Jagielski {
3871*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - draw full shadow rectangle
3872*b1cdbd2cSJim Jagielski aOut.Top( aOut.Top() + nHeight );
3873*b1cdbd2cSJim Jagielski aOut.Left( aOut.Left() + nWidth );
3874*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3875*b1cdbd2cSJim Jagielski }
3876*b1cdbd2cSJim Jagielski else
3877*b1cdbd2cSJim Jagielski {
3878*b1cdbd2cSJim Jagielski aOut.Top ( aOut.Bottom() - nHeight );
3879*b1cdbd2cSJim Jagielski aOut.Left( aOut.Left() + nWidth );
3880*b1cdbd2cSJim Jagielski if ( bBottom )
3881*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3882*b1cdbd2cSJim Jagielski aOut.Left( aOut.Right() - nWidth );
3883*b1cdbd2cSJim Jagielski aOut.Top ( rOutRect.Top() + nHeight );
3884*b1cdbd2cSJim Jagielski if ( bBottom )
3885*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Bottom() - nHeight );
3886*b1cdbd2cSJim Jagielski if ( bCnt && (!bTop || !bBottom) )
3887*b1cdbd2cSJim Jagielski ::lcl_ExtendLeftAndRight( aOut, *(this), rAttrs, fnRect );
3888*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3889*b1cdbd2cSJim Jagielski }
3890*b1cdbd2cSJim Jagielski
3891*b1cdbd2cSJim Jagielski rOutRect.Right ( rOutRect.Right() - nWidth );
3892*b1cdbd2cSJim Jagielski rOutRect.Bottom( rOutRect.Bottom()- nHeight );
3893*b1cdbd2cSJim Jagielski }
3894*b1cdbd2cSJim Jagielski break;
3895*b1cdbd2cSJim Jagielski case SVX_SHADOW_TOPLEFT:
3896*b1cdbd2cSJim Jagielski {
3897*b1cdbd2cSJim Jagielski if ( bDrawFullShadowRectangle )
3898*b1cdbd2cSJim Jagielski {
3899*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - draw full shadow rectangle
3900*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Bottom() - nHeight );
3901*b1cdbd2cSJim Jagielski aOut.Right( aOut.Right() - nWidth );
3902*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3903*b1cdbd2cSJim Jagielski }
3904*b1cdbd2cSJim Jagielski else
3905*b1cdbd2cSJim Jagielski {
3906*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Top() + nHeight );
3907*b1cdbd2cSJim Jagielski aOut.Right ( aOut.Right() - nWidth );
3908*b1cdbd2cSJim Jagielski if ( bTop )
3909*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3910*b1cdbd2cSJim Jagielski aOut.Right ( aOut.Left() + nWidth );
3911*b1cdbd2cSJim Jagielski aOut.Bottom( rOutRect.Bottom() - nHeight );
3912*b1cdbd2cSJim Jagielski if ( bTop )
3913*b1cdbd2cSJim Jagielski aOut.Top( aOut.Top() + nHeight );
3914*b1cdbd2cSJim Jagielski if ( bCnt && (!bBottom || !bTop) )
3915*b1cdbd2cSJim Jagielski ::lcl_ExtendLeftAndRight( aOut, *(this), rAttrs, fnRect );
3916*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3917*b1cdbd2cSJim Jagielski }
3918*b1cdbd2cSJim Jagielski
3919*b1cdbd2cSJim Jagielski rOutRect.Left( rOutRect.Left() + nWidth );
3920*b1cdbd2cSJim Jagielski rOutRect.Top( rOutRect.Top() + nHeight );
3921*b1cdbd2cSJim Jagielski }
3922*b1cdbd2cSJim Jagielski break;
3923*b1cdbd2cSJim Jagielski case SVX_SHADOW_TOPRIGHT:
3924*b1cdbd2cSJim Jagielski {
3925*b1cdbd2cSJim Jagielski if ( bDrawFullShadowRectangle )
3926*b1cdbd2cSJim Jagielski {
3927*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - draw full shadow rectangle
3928*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Bottom() - nHeight);
3929*b1cdbd2cSJim Jagielski aOut.Left( aOut.Left() + nWidth );
3930*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3931*b1cdbd2cSJim Jagielski }
3932*b1cdbd2cSJim Jagielski else
3933*b1cdbd2cSJim Jagielski {
3934*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Top() + nHeight );
3935*b1cdbd2cSJim Jagielski aOut.Left ( aOut.Left()+ nWidth );
3936*b1cdbd2cSJim Jagielski if ( bTop )
3937*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3938*b1cdbd2cSJim Jagielski aOut.Left ( aOut.Right() - nWidth );
3939*b1cdbd2cSJim Jagielski aOut.Bottom( rOutRect.Bottom() - nHeight );
3940*b1cdbd2cSJim Jagielski if ( bTop )
3941*b1cdbd2cSJim Jagielski aOut.Top( aOut.Top() + nHeight );
3942*b1cdbd2cSJim Jagielski if ( bCnt && (!bBottom || bTop) )
3943*b1cdbd2cSJim Jagielski ::lcl_ExtendLeftAndRight( aOut, *(this), rAttrs, fnRect );
3944*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3945*b1cdbd2cSJim Jagielski }
3946*b1cdbd2cSJim Jagielski
3947*b1cdbd2cSJim Jagielski rOutRect.Right( rOutRect.Right() - nWidth );
3948*b1cdbd2cSJim Jagielski rOutRect.Top( rOutRect.Top() + nHeight );
3949*b1cdbd2cSJim Jagielski }
3950*b1cdbd2cSJim Jagielski break;
3951*b1cdbd2cSJim Jagielski case SVX_SHADOW_BOTTOMLEFT:
3952*b1cdbd2cSJim Jagielski {
3953*b1cdbd2cSJim Jagielski if ( bDrawFullShadowRectangle )
3954*b1cdbd2cSJim Jagielski {
3955*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - draw full shadow rectangle
3956*b1cdbd2cSJim Jagielski aOut.Top( aOut.Top() + nHeight );
3957*b1cdbd2cSJim Jagielski aOut.Right( aOut.Right() - nWidth );
3958*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3959*b1cdbd2cSJim Jagielski }
3960*b1cdbd2cSJim Jagielski else
3961*b1cdbd2cSJim Jagielski {
3962*b1cdbd2cSJim Jagielski aOut.Top ( aOut.Bottom()- nHeight );
3963*b1cdbd2cSJim Jagielski aOut.Right( aOut.Right() - nWidth );
3964*b1cdbd2cSJim Jagielski if ( bBottom )
3965*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3966*b1cdbd2cSJim Jagielski aOut.Right( aOut.Left() + nWidth );
3967*b1cdbd2cSJim Jagielski aOut.Top( rOutRect.Top() + nHeight );
3968*b1cdbd2cSJim Jagielski if ( bBottom )
3969*b1cdbd2cSJim Jagielski aOut.Bottom( aOut.Bottom() - nHeight );
3970*b1cdbd2cSJim Jagielski if ( bCnt && (!bTop || !bBottom) )
3971*b1cdbd2cSJim Jagielski ::lcl_ExtendLeftAndRight( aOut, *(this), rAttrs, fnRect );
3972*b1cdbd2cSJim Jagielski aRegion.Insert( aOut, aRegion.Count() );
3973*b1cdbd2cSJim Jagielski }
3974*b1cdbd2cSJim Jagielski
3975*b1cdbd2cSJim Jagielski rOutRect.Left( rOutRect.Left() + nWidth );
3976*b1cdbd2cSJim Jagielski rOutRect.Bottom( rOutRect.Bottom() - nHeight );
3977*b1cdbd2cSJim Jagielski }
3978*b1cdbd2cSJim Jagielski break;
3979*b1cdbd2cSJim Jagielski default:
3980*b1cdbd2cSJim Jagielski ASSERT( !this, "new ShadowLocation() ?" )
3981*b1cdbd2cSJim Jagielski break;
3982*b1cdbd2cSJim Jagielski }
3983*b1cdbd2cSJim Jagielski
3984*b1cdbd2cSJim Jagielski OutputDevice *pOut = pGlobalShell->GetOut();
3985*b1cdbd2cSJim Jagielski
3986*b1cdbd2cSJim Jagielski sal_uLong nOldDrawMode = pOut->GetDrawMode();
3987*b1cdbd2cSJim Jagielski Color aShadowColor( rShadow.GetColor() );
3988*b1cdbd2cSJim Jagielski if( aRegion.Count() && pGlobalShell->GetWin() &&
3989*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
3990*b1cdbd2cSJim Jagielski {
3991*b1cdbd2cSJim Jagielski // Is heigh contrast mode, the output device has already set the
3992*b1cdbd2cSJim Jagielski // DRAWMODE_SETTINGSFILL flag. This causes the SetFillColor function
3993*b1cdbd2cSJim Jagielski // to ignore the setting of a new color. Therefore we have to reset
3994*b1cdbd2cSJim Jagielski // the drawing mode
3995*b1cdbd2cSJim Jagielski pOut->SetDrawMode( 0 );
3996*b1cdbd2cSJim Jagielski aShadowColor = SwViewOption::GetFontColor();
3997*b1cdbd2cSJim Jagielski }
3998*b1cdbd2cSJim Jagielski
3999*b1cdbd2cSJim Jagielski if ( pOut->GetFillColor() != aShadowColor )
4000*b1cdbd2cSJim Jagielski pOut->SetFillColor( aShadowColor );
4001*b1cdbd2cSJim Jagielski
4002*b1cdbd2cSJim Jagielski pOut->SetDrawMode( nOldDrawMode );
4003*b1cdbd2cSJim Jagielski
4004*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
4005*b1cdbd2cSJim Jagielski {
4006*b1cdbd2cSJim Jagielski SwRect &rOut = aRegion[i];
4007*b1cdbd2cSJim Jagielski aOut = rOut;
4008*b1cdbd2cSJim Jagielski // OD 30.09.2002 #103636# - no SwAlign of shadow rectangle
4009*b1cdbd2cSJim Jagielski // no alignment necessary, because (1) <rRect> is already aligned
4010*b1cdbd2cSJim Jagielski // and because (2) paint of border and background will occur later.
4011*b1cdbd2cSJim Jagielski // Thus, (1) assures that no conflicts with neighbour object will occure
4012*b1cdbd2cSJim Jagielski // and (2) assures that border and background is not affected by the
4013*b1cdbd2cSJim Jagielski // shadow paint.
4014*b1cdbd2cSJim Jagielski /*
4015*b1cdbd2cSJim Jagielski ::SwAlignRect( aOut, pGlobalShell );
4016*b1cdbd2cSJim Jagielski */
4017*b1cdbd2cSJim Jagielski if ( rRect.IsOver( aOut ) && aOut.Height() > 0 && aOut.Width() > 0 )
4018*b1cdbd2cSJim Jagielski {
4019*b1cdbd2cSJim Jagielski aOut._Intersection( rRect );
4020*b1cdbd2cSJim Jagielski pOut->DrawRect( aOut.SVRect() );
4021*b1cdbd2cSJim Jagielski }
4022*b1cdbd2cSJim Jagielski }
4023*b1cdbd2cSJim Jagielski }
4024*b1cdbd2cSJim Jagielski
4025*b1cdbd2cSJim Jagielski /*************************************************************************
4026*b1cdbd2cSJim Jagielski |*
4027*b1cdbd2cSJim Jagielski |* SwFrm::PaintBorderLine()
4028*b1cdbd2cSJim Jagielski |*
4029*b1cdbd2cSJim Jagielski |* Ersterstellung MA 22. Dec. 92
4030*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 22. Jan. 95
4031*b1cdbd2cSJim Jagielski |*
4032*b1cdbd2cSJim Jagielski |*************************************************************************/
4033*b1cdbd2cSJim Jagielski
PaintBorderLine(const SwRect & rRect,const SwRect & rOutRect,const SwPageFrm * pPage,const Color * pColor) const4034*b1cdbd2cSJim Jagielski void SwFrm::PaintBorderLine( const SwRect& rRect,
4035*b1cdbd2cSJim Jagielski const SwRect& rOutRect,
4036*b1cdbd2cSJim Jagielski const SwPageFrm *pPage,
4037*b1cdbd2cSJim Jagielski const Color *pColor ) const
4038*b1cdbd2cSJim Jagielski {
4039*b1cdbd2cSJim Jagielski if ( !rOutRect.IsOver( rRect ) )
4040*b1cdbd2cSJim Jagielski return;
4041*b1cdbd2cSJim Jagielski
4042*b1cdbd2cSJim Jagielski SwRect aOut( rOutRect );
4043*b1cdbd2cSJim Jagielski aOut._Intersection( rRect );
4044*b1cdbd2cSJim Jagielski
4045*b1cdbd2cSJim Jagielski const SwTabFrm *pTab = IsCellFrm() ? FindTabFrm() : 0;
4046*b1cdbd2cSJim Jagielski sal_uInt8 nSubCol = ( IsCellFrm() || IsRowFrm() ) ? SUBCOL_TAB :
4047*b1cdbd2cSJim Jagielski ( IsInSct() ? SUBCOL_SECT :
4048*b1cdbd2cSJim Jagielski ( IsInFly() ? SUBCOL_FLY : SUBCOL_PAGE ) );
4049*b1cdbd2cSJim Jagielski if( pColor && pGlobalShell->GetWin() &&
4050*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
4051*b1cdbd2cSJim Jagielski {
4052*b1cdbd2cSJim Jagielski pColor = &SwViewOption::GetFontColor();
4053*b1cdbd2cSJim Jagielski }
4054*b1cdbd2cSJim Jagielski
4055*b1cdbd2cSJim Jagielski if ( pPage->GetSortedObjs() )
4056*b1cdbd2cSJim Jagielski {
4057*b1cdbd2cSJim Jagielski SwRegionRects aRegion( aOut, 4, 1 );
4058*b1cdbd2cSJim Jagielski ::lcl_SubtractFlys( this, pPage, aOut, aRegion );
4059*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
4060*b1cdbd2cSJim Jagielski pLines->AddLineRect( aRegion[i], pColor, pTab, nSubCol );
4061*b1cdbd2cSJim Jagielski }
4062*b1cdbd2cSJim Jagielski else
4063*b1cdbd2cSJim Jagielski pLines->AddLineRect( aOut, pColor, pTab, nSubCol );
4064*b1cdbd2cSJim Jagielski }
4065*b1cdbd2cSJim Jagielski
4066*b1cdbd2cSJim Jagielski /*************************************************************************
4067*b1cdbd2cSJim Jagielski |*
4068*b1cdbd2cSJim Jagielski |* SwFrm::PaintBorderLines()
4069*b1cdbd2cSJim Jagielski |*
4070*b1cdbd2cSJim Jagielski |* Beschreibung Nur alle Linien einfach oder alle Linien doppelt!!!!
4071*b1cdbd2cSJim Jagielski |* Ersterstellung MA 22. Dec. 92
4072*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 22. Mar. 95
4073*b1cdbd2cSJim Jagielski |*
4074*b1cdbd2cSJim Jagielski |*************************************************************************/
4075*b1cdbd2cSJim Jagielski
4076*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - method called for left and right border rectangles.
4077*b1cdbd2cSJim Jagielski // For a printer output device perform adjustment for non-overlapping top and
4078*b1cdbd2cSJim Jagielski // bottom border rectangles. Thus, add parameter <_bPrtOutputDev> to indicate
4079*b1cdbd2cSJim Jagielski // printer output device.
4080*b1cdbd2cSJim Jagielski // NOTE: For printer output device left/right border rectangle <_iorRect>
4081*b1cdbd2cSJim Jagielski // has to be already non-overlapping the outer top/bottom border rectangle.
lcl_SubTopBottom(SwRect & _iorRect,const SvxBoxItem & _rBox,const SwBorderAttrs & _rAttrs,const SwFrm & _rFrm,const SwRectFn & _rRectFn,const sal_Bool _bPrtOutputDev)4082*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_SubTopBottom( SwRect& _iorRect,
4083*b1cdbd2cSJim Jagielski const SvxBoxItem& _rBox,
4084*b1cdbd2cSJim Jagielski const SwBorderAttrs& _rAttrs,
4085*b1cdbd2cSJim Jagielski const SwFrm& _rFrm,
4086*b1cdbd2cSJim Jagielski const SwRectFn& _rRectFn,
4087*b1cdbd2cSJim Jagielski const sal_Bool _bPrtOutputDev )
4088*b1cdbd2cSJim Jagielski {
4089*b1cdbd2cSJim Jagielski const sal_Bool bCnt = _rFrm.IsCntntFrm();
4090*b1cdbd2cSJim Jagielski if ( _rBox.GetTop() && _rBox.GetTop()->GetInWidth() &&
4091*b1cdbd2cSJim Jagielski ( !bCnt || _rAttrs.GetTopLine( _rFrm ) )
4092*b1cdbd2cSJim Jagielski )
4093*b1cdbd2cSJim Jagielski {
4094*b1cdbd2cSJim Jagielski // substract distance between outer and inner line.
4095*b1cdbd2cSJim Jagielski SwTwips nDist = ::lcl_MinHeightDist( _rBox.GetTop()->GetDistance() );
4096*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - non-overlapping border rectangles:
4097*b1cdbd2cSJim Jagielski // adjust x-/y-position, if inner top line is a hair line (width = 1)
4098*b1cdbd2cSJim Jagielski sal_Bool bIsInnerTopLineHairline = sal_False;
4099*b1cdbd2cSJim Jagielski if ( !_bPrtOutputDev )
4100*b1cdbd2cSJim Jagielski {
4101*b1cdbd2cSJim Jagielski // additionally substract width of top outer line
4102*b1cdbd2cSJim Jagielski // --> left/right inner/outer line doesn't overlap top outer line.
4103*b1cdbd2cSJim Jagielski nDist += ::lcl_AlignHeight( _rBox.GetTop()->GetOutWidth() );
4104*b1cdbd2cSJim Jagielski }
4105*b1cdbd2cSJim Jagielski else
4106*b1cdbd2cSJim Jagielski {
4107*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - additionally substract width of top inner line
4108*b1cdbd2cSJim Jagielski // --> left/right inner/outer line doesn't overlap top inner line.
4109*b1cdbd2cSJim Jagielski nDist += ::lcl_AlignHeight( _rBox.GetTop()->GetInWidth() );
4110*b1cdbd2cSJim Jagielski bIsInnerTopLineHairline = _rBox.GetTop()->GetInWidth() == 1;
4111*b1cdbd2cSJim Jagielski }
4112*b1cdbd2cSJim Jagielski (_iorRect.*_rRectFn->fnSubTop)( -nDist );
4113*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - adjust calculated border top, if inner top line
4114*b1cdbd2cSJim Jagielski // is a hair line
4115*b1cdbd2cSJim Jagielski if ( bIsInnerTopLineHairline )
4116*b1cdbd2cSJim Jagielski {
4117*b1cdbd2cSJim Jagielski if ( _rFrm.IsVertical() )
4118*b1cdbd2cSJim Jagielski {
4119*b1cdbd2cSJim Jagielski // right of border rectangle has to be checked and adjusted
4120*b1cdbd2cSJim Jagielski Point aCompPt( _iorRect.Right(), 0 );
4121*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X() + 1, aCompPt.Y() );
4122*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4123*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4124*b1cdbd2cSJim Jagielski sal_True, -1 );
4125*b1cdbd2cSJim Jagielski _iorRect.Right( aCompPt.X() );
4126*b1cdbd2cSJim Jagielski }
4127*b1cdbd2cSJim Jagielski else
4128*b1cdbd2cSJim Jagielski {
4129*b1cdbd2cSJim Jagielski // top of border rectangle has to be checked and adjusted
4130*b1cdbd2cSJim Jagielski Point aCompPt( 0, _iorRect.Top() );
4131*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X(), aCompPt.Y() - 1 );
4132*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4133*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4134*b1cdbd2cSJim Jagielski sal_False, +1 );
4135*b1cdbd2cSJim Jagielski _iorRect.Top( aCompPt.Y() );
4136*b1cdbd2cSJim Jagielski }
4137*b1cdbd2cSJim Jagielski }
4138*b1cdbd2cSJim Jagielski }
4139*b1cdbd2cSJim Jagielski
4140*b1cdbd2cSJim Jagielski if ( _rBox.GetBottom() && _rBox.GetBottom()->GetInWidth() &&
4141*b1cdbd2cSJim Jagielski ( !bCnt || _rAttrs.GetBottomLine( _rFrm ) )
4142*b1cdbd2cSJim Jagielski )
4143*b1cdbd2cSJim Jagielski {
4144*b1cdbd2cSJim Jagielski // substract distance between outer and inner line.
4145*b1cdbd2cSJim Jagielski SwTwips nDist = ::lcl_MinHeightDist( _rBox.GetBottom()->GetDistance() );
4146*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - non-overlapping border rectangles:
4147*b1cdbd2cSJim Jagielski // adjust x-/y-position, if inner bottom line is a hair line (width = 1)
4148*b1cdbd2cSJim Jagielski sal_Bool bIsInnerBottomLineHairline = sal_False;
4149*b1cdbd2cSJim Jagielski if ( !_bPrtOutputDev )
4150*b1cdbd2cSJim Jagielski {
4151*b1cdbd2cSJim Jagielski // additionally substract width of bottom outer line
4152*b1cdbd2cSJim Jagielski // --> left/right inner/outer line doesn't overlap bottom outer line.
4153*b1cdbd2cSJim Jagielski nDist += ::lcl_AlignHeight( _rBox.GetBottom()->GetOutWidth() );
4154*b1cdbd2cSJim Jagielski }
4155*b1cdbd2cSJim Jagielski else
4156*b1cdbd2cSJim Jagielski {
4157*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - additionally substract width of bottom inner line
4158*b1cdbd2cSJim Jagielski // --> left/right inner/outer line doesn't overlap bottom inner line.
4159*b1cdbd2cSJim Jagielski nDist += ::lcl_AlignHeight( _rBox.GetBottom()->GetInWidth() );
4160*b1cdbd2cSJim Jagielski bIsInnerBottomLineHairline = _rBox.GetBottom()->GetInWidth() == 1;
4161*b1cdbd2cSJim Jagielski }
4162*b1cdbd2cSJim Jagielski (_iorRect.*_rRectFn->fnAddBottom)( -nDist );
4163*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - adjust calculated border bottom, if inner
4164*b1cdbd2cSJim Jagielski // bottom line is a hair line.
4165*b1cdbd2cSJim Jagielski if ( bIsInnerBottomLineHairline )
4166*b1cdbd2cSJim Jagielski {
4167*b1cdbd2cSJim Jagielski if ( _rFrm.IsVertical() )
4168*b1cdbd2cSJim Jagielski {
4169*b1cdbd2cSJim Jagielski // left of border rectangle has to be checked and adjusted
4170*b1cdbd2cSJim Jagielski Point aCompPt( _iorRect.Left(), 0 );
4171*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X() - 1, aCompPt.Y() );
4172*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4173*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4174*b1cdbd2cSJim Jagielski sal_True, +1 );
4175*b1cdbd2cSJim Jagielski _iorRect.Left( aCompPt.X() );
4176*b1cdbd2cSJim Jagielski }
4177*b1cdbd2cSJim Jagielski else
4178*b1cdbd2cSJim Jagielski {
4179*b1cdbd2cSJim Jagielski // bottom of border rectangle has to be checked and adjusted
4180*b1cdbd2cSJim Jagielski Point aCompPt( 0, _iorRect.Bottom() );
4181*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X(), aCompPt.Y() + 1 );
4182*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4183*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4184*b1cdbd2cSJim Jagielski sal_False, -1 );
4185*b1cdbd2cSJim Jagielski _iorRect.Bottom( aCompPt.Y() );
4186*b1cdbd2cSJim Jagielski }
4187*b1cdbd2cSJim Jagielski }
4188*b1cdbd2cSJim Jagielski }
4189*b1cdbd2cSJim Jagielski }
4190*b1cdbd2cSJim Jagielski
4191*b1cdbd2cSJim Jagielski // method called for top and bottom border rectangles.
lcl_SubLeftRight(SwRect & rRect,const SvxBoxItem & rBox,const SwRectFn & rRectFn)4192*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_SubLeftRight( SwRect& rRect,
4193*b1cdbd2cSJim Jagielski const SvxBoxItem& rBox,
4194*b1cdbd2cSJim Jagielski const SwRectFn& rRectFn )
4195*b1cdbd2cSJim Jagielski {
4196*b1cdbd2cSJim Jagielski if ( rBox.GetLeft() && rBox.GetLeft()->GetInWidth() )
4197*b1cdbd2cSJim Jagielski {
4198*b1cdbd2cSJim Jagielski const long nDist = ::lcl_MinWidthDist( rBox.GetLeft()->GetDistance() )
4199*b1cdbd2cSJim Jagielski + ::lcl_AlignWidth( rBox.GetLeft()->GetOutWidth() );
4200*b1cdbd2cSJim Jagielski (rRect.*rRectFn->fnSubLeft)( -nDist );
4201*b1cdbd2cSJim Jagielski }
4202*b1cdbd2cSJim Jagielski
4203*b1cdbd2cSJim Jagielski if ( rBox.GetRight() && rBox.GetRight()->GetInWidth() )
4204*b1cdbd2cSJim Jagielski {
4205*b1cdbd2cSJim Jagielski const long nDist = ::lcl_MinWidthDist( rBox.GetRight()->GetDistance() )
4206*b1cdbd2cSJim Jagielski + ::lcl_AlignWidth( rBox.GetRight()->GetOutWidth() );
4207*b1cdbd2cSJim Jagielski (rRect.*rRectFn->fnAddRight)( -nDist );
4208*b1cdbd2cSJim Jagielski }
4209*b1cdbd2cSJim Jagielski }
4210*b1cdbd2cSJim Jagielski
4211*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - merge <lcl_PaintLeftLine> and <lcl_PaintRightLine>
4212*b1cdbd2cSJim Jagielski // into new method <lcl_PaintLeftRightLine(..)>
lcl_PaintLeftRightLine(const sal_Bool _bLeft,const SwFrm & _rFrm,const SwPageFrm & _rPage,const SwRect & _rOutRect,const SwRect & _rRect,const SwBorderAttrs & _rAttrs,const SwRectFn & _rRectFn)4213*b1cdbd2cSJim Jagielski void lcl_PaintLeftRightLine( const sal_Bool _bLeft,
4214*b1cdbd2cSJim Jagielski const SwFrm& _rFrm,
4215*b1cdbd2cSJim Jagielski const SwPageFrm& _rPage,
4216*b1cdbd2cSJim Jagielski const SwRect& _rOutRect,
4217*b1cdbd2cSJim Jagielski const SwRect& _rRect,
4218*b1cdbd2cSJim Jagielski const SwBorderAttrs& _rAttrs,
4219*b1cdbd2cSJim Jagielski const SwRectFn& _rRectFn )
4220*b1cdbd2cSJim Jagielski {
4221*b1cdbd2cSJim Jagielski const SvxBoxItem& rBox = _rAttrs.GetBox();
4222*b1cdbd2cSJim Jagielski const sal_Bool bR2L = _rFrm.IsCellFrm() && _rFrm.IsRightToLeft();
4223*b1cdbd2cSJim Jagielski const SvxBorderLine* pLeftRightBorder = 0;
4224*b1cdbd2cSJim Jagielski if ( _bLeft )
4225*b1cdbd2cSJim Jagielski {
4226*b1cdbd2cSJim Jagielski pLeftRightBorder = bR2L ? rBox.GetRight() : rBox.GetLeft();
4227*b1cdbd2cSJim Jagielski }
4228*b1cdbd2cSJim Jagielski else
4229*b1cdbd2cSJim Jagielski {
4230*b1cdbd2cSJim Jagielski pLeftRightBorder = bR2L ? rBox.GetLeft() : rBox.GetRight();
4231*b1cdbd2cSJim Jagielski }
4232*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - init boolean indicating printer output device.
4233*b1cdbd2cSJim Jagielski const sal_Bool bPrtOutputDev =
4234*b1cdbd2cSJim Jagielski ( OUTDEV_PRINTER == pGlobalShell->GetOut()->GetOutDevType() );
4235*b1cdbd2cSJim Jagielski
4236*b1cdbd2cSJim Jagielski if ( !pLeftRightBorder )
4237*b1cdbd2cSJim Jagielski {
4238*b1cdbd2cSJim Jagielski return;
4239*b1cdbd2cSJim Jagielski }
4240*b1cdbd2cSJim Jagielski
4241*b1cdbd2cSJim Jagielski SwRect aRect( _rOutRect );
4242*b1cdbd2cSJim Jagielski if ( _bLeft )
4243*b1cdbd2cSJim Jagielski {
4244*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddRight)( ::lcl_AlignWidth( pLeftRightBorder->GetOutWidth() ) -
4245*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnGetWidth)() );
4246*b1cdbd2cSJim Jagielski }
4247*b1cdbd2cSJim Jagielski else
4248*b1cdbd2cSJim Jagielski {
4249*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubLeft)( ::lcl_AlignWidth( pLeftRightBorder->GetOutWidth() ) -
4250*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnGetWidth)() );
4251*b1cdbd2cSJim Jagielski }
4252*b1cdbd2cSJim Jagielski
4253*b1cdbd2cSJim Jagielski const sal_Bool bCnt = _rFrm.IsCntntFrm();
4254*b1cdbd2cSJim Jagielski
4255*b1cdbd2cSJim Jagielski if ( bCnt )
4256*b1cdbd2cSJim Jagielski {
4257*b1cdbd2cSJim Jagielski ::lcl_ExtendLeftAndRight( aRect, _rFrm, _rAttrs, _rRectFn );
4258*b1cdbd2cSJim Jagielski }
4259*b1cdbd2cSJim Jagielski
4260*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - adjustments for printer output device
4261*b1cdbd2cSJim Jagielski if ( bPrtOutputDev )
4262*b1cdbd2cSJim Jagielski {
4263*b1cdbd2cSJim Jagielski // substract width of outer top line.
4264*b1cdbd2cSJim Jagielski if ( rBox.GetTop() && (!bCnt || _rAttrs.GetTopLine( _rFrm )) )
4265*b1cdbd2cSJim Jagielski {
4266*b1cdbd2cSJim Jagielski long nDist = ::lcl_AlignHeight( rBox.GetTop()->GetOutWidth() );
4267*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubTop)( -nDist );
4268*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - If outer top line is hair line, calculated
4269*b1cdbd2cSJim Jagielski // top has to be adjusted.
4270*b1cdbd2cSJim Jagielski if ( nDist == 1 )
4271*b1cdbd2cSJim Jagielski {
4272*b1cdbd2cSJim Jagielski if ( _rFrm.IsVertical() )
4273*b1cdbd2cSJim Jagielski {
4274*b1cdbd2cSJim Jagielski // right of border rectangle has to be checked and adjusted
4275*b1cdbd2cSJim Jagielski Point aCompPt( aRect.Right(), 0 );
4276*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X() + 1, aCompPt.Y() );
4277*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4278*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4279*b1cdbd2cSJim Jagielski sal_True, -1 );
4280*b1cdbd2cSJim Jagielski aRect.Right( aCompPt.X() );
4281*b1cdbd2cSJim Jagielski }
4282*b1cdbd2cSJim Jagielski else
4283*b1cdbd2cSJim Jagielski {
4284*b1cdbd2cSJim Jagielski // top of border rectangle has to be checked and adjusted
4285*b1cdbd2cSJim Jagielski Point aCompPt( 0, aRect.Top() );
4286*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X(), aCompPt.Y() - 1 );
4287*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4288*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4289*b1cdbd2cSJim Jagielski sal_False, +1 );
4290*b1cdbd2cSJim Jagielski aRect.Top( aCompPt.Y() );
4291*b1cdbd2cSJim Jagielski }
4292*b1cdbd2cSJim Jagielski }
4293*b1cdbd2cSJim Jagielski }
4294*b1cdbd2cSJim Jagielski // substract width of outer bottom line.
4295*b1cdbd2cSJim Jagielski if ( rBox.GetBottom() && (!bCnt || _rAttrs.GetBottomLine( _rFrm )) )
4296*b1cdbd2cSJim Jagielski {
4297*b1cdbd2cSJim Jagielski long nDist = ::lcl_AlignHeight( rBox.GetBottom()->GetOutWidth());
4298*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddBottom)( -nDist );
4299*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - If outer bottom line is hair line, calculated
4300*b1cdbd2cSJim Jagielski // top has to be adjusted.
4301*b1cdbd2cSJim Jagielski if ( nDist == 1 )
4302*b1cdbd2cSJim Jagielski {
4303*b1cdbd2cSJim Jagielski if ( _rFrm.IsVertical() )
4304*b1cdbd2cSJim Jagielski {
4305*b1cdbd2cSJim Jagielski // left of border rectangle has to be checked and adjusted
4306*b1cdbd2cSJim Jagielski Point aCompPt( aRect.Left(), 0 );
4307*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X() - 1, aCompPt.Y() );
4308*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4309*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4310*b1cdbd2cSJim Jagielski sal_True, +1 );
4311*b1cdbd2cSJim Jagielski aRect.Left( aCompPt.X() );
4312*b1cdbd2cSJim Jagielski }
4313*b1cdbd2cSJim Jagielski else
4314*b1cdbd2cSJim Jagielski {
4315*b1cdbd2cSJim Jagielski // bottom of border rectangle has to be checked and adjusted
4316*b1cdbd2cSJim Jagielski Point aCompPt( 0, aRect.Bottom() );
4317*b1cdbd2cSJim Jagielski Point aRefPt( aCompPt.X(), aCompPt.Y() + 1 );
4318*b1cdbd2cSJim Jagielski lcl_CompPxPosAndAdjustPos( *(pGlobalShell->GetOut()),
4319*b1cdbd2cSJim Jagielski aRefPt, aCompPt,
4320*b1cdbd2cSJim Jagielski sal_False, -1 );
4321*b1cdbd2cSJim Jagielski aRect.Bottom( aCompPt.Y() );
4322*b1cdbd2cSJim Jagielski }
4323*b1cdbd2cSJim Jagielski }
4324*b1cdbd2cSJim Jagielski }
4325*b1cdbd2cSJim Jagielski }
4326*b1cdbd2cSJim Jagielski
4327*b1cdbd2cSJim Jagielski if ( !pLeftRightBorder->GetInWidth() )
4328*b1cdbd2cSJim Jagielski {
4329*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - add 6th parameter
4330*b1cdbd2cSJim Jagielski ::lcl_SubTopBottom( aRect, rBox, _rAttrs, _rFrm, _rRectFn, bPrtOutputDev );
4331*b1cdbd2cSJim Jagielski }
4332*b1cdbd2cSJim Jagielski
4333*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - paint SwAligned-rectangle
4334*b1cdbd2cSJim Jagielski {
4335*b1cdbd2cSJim Jagielski SwRect aPaintRect( aRect );
4336*b1cdbd2cSJim Jagielski ::SwAlignRect( aPaintRect, _rFrm.getRootFrm()->GetCurrShell() );
4337*b1cdbd2cSJim Jagielski // if <SwAlignRect> reveals rectangle with no width, adjust rectangle
4338*b1cdbd2cSJim Jagielski // to the prior left postion with width of one twip.
4339*b1cdbd2cSJim Jagielski if ( (aPaintRect.*_rRectFn->fnGetWidth)() == 0 )
4340*b1cdbd2cSJim Jagielski {
4341*b1cdbd2cSJim Jagielski if ( _bLeft )
4342*b1cdbd2cSJim Jagielski {
4343*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetLeft)( (aRect.*_rRectFn->fnGetLeft)() );
4344*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetRight)( (aRect.*_rRectFn->fnGetLeft)() );
4345*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddRight)( 1 );
4346*b1cdbd2cSJim Jagielski }
4347*b1cdbd2cSJim Jagielski else
4348*b1cdbd2cSJim Jagielski {
4349*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetLeft)( (aRect.*_rRectFn->fnGetRight)() - 1 );
4350*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetRight)( (aRect.*_rRectFn->fnGetRight)() - 1 );
4351*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddRight)( 1 );
4352*b1cdbd2cSJim Jagielski }
4353*b1cdbd2cSJim Jagielski }
4354*b1cdbd2cSJim Jagielski _rFrm.PaintBorderLine( _rRect, aPaintRect, &_rPage, &pLeftRightBorder->GetColor() );
4355*b1cdbd2cSJim Jagielski }
4356*b1cdbd2cSJim Jagielski
4357*b1cdbd2cSJim Jagielski if ( pLeftRightBorder->GetInWidth() )
4358*b1cdbd2cSJim Jagielski {
4359*b1cdbd2cSJim Jagielski const long nDist = ::lcl_MinWidthDist( pLeftRightBorder->GetDistance() );
4360*b1cdbd2cSJim Jagielski long nWidth = ::lcl_AlignWidth( pLeftRightBorder->GetInWidth() );
4361*b1cdbd2cSJim Jagielski if ( _bLeft )
4362*b1cdbd2cSJim Jagielski {
4363*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddRight)( nDist + nWidth );
4364*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubLeft)( nWidth - (aRect.*_rRectFn->fnGetWidth)() );
4365*b1cdbd2cSJim Jagielski }
4366*b1cdbd2cSJim Jagielski else
4367*b1cdbd2cSJim Jagielski {
4368*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubLeft)( nDist + nWidth );
4369*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddRight)( nWidth - (aRect.*_rRectFn->fnGetWidth)() );
4370*b1cdbd2cSJim Jagielski }
4371*b1cdbd2cSJim Jagielski // OD 06.05.2003 #107169# - add 6th parameter
4372*b1cdbd2cSJim Jagielski ::lcl_SubTopBottom( aRect, rBox, _rAttrs, _rFrm, _rRectFn, bPrtOutputDev );
4373*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - paint SwAligned-rectangle
4374*b1cdbd2cSJim Jagielski {
4375*b1cdbd2cSJim Jagielski SwRect aPaintRect( aRect );
4376*b1cdbd2cSJim Jagielski ::SwAlignRect( aPaintRect, _rFrm.getRootFrm()->GetCurrShell() );
4377*b1cdbd2cSJim Jagielski // if <SwAlignRect> reveals rectangle with no width, adjust
4378*b1cdbd2cSJim Jagielski // rectangle to the prior left postion with width of one twip.
4379*b1cdbd2cSJim Jagielski if ( (aPaintRect.*_rRectFn->fnGetWidth)() == 0 )
4380*b1cdbd2cSJim Jagielski {
4381*b1cdbd2cSJim Jagielski if ( _bLeft )
4382*b1cdbd2cSJim Jagielski {
4383*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetLeft)( (aRect.*_rRectFn->fnGetLeft)() );
4384*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetRight)( (aRect.*_rRectFn->fnGetLeft)() );
4385*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddRight)( 1 );
4386*b1cdbd2cSJim Jagielski }
4387*b1cdbd2cSJim Jagielski else
4388*b1cdbd2cSJim Jagielski {
4389*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetLeft)( (aRect.*_rRectFn->fnGetRight)() - 1 );
4390*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetRight)( (aRect.*_rRectFn->fnGetRight)() - 1 );
4391*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddRight)( 1 );
4392*b1cdbd2cSJim Jagielski }
4393*b1cdbd2cSJim Jagielski }
4394*b1cdbd2cSJim Jagielski _rFrm.PaintBorderLine( _rRect, aPaintRect, &_rPage, &pLeftRightBorder->GetColor() );
4395*b1cdbd2cSJim Jagielski }
4396*b1cdbd2cSJim Jagielski }
4397*b1cdbd2cSJim Jagielski }
4398*b1cdbd2cSJim Jagielski
4399*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - merge <lcl_PaintTopLine> and <lcl_PaintBottomLine>
4400*b1cdbd2cSJim Jagielski // into <lcl_PaintTopLine>
lcl_PaintTopBottomLine(const sal_Bool _bTop,const SwFrm & _rFrm,const SwPageFrm & _rPage,const SwRect & _rOutRect,const SwRect & _rRect,const SwBorderAttrs & _rAttrs,const SwRectFn & _rRectFn)4401*b1cdbd2cSJim Jagielski void lcl_PaintTopBottomLine( const sal_Bool _bTop,
4402*b1cdbd2cSJim Jagielski const SwFrm& _rFrm,
4403*b1cdbd2cSJim Jagielski const SwPageFrm& _rPage,
4404*b1cdbd2cSJim Jagielski const SwRect& _rOutRect,
4405*b1cdbd2cSJim Jagielski const SwRect& _rRect,
4406*b1cdbd2cSJim Jagielski const SwBorderAttrs& _rAttrs,
4407*b1cdbd2cSJim Jagielski const SwRectFn& _rRectFn )
4408*b1cdbd2cSJim Jagielski {
4409*b1cdbd2cSJim Jagielski const SvxBoxItem& rBox = _rAttrs.GetBox();
4410*b1cdbd2cSJim Jagielski const SvxBorderLine* pTopBottomBorder = 0;
4411*b1cdbd2cSJim Jagielski if ( _bTop )
4412*b1cdbd2cSJim Jagielski {
4413*b1cdbd2cSJim Jagielski pTopBottomBorder = rBox.GetTop();
4414*b1cdbd2cSJim Jagielski }
4415*b1cdbd2cSJim Jagielski else
4416*b1cdbd2cSJim Jagielski {
4417*b1cdbd2cSJim Jagielski pTopBottomBorder = rBox.GetBottom();
4418*b1cdbd2cSJim Jagielski }
4419*b1cdbd2cSJim Jagielski
4420*b1cdbd2cSJim Jagielski if ( !pTopBottomBorder )
4421*b1cdbd2cSJim Jagielski {
4422*b1cdbd2cSJim Jagielski return;
4423*b1cdbd2cSJim Jagielski }
4424*b1cdbd2cSJim Jagielski
4425*b1cdbd2cSJim Jagielski SwRect aRect( _rOutRect );
4426*b1cdbd2cSJim Jagielski if ( _bTop )
4427*b1cdbd2cSJim Jagielski {
4428*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddBottom)( ::lcl_AlignHeight( pTopBottomBorder->GetOutWidth() ) -
4429*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnGetHeight)() );
4430*b1cdbd2cSJim Jagielski }
4431*b1cdbd2cSJim Jagielski else
4432*b1cdbd2cSJim Jagielski {
4433*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubTop)( ::lcl_AlignHeight( pTopBottomBorder->GetOutWidth() ) -
4434*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnGetHeight)() );
4435*b1cdbd2cSJim Jagielski }
4436*b1cdbd2cSJim Jagielski
4437*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - paint SwAligned-rectangle
4438*b1cdbd2cSJim Jagielski {
4439*b1cdbd2cSJim Jagielski SwRect aPaintRect( aRect );
4440*b1cdbd2cSJim Jagielski ::SwAlignRect( aPaintRect, _rFrm.getRootFrm()->GetCurrShell() );
4441*b1cdbd2cSJim Jagielski // if <SwAlignRect> reveals rectangle with no width, adjust rectangle
4442*b1cdbd2cSJim Jagielski // to the prior top postion with width of one twip.
4443*b1cdbd2cSJim Jagielski if ( (aPaintRect.*_rRectFn->fnGetHeight)() == 0 )
4444*b1cdbd2cSJim Jagielski {
4445*b1cdbd2cSJim Jagielski if ( _bTop )
4446*b1cdbd2cSJim Jagielski {
4447*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetTop)( (aRect.*_rRectFn->fnGetTop)() );
4448*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetBottom)( (aRect.*_rRectFn->fnGetTop)() );
4449*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddBottom)( 1 );
4450*b1cdbd2cSJim Jagielski }
4451*b1cdbd2cSJim Jagielski else
4452*b1cdbd2cSJim Jagielski {
4453*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetTop)( (aRect.*_rRectFn->fnGetBottom)() - 1 );
4454*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetBottom)( (aRect.*_rRectFn->fnGetBottom)() - 1 );
4455*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddBottom)( 1 );
4456*b1cdbd2cSJim Jagielski }
4457*b1cdbd2cSJim Jagielski }
4458*b1cdbd2cSJim Jagielski _rFrm.PaintBorderLine( _rRect, aPaintRect, &_rPage, &pTopBottomBorder->GetColor() );
4459*b1cdbd2cSJim Jagielski }
4460*b1cdbd2cSJim Jagielski
4461*b1cdbd2cSJim Jagielski if ( pTopBottomBorder->GetInWidth() )
4462*b1cdbd2cSJim Jagielski {
4463*b1cdbd2cSJim Jagielski const long nDist = ::lcl_MinHeightDist( pTopBottomBorder->GetDistance() );
4464*b1cdbd2cSJim Jagielski const long nHeight = ::lcl_AlignHeight( pTopBottomBorder->GetInWidth() );
4465*b1cdbd2cSJim Jagielski if ( _bTop )
4466*b1cdbd2cSJim Jagielski {
4467*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddBottom)( nDist + nHeight );
4468*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubTop)( nHeight - (aRect.*_rRectFn->fnGetHeight)() );
4469*b1cdbd2cSJim Jagielski }
4470*b1cdbd2cSJim Jagielski else
4471*b1cdbd2cSJim Jagielski {
4472*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnSubTop)( nDist + nHeight );
4473*b1cdbd2cSJim Jagielski (aRect.*_rRectFn->fnAddBottom)( nHeight -(aRect.*_rRectFn->fnGetHeight)() );
4474*b1cdbd2cSJim Jagielski }
4475*b1cdbd2cSJim Jagielski ::lcl_SubLeftRight( aRect, rBox, _rRectFn );
4476*b1cdbd2cSJim Jagielski // OD 29.04.2003 #107169# - paint SwAligned-rectangle
4477*b1cdbd2cSJim Jagielski {
4478*b1cdbd2cSJim Jagielski SwRect aPaintRect( aRect );
4479*b1cdbd2cSJim Jagielski ::SwAlignRect( aPaintRect, _rFrm.getRootFrm()->GetCurrShell() );
4480*b1cdbd2cSJim Jagielski // if <SwAlignRect> reveals rectangle with no width, adjust
4481*b1cdbd2cSJim Jagielski // rectangle to the prior top postion with width of one twip.
4482*b1cdbd2cSJim Jagielski if ( (aPaintRect.*_rRectFn->fnGetHeight)() == 0 )
4483*b1cdbd2cSJim Jagielski {
4484*b1cdbd2cSJim Jagielski if ( _bTop )
4485*b1cdbd2cSJim Jagielski {
4486*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetTop)( (aRect.*_rRectFn->fnGetTop)() );
4487*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetBottom)( (aRect.*_rRectFn->fnGetTop)() );
4488*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddBottom)( 1 );
4489*b1cdbd2cSJim Jagielski }
4490*b1cdbd2cSJim Jagielski else
4491*b1cdbd2cSJim Jagielski {
4492*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetTop)( (aRect.*_rRectFn->fnGetBottom)() - 1 );
4493*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnSetBottom)( (aRect.*_rRectFn->fnGetBottom)() - 1 );
4494*b1cdbd2cSJim Jagielski (aPaintRect.*_rRectFn->fnAddBottom)( 1 );
4495*b1cdbd2cSJim Jagielski }
4496*b1cdbd2cSJim Jagielski }
4497*b1cdbd2cSJim Jagielski _rFrm.PaintBorderLine( _rRect, aPaintRect, &_rPage, &pTopBottomBorder->GetColor() );
4498*b1cdbd2cSJim Jagielski }
4499*b1cdbd2cSJim Jagielski }
4500*b1cdbd2cSJim Jagielski }
4501*b1cdbd2cSJim Jagielski
4502*b1cdbd2cSJim Jagielski
4503*b1cdbd2cSJim Jagielski /*************************************************************************
4504*b1cdbd2cSJim Jagielski |*
4505*b1cdbd2cSJim Jagielski |* const SwFrm* lcl_HasNextCell( const SwFrm& rFrm )
4506*b1cdbd2cSJim Jagielski |*
4507*b1cdbd2cSJim Jagielski |* No comment. #i15844#
4508*b1cdbd2cSJim Jagielski |*
4509*b1cdbd2cSJim Jagielski |*************************************************************************/
4510*b1cdbd2cSJim Jagielski
lcl_HasNextCell(const SwFrm & rFrm)4511*b1cdbd2cSJim Jagielski const SwFrm* lcl_HasNextCell( const SwFrm& rFrm )
4512*b1cdbd2cSJim Jagielski {
4513*b1cdbd2cSJim Jagielski ASSERT( rFrm.IsCellFrm(),
4514*b1cdbd2cSJim Jagielski "lcl_HasNextCell( const SwFrm& rFrm ) should be called with SwCellFrm" )
4515*b1cdbd2cSJim Jagielski
4516*b1cdbd2cSJim Jagielski const SwFrm* pTmpFrm = &rFrm;
4517*b1cdbd2cSJim Jagielski do
4518*b1cdbd2cSJim Jagielski {
4519*b1cdbd2cSJim Jagielski if ( pTmpFrm->GetNext() )
4520*b1cdbd2cSJim Jagielski return pTmpFrm->GetNext();
4521*b1cdbd2cSJim Jagielski
4522*b1cdbd2cSJim Jagielski pTmpFrm = pTmpFrm->GetUpper()->GetUpper();
4523*b1cdbd2cSJim Jagielski }
4524*b1cdbd2cSJim Jagielski while ( pTmpFrm->IsCellFrm() );
4525*b1cdbd2cSJim Jagielski
4526*b1cdbd2cSJim Jagielski return 0;
4527*b1cdbd2cSJim Jagielski }
4528*b1cdbd2cSJim Jagielski
4529*b1cdbd2cSJim Jagielski
4530*b1cdbd2cSJim Jagielski /*************************************************************************
4531*b1cdbd2cSJim Jagielski |*
4532*b1cdbd2cSJim Jagielski |* SwFrm::PaintBorder()
4533*b1cdbd2cSJim Jagielski |*
4534*b1cdbd2cSJim Jagielski |* Beschreibung Malt Schatten und Umrandung
4535*b1cdbd2cSJim Jagielski |* Ersterstellung MA 23.01.92
4536*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 29. Jul. 96
4537*b1cdbd2cSJim Jagielski |*
4538*b1cdbd2cSJim Jagielski |*************************************************************************/
4539*b1cdbd2cSJim Jagielski
4540*b1cdbd2cSJim Jagielski /** local method to determine cell frame, from which the border attributes
4541*b1cdbd2cSJim Jagielski for paint of top/bottom border has to be used.
4542*b1cdbd2cSJim Jagielski
4543*b1cdbd2cSJim Jagielski OD 21.02.2003 #b4779636#, #107692#
4544*b1cdbd2cSJim Jagielski
4545*b1cdbd2cSJim Jagielski @author OD
4546*b1cdbd2cSJim Jagielski
4547*b1cdbd2cSJim Jagielski
4548*b1cdbd2cSJim Jagielski @param _pCellFrm
4549*b1cdbd2cSJim Jagielski input parameter - constant pointer to cell frame for which the cell frame
4550*b1cdbd2cSJim Jagielski for the border attributes has to be determined.
4551*b1cdbd2cSJim Jagielski
4552*b1cdbd2cSJim Jagielski @param _rCellBorderAttrs
4553*b1cdbd2cSJim Jagielski input parameter - constant reference to the border attributes of cell frame
4554*b1cdbd2cSJim Jagielski <_pCellFrm>.
4555*b1cdbd2cSJim Jagielski
4556*b1cdbd2cSJim Jagielski @param _bTop
4557*b1cdbd2cSJim Jagielski input parameter - boolean, that controls, if cell frame for top border or
4558*b1cdbd2cSJim Jagielski for bottom border has to be determined.
4559*b1cdbd2cSJim Jagielski
4560*b1cdbd2cSJim Jagielski @return constant pointer to cell frame, for which the border attributes has
4561*b1cdbd2cSJim Jagielski to be used
4562*b1cdbd2cSJim Jagielski */
lcl_GetCellFrmForBorderAttrs(const SwFrm * _pCellFrm,const SwBorderAttrs & _rCellBorderAttrs,const bool _bTop)4563*b1cdbd2cSJim Jagielski const SwFrm* lcl_GetCellFrmForBorderAttrs( const SwFrm* _pCellFrm,
4564*b1cdbd2cSJim Jagielski const SwBorderAttrs& _rCellBorderAttrs,
4565*b1cdbd2cSJim Jagielski const bool _bTop )
4566*b1cdbd2cSJim Jagielski {
4567*b1cdbd2cSJim Jagielski ASSERT( _pCellFrm, "No cell frame available, dying soon" )
4568*b1cdbd2cSJim Jagielski
4569*b1cdbd2cSJim Jagielski // determine, if cell frame is at bottom/top border of a table frame and
4570*b1cdbd2cSJim Jagielski // the table frame has/is a follow.
4571*b1cdbd2cSJim Jagielski const SwFrm* pTmpFrm = _pCellFrm;
4572*b1cdbd2cSJim Jagielski bool bCellAtBorder = true;
4573*b1cdbd2cSJim Jagielski bool bCellAtLeftBorder = !_pCellFrm->GetPrev();
4574*b1cdbd2cSJim Jagielski bool bCellAtRightBorder = !_pCellFrm->GetNext();
4575*b1cdbd2cSJim Jagielski while( !pTmpFrm->IsRowFrm() || !pTmpFrm->GetUpper()->IsTabFrm() )
4576*b1cdbd2cSJim Jagielski {
4577*b1cdbd2cSJim Jagielski pTmpFrm = pTmpFrm->GetUpper();
4578*b1cdbd2cSJim Jagielski if ( pTmpFrm->IsRowFrm() &&
4579*b1cdbd2cSJim Jagielski (_bTop ? pTmpFrm->GetPrev() : pTmpFrm->GetNext())
4580*b1cdbd2cSJim Jagielski )
4581*b1cdbd2cSJim Jagielski {
4582*b1cdbd2cSJim Jagielski bCellAtBorder = false;
4583*b1cdbd2cSJim Jagielski }
4584*b1cdbd2cSJim Jagielski if ( pTmpFrm->IsCellFrm() )
4585*b1cdbd2cSJim Jagielski {
4586*b1cdbd2cSJim Jagielski if ( pTmpFrm->GetPrev() )
4587*b1cdbd2cSJim Jagielski {
4588*b1cdbd2cSJim Jagielski bCellAtLeftBorder = false;
4589*b1cdbd2cSJim Jagielski }
4590*b1cdbd2cSJim Jagielski if ( pTmpFrm->GetNext() )
4591*b1cdbd2cSJim Jagielski {
4592*b1cdbd2cSJim Jagielski bCellAtRightBorder = false;
4593*b1cdbd2cSJim Jagielski }
4594*b1cdbd2cSJim Jagielski }
4595*b1cdbd2cSJim Jagielski }
4596*b1cdbd2cSJim Jagielski ASSERT( pTmpFrm && pTmpFrm->IsRowFrm(), "No RowFrm available" );
4597*b1cdbd2cSJim Jagielski
4598*b1cdbd2cSJim Jagielski const SwLayoutFrm* pParentRowFrm = static_cast<const SwLayoutFrm*>(pTmpFrm);
4599*b1cdbd2cSJim Jagielski const SwTabFrm* pParentTabFrm =
4600*b1cdbd2cSJim Jagielski static_cast<const SwTabFrm*>(pParentRowFrm->GetUpper());
4601*b1cdbd2cSJim Jagielski
4602*b1cdbd2cSJim Jagielski const bool bCellNeedsAttribute = bCellAtBorder &&
4603*b1cdbd2cSJim Jagielski ( _bTop ?
4604*b1cdbd2cSJim Jagielski // bCellInFirstRowWithMaster
4605*b1cdbd2cSJim Jagielski ( !pParentRowFrm->GetPrev() &&
4606*b1cdbd2cSJim Jagielski pParentTabFrm->IsFollow() &&
4607*b1cdbd2cSJim Jagielski 0 == pParentTabFrm->GetTable()->GetRowsToRepeat() ) :
4608*b1cdbd2cSJim Jagielski // bCellInLastRowWithFollow
4609*b1cdbd2cSJim Jagielski ( !pParentRowFrm->GetNext() &&
4610*b1cdbd2cSJim Jagielski pParentTabFrm->GetFollow() )
4611*b1cdbd2cSJim Jagielski );
4612*b1cdbd2cSJim Jagielski
4613*b1cdbd2cSJim Jagielski const SwFrm* pRet = _pCellFrm;
4614*b1cdbd2cSJim Jagielski if ( bCellNeedsAttribute )
4615*b1cdbd2cSJim Jagielski {
4616*b1cdbd2cSJim Jagielski // determine, if cell frame has no borders inside the table.
4617*b1cdbd2cSJim Jagielski const SwFrm* pNextCell = 0;
4618*b1cdbd2cSJim Jagielski bool bNoBordersInside = false;
4619*b1cdbd2cSJim Jagielski
4620*b1cdbd2cSJim Jagielski if ( bCellAtLeftBorder && ( 0 != ( pNextCell = lcl_HasNextCell( *_pCellFrm ) ) ) )
4621*b1cdbd2cSJim Jagielski {
4622*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), pNextCell );
4623*b1cdbd2cSJim Jagielski const SwBorderAttrs &rBorderAttrs = *aAccess.Get();
4624*b1cdbd2cSJim Jagielski const SvxBoxItem& rBorderBox = rBorderAttrs.GetBox();
4625*b1cdbd2cSJim Jagielski bCellAtRightBorder = !lcl_HasNextCell( *pNextCell );
4626*b1cdbd2cSJim Jagielski bNoBordersInside =
4627*b1cdbd2cSJim Jagielski ( !rBorderBox.GetTop() || !pParentRowFrm->GetPrev() ) &&
4628*b1cdbd2cSJim Jagielski !rBorderBox.GetLeft() &&
4629*b1cdbd2cSJim Jagielski ( !rBorderBox.GetRight() || bCellAtRightBorder ) &&
4630*b1cdbd2cSJim Jagielski ( !rBorderBox.GetBottom() || !pParentRowFrm->GetNext() );
4631*b1cdbd2cSJim Jagielski }
4632*b1cdbd2cSJim Jagielski else
4633*b1cdbd2cSJim Jagielski {
4634*b1cdbd2cSJim Jagielski const SvxBoxItem& rBorderBox = _rCellBorderAttrs.GetBox();
4635*b1cdbd2cSJim Jagielski bNoBordersInside =
4636*b1cdbd2cSJim Jagielski ( !rBorderBox.GetTop() || !pParentRowFrm->GetPrev() ) &&
4637*b1cdbd2cSJim Jagielski ( !rBorderBox.GetLeft() || bCellAtLeftBorder ) &&
4638*b1cdbd2cSJim Jagielski ( !rBorderBox.GetRight() || bCellAtRightBorder ) &&
4639*b1cdbd2cSJim Jagielski ( !rBorderBox.GetBottom() || !pParentRowFrm->GetNext() );
4640*b1cdbd2cSJim Jagielski }
4641*b1cdbd2cSJim Jagielski
4642*b1cdbd2cSJim Jagielski if ( bNoBordersInside )
4643*b1cdbd2cSJim Jagielski {
4644*b1cdbd2cSJim Jagielski if ( _bTop && !_rCellBorderAttrs.GetBox().GetTop() )
4645*b1cdbd2cSJim Jagielski {
4646*b1cdbd2cSJim Jagielski // #b4779636#-hack:
4647*b1cdbd2cSJim Jagielski // Cell frame has no top border and no border inside the table, but
4648*b1cdbd2cSJim Jagielski // it is at the top border of a table frame, which is a follow.
4649*b1cdbd2cSJim Jagielski // Thus, use border attributes of cell frame in first row of complete table.
4650*b1cdbd2cSJim Jagielski // First, determine first table frame of complete table.
4651*b1cdbd2cSJim Jagielski SwTabFrm* pMasterTabFrm = pParentTabFrm->FindMaster( true );
4652*b1cdbd2cSJim Jagielski // determine first row of complete table.
4653*b1cdbd2cSJim Jagielski const SwFrm* pFirstRow = pMasterTabFrm->GetLower();
4654*b1cdbd2cSJim Jagielski // return first cell in first row
4655*b1cdbd2cSJim Jagielski SwFrm* pLowerCell = const_cast<SwFrm*>(pFirstRow->GetLower());
4656*b1cdbd2cSJim Jagielski while ( !pLowerCell->IsCellFrm() ||
4657*b1cdbd2cSJim Jagielski ( pLowerCell->GetLower() && pLowerCell->GetLower()->IsRowFrm() )
4658*b1cdbd2cSJim Jagielski )
4659*b1cdbd2cSJim Jagielski {
4660*b1cdbd2cSJim Jagielski pLowerCell = pLowerCell->GetLower();
4661*b1cdbd2cSJim Jagielski }
4662*b1cdbd2cSJim Jagielski ASSERT( pLowerCell && pLowerCell->IsCellFrm(), "No CellFrm available" );
4663*b1cdbd2cSJim Jagielski pRet = pLowerCell;
4664*b1cdbd2cSJim Jagielski }
4665*b1cdbd2cSJim Jagielski else if ( !_bTop && !_rCellBorderAttrs.GetBox().GetBottom() )
4666*b1cdbd2cSJim Jagielski {
4667*b1cdbd2cSJim Jagielski // #b4779636#-hack:
4668*b1cdbd2cSJim Jagielski // Cell frame has no bottom border and no border inside the table,
4669*b1cdbd2cSJim Jagielski // but it is at the bottom border of a table frame, which has a follow.
4670*b1cdbd2cSJim Jagielski // Thus, use border attributes of cell frame in last row of complete table.
4671*b1cdbd2cSJim Jagielski // First, determine last table frame of complete table.
4672*b1cdbd2cSJim Jagielski SwTabFrm* pLastTabFrm = const_cast<SwTabFrm*>(pParentTabFrm->GetFollow());
4673*b1cdbd2cSJim Jagielski while ( pLastTabFrm->GetFollow() )
4674*b1cdbd2cSJim Jagielski {
4675*b1cdbd2cSJim Jagielski pLastTabFrm = pLastTabFrm->GetFollow();
4676*b1cdbd2cSJim Jagielski }
4677*b1cdbd2cSJim Jagielski // determine last row of complete table.
4678*b1cdbd2cSJim Jagielski SwFrm* pLastRow = pLastTabFrm->GetLastLower();
4679*b1cdbd2cSJim Jagielski // return first bottom border cell in last row
4680*b1cdbd2cSJim Jagielski SwFrm* pLowerCell = const_cast<SwFrm*>(pLastRow->GetLower());
4681*b1cdbd2cSJim Jagielski while ( !pLowerCell->IsCellFrm() ||
4682*b1cdbd2cSJim Jagielski ( pLowerCell->GetLower() && pLowerCell->GetLower()->IsRowFrm() )
4683*b1cdbd2cSJim Jagielski )
4684*b1cdbd2cSJim Jagielski {
4685*b1cdbd2cSJim Jagielski if ( pLowerCell->IsRowFrm() )
4686*b1cdbd2cSJim Jagielski {
4687*b1cdbd2cSJim Jagielski while ( pLowerCell->GetNext() )
4688*b1cdbd2cSJim Jagielski {
4689*b1cdbd2cSJim Jagielski pLowerCell = pLowerCell->GetNext();
4690*b1cdbd2cSJim Jagielski }
4691*b1cdbd2cSJim Jagielski }
4692*b1cdbd2cSJim Jagielski pLowerCell = pLowerCell->GetLower();
4693*b1cdbd2cSJim Jagielski }
4694*b1cdbd2cSJim Jagielski ASSERT( pLowerCell && pLowerCell->IsCellFrm(), "No CellFrm available" );
4695*b1cdbd2cSJim Jagielski pRet = pLowerCell;
4696*b1cdbd2cSJim Jagielski }
4697*b1cdbd2cSJim Jagielski }
4698*b1cdbd2cSJim Jagielski }
4699*b1cdbd2cSJim Jagielski
4700*b1cdbd2cSJim Jagielski return pRet;
4701*b1cdbd2cSJim Jagielski }
4702*b1cdbd2cSJim Jagielski
PaintBorder(const SwRect & rRect,const SwPageFrm * pPage,const SwBorderAttrs & rAttrs) const4703*b1cdbd2cSJim Jagielski void SwFrm::PaintBorder( const SwRect& rRect, const SwPageFrm *pPage,
4704*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs ) const
4705*b1cdbd2cSJim Jagielski {
4706*b1cdbd2cSJim Jagielski //fuer (Row,Body,Ftn,Root,Column,NoTxt) gibt's hier nix zu tun
4707*b1cdbd2cSJim Jagielski if ( (GetType() & 0x90C5) || (Prt().SSize() == Frm().SSize()) )
4708*b1cdbd2cSJim Jagielski return;
4709*b1cdbd2cSJim Jagielski
4710*b1cdbd2cSJim Jagielski if ( (GetType() & 0x2000) && //Cell
4711*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsTable() )
4712*b1cdbd2cSJim Jagielski return;
4713*b1cdbd2cSJim Jagielski
4714*b1cdbd2cSJim Jagielski // --> collapsing borders FME 2005-05-27 #i29550#
4715*b1cdbd2cSJim Jagielski if ( IsTabFrm() || IsCellFrm() || IsRowFrm() )
4716*b1cdbd2cSJim Jagielski {
4717*b1cdbd2cSJim Jagielski const SwTabFrm* pTabFrm = FindTabFrm();
4718*b1cdbd2cSJim Jagielski if ( pTabFrm->IsCollapsingBorders() )
4719*b1cdbd2cSJim Jagielski return;
4720*b1cdbd2cSJim Jagielski
4721*b1cdbd2cSJim Jagielski if ( pTabFrm->GetTable()->IsNewModel() && ( !IsCellFrm() || IsCoveredCell() ) )
4722*b1cdbd2cSJim Jagielski return;
4723*b1cdbd2cSJim Jagielski }
4724*b1cdbd2cSJim Jagielski // <--
4725*b1cdbd2cSJim Jagielski
4726*b1cdbd2cSJim Jagielski const bool bLine = rAttrs.IsLine() ? true : false;
4727*b1cdbd2cSJim Jagielski const bool bShadow = rAttrs.GetShadow().GetLocation() != SVX_SHADOW_NONE;
4728*b1cdbd2cSJim Jagielski
4729*b1cdbd2cSJim Jagielski // OD 24.02.2003 #b4779636#, #107692# - flag to control,
4730*b1cdbd2cSJim Jagielski // if #b4779636#-hack has to be used.
4731*b1cdbd2cSJim Jagielski const bool bb4779636HackActive = true;
4732*b1cdbd2cSJim Jagielski // OD 21.02.2003 #b4779636#, #107692#
4733*b1cdbd2cSJim Jagielski const SwFrm* pCellFrmForBottomBorderAttrs = 0;
4734*b1cdbd2cSJim Jagielski const SwFrm* pCellFrmForTopBorderAttrs = 0;
4735*b1cdbd2cSJim Jagielski bool bFoundCellForTopOrBorderAttrs = false;
4736*b1cdbd2cSJim Jagielski if ( bb4779636HackActive && IsCellFrm() )
4737*b1cdbd2cSJim Jagielski {
4738*b1cdbd2cSJim Jagielski pCellFrmForBottomBorderAttrs = lcl_GetCellFrmForBorderAttrs( this, rAttrs, false );
4739*b1cdbd2cSJim Jagielski if ( pCellFrmForBottomBorderAttrs != this )
4740*b1cdbd2cSJim Jagielski bFoundCellForTopOrBorderAttrs = true;
4741*b1cdbd2cSJim Jagielski pCellFrmForTopBorderAttrs = lcl_GetCellFrmForBorderAttrs( this, rAttrs, true );
4742*b1cdbd2cSJim Jagielski if ( pCellFrmForTopBorderAttrs != this )
4743*b1cdbd2cSJim Jagielski bFoundCellForTopOrBorderAttrs = true;
4744*b1cdbd2cSJim Jagielski }
4745*b1cdbd2cSJim Jagielski
4746*b1cdbd2cSJim Jagielski // OD 24.02.2003 #b4779636#, #107692# - add condition <bFoundCellForTopOrBorderAttrs>
4747*b1cdbd2cSJim Jagielski // for #b4779636#-hack
4748*b1cdbd2cSJim Jagielski if ( bLine || bShadow || bFoundCellForTopOrBorderAttrs )
4749*b1cdbd2cSJim Jagielski {
4750*b1cdbd2cSJim Jagielski //Wenn das Rechteck vollstandig innerhalb der PrtArea liegt,
4751*b1cdbd2cSJim Jagielski //so braucht kein Rand gepainted werden.
4752*b1cdbd2cSJim Jagielski //Fuer die PrtArea muss der Aligned'e Wert zugrunde gelegt werden,
4753*b1cdbd2cSJim Jagielski //anderfalls wuerden u.U. Teile nicht verarbeitet.
4754*b1cdbd2cSJim Jagielski SwRect aRect( Prt() );
4755*b1cdbd2cSJim Jagielski aRect += Frm().Pos();
4756*b1cdbd2cSJim Jagielski ::SwAlignRect( aRect, pGlobalShell );
4757*b1cdbd2cSJim Jagielski // OD 27.09.2002 #103636# - new local boolean variable in order to
4758*b1cdbd2cSJim Jagielski // suspend border paint under special cases - see below.
4759*b1cdbd2cSJim Jagielski // NOTE: This is a fix for the implementation of feature #99657#.
4760*b1cdbd2cSJim Jagielski bool bDrawOnlyShadowForTransparentFrame = false;
4761*b1cdbd2cSJim Jagielski if ( aRect.IsInside( rRect ) )
4762*b1cdbd2cSJim Jagielski {
4763*b1cdbd2cSJim Jagielski // OD 27.09.2002 #103636# - paint shadow, if background is transparent.
4764*b1cdbd2cSJim Jagielski // Because of introduced transparent background for fly frame #99657#,
4765*b1cdbd2cSJim Jagielski // the shadow have to be drawn if the background is transparent,
4766*b1cdbd2cSJim Jagielski // in spite the fact that the paint rectangle <rRect> lies fully
4767*b1cdbd2cSJim Jagielski // in the printing area.
4768*b1cdbd2cSJim Jagielski // NOTE to chosen solution:
4769*b1cdbd2cSJim Jagielski // On transparent background, continue processing, but suspend
4770*b1cdbd2cSJim Jagielski // drawing of border by setting <bDrawOnlyShadowForTransparentFrame>
4771*b1cdbd2cSJim Jagielski // to true.
4772*b1cdbd2cSJim Jagielski if ( IsLayoutFrm() &&
4773*b1cdbd2cSJim Jagielski static_cast<const SwLayoutFrm*>(this)->GetFmt()->IsBackgroundTransparent() )
4774*b1cdbd2cSJim Jagielski {
4775*b1cdbd2cSJim Jagielski bDrawOnlyShadowForTransparentFrame = true;
4776*b1cdbd2cSJim Jagielski }
4777*b1cdbd2cSJim Jagielski else
4778*b1cdbd2cSJim Jagielski {
4779*b1cdbd2cSJim Jagielski return;
4780*b1cdbd2cSJim Jagielski }
4781*b1cdbd2cSJim Jagielski }
4782*b1cdbd2cSJim Jagielski
4783*b1cdbd2cSJim Jagielski if ( !pPage )
4784*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
4785*b1cdbd2cSJim Jagielski
4786*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( aRect, this, rAttrs, sal_True );
4787*b1cdbd2cSJim Jagielski rAttrs.SetGetCacheLine( sal_True );
4788*b1cdbd2cSJim Jagielski if ( bShadow )
4789*b1cdbd2cSJim Jagielski PaintShadow( rRect, aRect, rAttrs );
4790*b1cdbd2cSJim Jagielski // OD 27.09.2002 #103636# - suspend drawing of border
4791*b1cdbd2cSJim Jagielski // add condition < NOT bDrawOnlyShadowForTransparentFrame > - see above
4792*b1cdbd2cSJim Jagielski // OD 24.02.2003 #b4779636#, #107692# - add condition <bFoundCellForTopOrBorderAttrs>
4793*b1cdbd2cSJim Jagielski // for #b4779636#-hack.
4794*b1cdbd2cSJim Jagielski if ( ( bLine || bFoundCellForTopOrBorderAttrs ) &&
4795*b1cdbd2cSJim Jagielski !bDrawOnlyShadowForTransparentFrame )
4796*b1cdbd2cSJim Jagielski {
4797*b1cdbd2cSJim Jagielski const SwFrm* pDirRefFrm = IsCellFrm() ? FindTabFrm() : this;
4798*b1cdbd2cSJim Jagielski SWRECTFN( pDirRefFrm )
4799*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - use new method <lcl_PaintLeftRightLine(..)>
4800*b1cdbd2cSJim Jagielski //::lcl_PaintLeftLine ( this, pPage, aRect, rRect, rAttrs, fnRect );
4801*b1cdbd2cSJim Jagielski //::lcl_PaintRightLine ( this, pPage, aRect, rRect, rAttrs, fnRect );
4802*b1cdbd2cSJim Jagielski ::lcl_PaintLeftRightLine ( sal_True, *(this), *(pPage), aRect, rRect, rAttrs, fnRect );
4803*b1cdbd2cSJim Jagielski ::lcl_PaintLeftRightLine ( sal_False, *(this), *(pPage), aRect, rRect, rAttrs, fnRect );
4804*b1cdbd2cSJim Jagielski if ( !IsCntntFrm() || rAttrs.GetTopLine( *(this) ) )
4805*b1cdbd2cSJim Jagielski {
4806*b1cdbd2cSJim Jagielski // OD 21.02.2003 #b4779636#, #107692# -
4807*b1cdbd2cSJim Jagielski // #b4779636#-hack: If another cell frame for top border
4808*b1cdbd2cSJim Jagielski // paint is found, paint its top border.
4809*b1cdbd2cSJim Jagielski if ( IsCellFrm() && pCellFrmForTopBorderAttrs != this )
4810*b1cdbd2cSJim Jagielski {
4811*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(),
4812*b1cdbd2cSJim Jagielski pCellFrmForTopBorderAttrs );
4813*b1cdbd2cSJim Jagielski const SwBorderAttrs &rTopAttrs = *aAccess.Get();
4814*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - use new method <lcl_PaintTopBottomLine(..)>
4815*b1cdbd2cSJim Jagielski //::lcl_PaintTopLine( this, pPage, aRect, rRect, rTopAttrs, fnRect );
4816*b1cdbd2cSJim Jagielski ::lcl_PaintTopBottomLine( sal_True, *(this), *(pPage), aRect, rRect, rTopAttrs, fnRect );
4817*b1cdbd2cSJim Jagielski }
4818*b1cdbd2cSJim Jagielski else
4819*b1cdbd2cSJim Jagielski {
4820*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - use new method <lcl_PaintTopBottomLine(..)>
4821*b1cdbd2cSJim Jagielski //::lcl_PaintTopLine( this, pPage, aRect, rRect, rAttrs, fnRect );
4822*b1cdbd2cSJim Jagielski ::lcl_PaintTopBottomLine( sal_True, *(this), *(pPage), aRect, rRect, rAttrs, fnRect );
4823*b1cdbd2cSJim Jagielski }
4824*b1cdbd2cSJim Jagielski }
4825*b1cdbd2cSJim Jagielski if ( !IsCntntFrm() || rAttrs.GetBottomLine( *(this) ) )
4826*b1cdbd2cSJim Jagielski {
4827*b1cdbd2cSJim Jagielski // OD 21.02.2003 #b4779636#, #107692# -
4828*b1cdbd2cSJim Jagielski // #b4779636#-hack: If another cell frame for bottom border
4829*b1cdbd2cSJim Jagielski // paint is found, paint its bottom border.
4830*b1cdbd2cSJim Jagielski if ( IsCellFrm() && pCellFrmForBottomBorderAttrs != this )
4831*b1cdbd2cSJim Jagielski {
4832*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(),
4833*b1cdbd2cSJim Jagielski pCellFrmForBottomBorderAttrs );
4834*b1cdbd2cSJim Jagielski const SwBorderAttrs &rBottomAttrs = *aAccess.Get();
4835*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - use new method <lcl_PaintTopBottomLine(..)>
4836*b1cdbd2cSJim Jagielski //::lcl_PaintBottomLine(this, pPage, aRect, rRect, rBottomAttrs, fnRect);
4837*b1cdbd2cSJim Jagielski ::lcl_PaintTopBottomLine(sal_False, *(this), *(pPage), aRect, rRect, rBottomAttrs, fnRect);
4838*b1cdbd2cSJim Jagielski }
4839*b1cdbd2cSJim Jagielski else
4840*b1cdbd2cSJim Jagielski {
4841*b1cdbd2cSJim Jagielski // OD 19.05.2003 #109667# - use new method <lcl_PaintTopBottomLine(..)>
4842*b1cdbd2cSJim Jagielski //::lcl_PaintBottomLine(this, pPage, aRect, rRect, rAttrs, fnRect);
4843*b1cdbd2cSJim Jagielski ::lcl_PaintTopBottomLine(sal_False, *(this), *(pPage), aRect, rRect, rAttrs, fnRect);
4844*b1cdbd2cSJim Jagielski }
4845*b1cdbd2cSJim Jagielski }
4846*b1cdbd2cSJim Jagielski }
4847*b1cdbd2cSJim Jagielski rAttrs.SetGetCacheLine( sal_False );
4848*b1cdbd2cSJim Jagielski }
4849*b1cdbd2cSJim Jagielski }
4850*b1cdbd2cSJim Jagielski /*************************************************************************
4851*b1cdbd2cSJim Jagielski |*
4852*b1cdbd2cSJim Jagielski |* SwFtnContFrm::PaintBorder()
4853*b1cdbd2cSJim Jagielski |*
4854*b1cdbd2cSJim Jagielski |* Beschreibung Spezialimplementierung wg. der Fussnotenlinie.
4855*b1cdbd2cSJim Jagielski |* Derzeit braucht nur der obere Rand beruecksichtigt werden.
4856*b1cdbd2cSJim Jagielski |* Auf andere Linien und Schatten wird verzichtet.
4857*b1cdbd2cSJim Jagielski |* Ersterstellung MA 27. Feb. 93
4858*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 08. Sep. 93
4859*b1cdbd2cSJim Jagielski |*
4860*b1cdbd2cSJim Jagielski |*************************************************************************/
4861*b1cdbd2cSJim Jagielski
PaintBorder(const SwRect & rRect,const SwPageFrm * pPage,const SwBorderAttrs &) const4862*b1cdbd2cSJim Jagielski void SwFtnContFrm::PaintBorder( const SwRect& rRect, const SwPageFrm *pPage,
4863*b1cdbd2cSJim Jagielski const SwBorderAttrs & ) const
4864*b1cdbd2cSJim Jagielski {
4865*b1cdbd2cSJim Jagielski //Wenn das Rechteck vollstandig innerhalb der PrtArea liegt, so gibt es
4866*b1cdbd2cSJim Jagielski //keinen Rand zu painten.
4867*b1cdbd2cSJim Jagielski SwRect aRect( Prt() );
4868*b1cdbd2cSJim Jagielski aRect.Pos() += Frm().Pos();
4869*b1cdbd2cSJim Jagielski if ( !aRect.IsInside( rRect ) )
4870*b1cdbd2cSJim Jagielski PaintLine( rRect, pPage );
4871*b1cdbd2cSJim Jagielski }
4872*b1cdbd2cSJim Jagielski /*************************************************************************
4873*b1cdbd2cSJim Jagielski |*
4874*b1cdbd2cSJim Jagielski |* SwFtnContFrm::PaintLine()
4875*b1cdbd2cSJim Jagielski |*
4876*b1cdbd2cSJim Jagielski |* Beschreibung Fussnotenline malen.
4877*b1cdbd2cSJim Jagielski |* Ersterstellung MA 02. Mar. 93
4878*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 28. Mar. 94
4879*b1cdbd2cSJim Jagielski |*
4880*b1cdbd2cSJim Jagielski |*************************************************************************/
4881*b1cdbd2cSJim Jagielski
PaintLine(const SwRect & rRect,const SwPageFrm * pPage) const4882*b1cdbd2cSJim Jagielski void SwFtnContFrm::PaintLine( const SwRect& rRect,
4883*b1cdbd2cSJim Jagielski const SwPageFrm *pPage ) const
4884*b1cdbd2cSJim Jagielski {
4885*b1cdbd2cSJim Jagielski //Laenge der Linie ergibt sich aus der prozentualen Angabe am PageDesc.
4886*b1cdbd2cSJim Jagielski //Die Position ist ebenfalls am PageDesc angegeben.
4887*b1cdbd2cSJim Jagielski //Der Pen steht direkt im PageDesc.
4888*b1cdbd2cSJim Jagielski
4889*b1cdbd2cSJim Jagielski if ( !pPage )
4890*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
4891*b1cdbd2cSJim Jagielski const SwPageFtnInfo &rInf = pPage->GetPageDesc()->GetFtnInfo();
4892*b1cdbd2cSJim Jagielski
4893*b1cdbd2cSJim Jagielski SWRECTFN( this )
4894*b1cdbd2cSJim Jagielski SwTwips nPrtWidth = (Prt().*fnRect->fnGetWidth)();
4895*b1cdbd2cSJim Jagielski Fraction aFract( nPrtWidth, 1 );
4896*b1cdbd2cSJim Jagielski const SwTwips nWidth = (long)(aFract *= rInf.GetWidth());
4897*b1cdbd2cSJim Jagielski
4898*b1cdbd2cSJim Jagielski SwTwips nX = (this->*fnRect->fnGetPrtLeft)();
4899*b1cdbd2cSJim Jagielski switch ( rInf.GetAdj() )
4900*b1cdbd2cSJim Jagielski {
4901*b1cdbd2cSJim Jagielski case FTNADJ_CENTER:
4902*b1cdbd2cSJim Jagielski nX += nPrtWidth/2 - nWidth/2; break;
4903*b1cdbd2cSJim Jagielski case FTNADJ_RIGHT:
4904*b1cdbd2cSJim Jagielski nX += nPrtWidth - nWidth; break;
4905*b1cdbd2cSJim Jagielski case FTNADJ_LEFT:
4906*b1cdbd2cSJim Jagielski /* do nothing */; break;
4907*b1cdbd2cSJim Jagielski default:
4908*b1cdbd2cSJim Jagielski ASSERT( !this, "Neues Adjustment fuer Fussnotenlinie?" );
4909*b1cdbd2cSJim Jagielski }
4910*b1cdbd2cSJim Jagielski SwTwips nLineWidth = rInf.GetLineWidth();
4911*b1cdbd2cSJim Jagielski const SwRect aLineRect = bVert ?
4912*b1cdbd2cSJim Jagielski SwRect( Point(Frm().Left()+Frm().Width()-rInf.GetTopDist()-nLineWidth,
4913*b1cdbd2cSJim Jagielski nX), Size( nLineWidth, nWidth ) )
4914*b1cdbd2cSJim Jagielski : SwRect( Point( nX, Frm().Pos().Y() + rInf.GetTopDist() ),
4915*b1cdbd2cSJim Jagielski Size( nWidth, rInf.GetLineWidth()));
4916*b1cdbd2cSJim Jagielski if ( aLineRect.HasArea() )
4917*b1cdbd2cSJim Jagielski PaintBorderLine( rRect, aLineRect , pPage, &rInf.GetLineColor() );
4918*b1cdbd2cSJim Jagielski }
4919*b1cdbd2cSJim Jagielski
4920*b1cdbd2cSJim Jagielski /*************************************************************************
4921*b1cdbd2cSJim Jagielski |*
4922*b1cdbd2cSJim Jagielski |* SwLayoutFrm::PaintColLines()
4923*b1cdbd2cSJim Jagielski |*
4924*b1cdbd2cSJim Jagielski |* Beschreibung Painted die Trennlinien fuer die innenliegenden
4925*b1cdbd2cSJim Jagielski |* Spalten.
4926*b1cdbd2cSJim Jagielski |* Ersterstellung MA 21. Jun. 93
4927*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 28. Mar. 94
4928*b1cdbd2cSJim Jagielski |*
4929*b1cdbd2cSJim Jagielski |*************************************************************************/
4930*b1cdbd2cSJim Jagielski
PaintColLines(const SwRect & rRect,const SwFmtCol & rFmtCol,const SwPageFrm * pPage) const4931*b1cdbd2cSJim Jagielski void SwLayoutFrm::PaintColLines( const SwRect &rRect, const SwFmtCol &rFmtCol,
4932*b1cdbd2cSJim Jagielski const SwPageFrm *pPage ) const
4933*b1cdbd2cSJim Jagielski {
4934*b1cdbd2cSJim Jagielski const SwFrm *pCol = Lower();
4935*b1cdbd2cSJim Jagielski if ( !pCol || !pCol->IsColumnFrm() )
4936*b1cdbd2cSJim Jagielski return;
4937*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
4938*b1cdbd2cSJim Jagielski SwRectFn fnRect = pCol->IsVertical() ? ( pCol->IsVertLR() ? fnRectVertL2R : fnRectVert ) : fnRectHori;
4939*b1cdbd2cSJim Jagielski
4940*b1cdbd2cSJim Jagielski SwRect aLineRect = Prt();
4941*b1cdbd2cSJim Jagielski aLineRect += Frm().Pos();
4942*b1cdbd2cSJim Jagielski
4943*b1cdbd2cSJim Jagielski SwTwips nTop = ((aLineRect.*fnRect->fnGetHeight)()*rFmtCol.GetLineHeight())
4944*b1cdbd2cSJim Jagielski / 100 - (aLineRect.*fnRect->fnGetHeight)();
4945*b1cdbd2cSJim Jagielski SwTwips nBottom = 0;
4946*b1cdbd2cSJim Jagielski
4947*b1cdbd2cSJim Jagielski switch ( rFmtCol.GetLineAdj() )
4948*b1cdbd2cSJim Jagielski {
4949*b1cdbd2cSJim Jagielski case COLADJ_CENTER:
4950*b1cdbd2cSJim Jagielski nBottom = nTop / 2; nTop -= nBottom; break;
4951*b1cdbd2cSJim Jagielski case COLADJ_TOP:
4952*b1cdbd2cSJim Jagielski nBottom = nTop; nTop = 0; break;
4953*b1cdbd2cSJim Jagielski case COLADJ_BOTTOM:
4954*b1cdbd2cSJim Jagielski break;
4955*b1cdbd2cSJim Jagielski default:
4956*b1cdbd2cSJim Jagielski ASSERT( !this, "Neues Adjustment fuer Spaltenlinie?" );
4957*b1cdbd2cSJim Jagielski }
4958*b1cdbd2cSJim Jagielski
4959*b1cdbd2cSJim Jagielski if( nTop )
4960*b1cdbd2cSJim Jagielski (aLineRect.*fnRect->fnSubTop)( nTop );
4961*b1cdbd2cSJim Jagielski if( nBottom )
4962*b1cdbd2cSJim Jagielski (aLineRect.*fnRect->fnAddBottom)( nBottom );
4963*b1cdbd2cSJim Jagielski
4964*b1cdbd2cSJim Jagielski SwTwips nPenHalf = rFmtCol.GetLineWidth();
4965*b1cdbd2cSJim Jagielski (aLineRect.*fnRect->fnSetWidth)( nPenHalf );
4966*b1cdbd2cSJim Jagielski nPenHalf /= 2;
4967*b1cdbd2cSJim Jagielski
4968*b1cdbd2cSJim Jagielski //Damit uns nichts verlorengeht muessen wir hier etwas grosszuegiger sein.
4969*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
4970*b1cdbd2cSJim Jagielski (aRect.*fnRect->fnSubLeft)( nPenHalf + nPixelSzW );
4971*b1cdbd2cSJim Jagielski (aRect.*fnRect->fnAddRight)( nPenHalf + nPixelSzW );
4972*b1cdbd2cSJim Jagielski SwRectGet fnGetX = IsRightToLeft() ? fnRect->fnGetLeft : fnRect->fnGetRight;
4973*b1cdbd2cSJim Jagielski while ( pCol->GetNext() )
4974*b1cdbd2cSJim Jagielski {
4975*b1cdbd2cSJim Jagielski (aLineRect.*fnRect->fnSetPosX)
4976*b1cdbd2cSJim Jagielski ( (pCol->Frm().*fnGetX)() - nPenHalf );
4977*b1cdbd2cSJim Jagielski if ( aRect.IsOver( aLineRect ) )
4978*b1cdbd2cSJim Jagielski PaintBorderLine( aRect, aLineRect , pPage, &rFmtCol.GetLineColor());
4979*b1cdbd2cSJim Jagielski pCol = pCol->GetNext();
4980*b1cdbd2cSJim Jagielski }
4981*b1cdbd2cSJim Jagielski }
4982*b1cdbd2cSJim Jagielski
PaintGrid(OutputDevice * pOut,SwRect & rRect) const4983*b1cdbd2cSJim Jagielski void SwPageFrm::PaintGrid( OutputDevice* pOut, SwRect &rRect ) const
4984*b1cdbd2cSJim Jagielski {
4985*b1cdbd2cSJim Jagielski if( !bHasGrid || pRetoucheFly || pRetoucheFly2 )
4986*b1cdbd2cSJim Jagielski return;
4987*b1cdbd2cSJim Jagielski GETGRID( this )
4988*b1cdbd2cSJim Jagielski if( pGrid && ( OUTDEV_PRINTER != pOut->GetOutDevType() ?
4989*b1cdbd2cSJim Jagielski pGrid->GetDisplayGrid() : pGrid->GetPrintGrid() ) )
4990*b1cdbd2cSJim Jagielski {
4991*b1cdbd2cSJim Jagielski const SwLayoutFrm* pBody = FindBodyCont();
4992*b1cdbd2cSJim Jagielski if( pBody )
4993*b1cdbd2cSJim Jagielski {
4994*b1cdbd2cSJim Jagielski SwRect aGrid( pBody->Prt() );
4995*b1cdbd2cSJim Jagielski aGrid += pBody->Frm().Pos();
4996*b1cdbd2cSJim Jagielski
4997*b1cdbd2cSJim Jagielski SwRect aInter( aGrid );
4998*b1cdbd2cSJim Jagielski aInter.Intersection( rRect );
4999*b1cdbd2cSJim Jagielski if( aInter.HasArea() )
5000*b1cdbd2cSJim Jagielski {
5001*b1cdbd2cSJim Jagielski sal_Bool bGrid = pGrid->GetRubyTextBelow();
5002*b1cdbd2cSJim Jagielski sal_Bool bCell = GRID_LINES_CHARS == pGrid->GetGridType();
5003*b1cdbd2cSJim Jagielski long nGrid = pGrid->GetBaseHeight();
5004*b1cdbd2cSJim Jagielski const SwDoc* pDoc = GetFmt()->GetDoc();
5005*b1cdbd2cSJim Jagielski long nGridWidth = GETGRIDWIDTH(pGrid,pDoc); //for textgrid refactor
5006*b1cdbd2cSJim Jagielski long nRuby = pGrid->GetRubyHeight();
5007*b1cdbd2cSJim Jagielski long nSum = nGrid + nRuby;
5008*b1cdbd2cSJim Jagielski const Color *pCol = &pGrid->GetColor();
5009*b1cdbd2cSJim Jagielski
5010*b1cdbd2cSJim Jagielski SwTwips nRight = aInter.Left() + aInter.Width();
5011*b1cdbd2cSJim Jagielski SwTwips nBottom = aInter.Top() + aInter.Height();
5012*b1cdbd2cSJim Jagielski if( IsVertical() )
5013*b1cdbd2cSJim Jagielski {
5014*b1cdbd2cSJim Jagielski SwTwips nOrig = aGrid.Left() + aGrid.Width();
5015*b1cdbd2cSJim Jagielski SwTwips nY = nOrig + nSum *
5016*b1cdbd2cSJim Jagielski ( ( nOrig - aInter.Left() ) / nSum );
5017*b1cdbd2cSJim Jagielski SwRect aTmp( Point( nY, aInter.Top() ),
5018*b1cdbd2cSJim Jagielski Size( 1, aInter.Height() ) );
5019*b1cdbd2cSJim Jagielski SwTwips nX = aGrid.Top() + nGrid *
5020*b1cdbd2cSJim Jagielski ( ( aInter.Top() - aGrid.Top() )/ nGrid );
5021*b1cdbd2cSJim Jagielski if( nX < aInter.Top() )
5022*b1cdbd2cSJim Jagielski nX += nGrid;
5023*b1cdbd2cSJim Jagielski SwTwips nGridBottom = aGrid.Top() + aGrid.Height();
5024*b1cdbd2cSJim Jagielski sal_Bool bLeft = aGrid.Top() >= aInter.Top();
5025*b1cdbd2cSJim Jagielski sal_Bool bRight = nGridBottom <= nBottom;
5026*b1cdbd2cSJim Jagielski sal_Bool bBorder = bLeft || bRight;
5027*b1cdbd2cSJim Jagielski while( nY > nRight )
5028*b1cdbd2cSJim Jagielski {
5029*b1cdbd2cSJim Jagielski aTmp.Pos().X() = nY;
5030*b1cdbd2cSJim Jagielski if( bGrid )
5031*b1cdbd2cSJim Jagielski {
5032*b1cdbd2cSJim Jagielski nY -= nGrid;
5033*b1cdbd2cSJim Jagielski SwTwips nPosY = Max( aInter.Left(), nY );
5034*b1cdbd2cSJim Jagielski SwTwips nHeight = Min(nRight, aTmp.Pos().X())-nPosY;
5035*b1cdbd2cSJim Jagielski if( nHeight > 0 )
5036*b1cdbd2cSJim Jagielski {
5037*b1cdbd2cSJim Jagielski if( bCell )
5038*b1cdbd2cSJim Jagielski {
5039*b1cdbd2cSJim Jagielski SwRect aVert( Point( nPosY, nX ),
5040*b1cdbd2cSJim Jagielski Size( nHeight, 1 ) );
5041*b1cdbd2cSJim Jagielski while( aVert.Top() <= nBottom )
5042*b1cdbd2cSJim Jagielski {
5043*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5044*b1cdbd2cSJim Jagielski aVert.Pos().Y() += nGrid;
5045*b1cdbd2cSJim Jagielski }
5046*b1cdbd2cSJim Jagielski }
5047*b1cdbd2cSJim Jagielski else if( bBorder )
5048*b1cdbd2cSJim Jagielski {
5049*b1cdbd2cSJim Jagielski SwRect aVert( Point( nPosY, aGrid.Top() ),
5050*b1cdbd2cSJim Jagielski Size( nHeight, 1 ) );
5051*b1cdbd2cSJim Jagielski if( bLeft )
5052*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5053*b1cdbd2cSJim Jagielski if( bRight )
5054*b1cdbd2cSJim Jagielski {
5055*b1cdbd2cSJim Jagielski aVert.Pos().Y() = nGridBottom;
5056*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5057*b1cdbd2cSJim Jagielski }
5058*b1cdbd2cSJim Jagielski }
5059*b1cdbd2cSJim Jagielski }
5060*b1cdbd2cSJim Jagielski }
5061*b1cdbd2cSJim Jagielski else
5062*b1cdbd2cSJim Jagielski {
5063*b1cdbd2cSJim Jagielski nY -= nRuby;
5064*b1cdbd2cSJim Jagielski if( bBorder )
5065*b1cdbd2cSJim Jagielski {
5066*b1cdbd2cSJim Jagielski SwTwips nPos = Max( aInter.Left(), nY );
5067*b1cdbd2cSJim Jagielski SwTwips nW = Min(nRight, aTmp.Pos().X()) - nPos;
5068*b1cdbd2cSJim Jagielski SwRect aVert( Point( nPos, aGrid.Top() ),
5069*b1cdbd2cSJim Jagielski Size( nW, 1 ) );
5070*b1cdbd2cSJim Jagielski if( nW > 0 )
5071*b1cdbd2cSJim Jagielski {
5072*b1cdbd2cSJim Jagielski if( bLeft )
5073*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5074*b1cdbd2cSJim Jagielski if( bRight )
5075*b1cdbd2cSJim Jagielski {
5076*b1cdbd2cSJim Jagielski aVert.Pos().Y() = nGridBottom;
5077*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5078*b1cdbd2cSJim Jagielski }
5079*b1cdbd2cSJim Jagielski }
5080*b1cdbd2cSJim Jagielski }
5081*b1cdbd2cSJim Jagielski }
5082*b1cdbd2cSJim Jagielski bGrid = !bGrid;
5083*b1cdbd2cSJim Jagielski }
5084*b1cdbd2cSJim Jagielski while( nY >= aInter.Left() )
5085*b1cdbd2cSJim Jagielski {
5086*b1cdbd2cSJim Jagielski aTmp.Pos().X() = nY;
5087*b1cdbd2cSJim Jagielski PaintBorderLine( rRect, aTmp, this, pCol);
5088*b1cdbd2cSJim Jagielski if( bGrid )
5089*b1cdbd2cSJim Jagielski {
5090*b1cdbd2cSJim Jagielski nY -= nGrid;
5091*b1cdbd2cSJim Jagielski SwTwips nHeight = aTmp.Pos().X()
5092*b1cdbd2cSJim Jagielski - Max(aInter.Left(), nY );
5093*b1cdbd2cSJim Jagielski if( nHeight > 0 )
5094*b1cdbd2cSJim Jagielski {
5095*b1cdbd2cSJim Jagielski if( bCell )
5096*b1cdbd2cSJim Jagielski {
5097*b1cdbd2cSJim Jagielski SwRect aVert( Point(aTmp.Pos().X()-nHeight,
5098*b1cdbd2cSJim Jagielski nX ), Size( nHeight, 1 ) );
5099*b1cdbd2cSJim Jagielski while( aVert.Top() <= nBottom )
5100*b1cdbd2cSJim Jagielski {
5101*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5102*b1cdbd2cSJim Jagielski aVert.Pos().Y() += nGrid;
5103*b1cdbd2cSJim Jagielski }
5104*b1cdbd2cSJim Jagielski }
5105*b1cdbd2cSJim Jagielski else if( bBorder )
5106*b1cdbd2cSJim Jagielski {
5107*b1cdbd2cSJim Jagielski SwRect aVert( Point(aTmp.Pos().X()-nHeight,
5108*b1cdbd2cSJim Jagielski aGrid.Top() ), Size( nHeight, 1 ) );
5109*b1cdbd2cSJim Jagielski if( bLeft )
5110*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5111*b1cdbd2cSJim Jagielski if( bRight )
5112*b1cdbd2cSJim Jagielski {
5113*b1cdbd2cSJim Jagielski aVert.Pos().Y() = nGridBottom;
5114*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5115*b1cdbd2cSJim Jagielski }
5116*b1cdbd2cSJim Jagielski }
5117*b1cdbd2cSJim Jagielski }
5118*b1cdbd2cSJim Jagielski }
5119*b1cdbd2cSJim Jagielski else
5120*b1cdbd2cSJim Jagielski {
5121*b1cdbd2cSJim Jagielski nY -= nRuby;
5122*b1cdbd2cSJim Jagielski if( bBorder )
5123*b1cdbd2cSJim Jagielski {
5124*b1cdbd2cSJim Jagielski SwTwips nPos = Max( aInter.Left(), nY );
5125*b1cdbd2cSJim Jagielski SwTwips nW = Min(nRight, aTmp.Pos().X()) - nPos;
5126*b1cdbd2cSJim Jagielski SwRect aVert( Point( nPos, aGrid.Top() ),
5127*b1cdbd2cSJim Jagielski Size( nW, 1 ) );
5128*b1cdbd2cSJim Jagielski if( nW > 0 )
5129*b1cdbd2cSJim Jagielski {
5130*b1cdbd2cSJim Jagielski if( bLeft )
5131*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5132*b1cdbd2cSJim Jagielski if( bRight )
5133*b1cdbd2cSJim Jagielski {
5134*b1cdbd2cSJim Jagielski aVert.Pos().Y() = nGridBottom;
5135*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5136*b1cdbd2cSJim Jagielski }
5137*b1cdbd2cSJim Jagielski }
5138*b1cdbd2cSJim Jagielski }
5139*b1cdbd2cSJim Jagielski }
5140*b1cdbd2cSJim Jagielski bGrid = !bGrid;
5141*b1cdbd2cSJim Jagielski }
5142*b1cdbd2cSJim Jagielski }
5143*b1cdbd2cSJim Jagielski else
5144*b1cdbd2cSJim Jagielski {
5145*b1cdbd2cSJim Jagielski SwTwips nOrig = aGrid.Top();
5146*b1cdbd2cSJim Jagielski SwTwips nY = nOrig + nSum *( (aInter.Top()-nOrig)/nSum );
5147*b1cdbd2cSJim Jagielski SwRect aTmp( Point( aInter.Left(), nY ),
5148*b1cdbd2cSJim Jagielski Size( aInter.Width(), 1 ) );
5149*b1cdbd2cSJim Jagielski //for textgrid refactor
5150*b1cdbd2cSJim Jagielski SwTwips nX = aGrid.Left() + nGridWidth *
5151*b1cdbd2cSJim Jagielski ( ( aInter.Left() - aGrid.Left() )/ nGridWidth );
5152*b1cdbd2cSJim Jagielski if( nX < aInter.Left() )
5153*b1cdbd2cSJim Jagielski nX += nGridWidth;
5154*b1cdbd2cSJim Jagielski SwTwips nGridRight = aGrid.Left() + aGrid.Width();
5155*b1cdbd2cSJim Jagielski sal_Bool bLeft = aGrid.Left() >= aInter.Left();
5156*b1cdbd2cSJim Jagielski sal_Bool bRight = nGridRight <= nRight;
5157*b1cdbd2cSJim Jagielski sal_Bool bBorder = bLeft || bRight;
5158*b1cdbd2cSJim Jagielski while( nY < aInter.Top() )
5159*b1cdbd2cSJim Jagielski {
5160*b1cdbd2cSJim Jagielski aTmp.Pos().Y() = nY;
5161*b1cdbd2cSJim Jagielski if( bGrid )
5162*b1cdbd2cSJim Jagielski {
5163*b1cdbd2cSJim Jagielski nY += nGrid;
5164*b1cdbd2cSJim Jagielski SwTwips nPosY = Max( aInter.Top(), aTmp.Pos().Y() );
5165*b1cdbd2cSJim Jagielski SwTwips nHeight = Min(nBottom, nY ) - nPosY;
5166*b1cdbd2cSJim Jagielski if( nHeight )
5167*b1cdbd2cSJim Jagielski {
5168*b1cdbd2cSJim Jagielski if( bCell )
5169*b1cdbd2cSJim Jagielski {
5170*b1cdbd2cSJim Jagielski SwRect aVert( Point( nX, nPosY ),
5171*b1cdbd2cSJim Jagielski Size( 1, nHeight ) );
5172*b1cdbd2cSJim Jagielski while( aVert.Left() <= nRight )
5173*b1cdbd2cSJim Jagielski {
5174*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5175*b1cdbd2cSJim Jagielski aVert.Pos().X() += nGridWidth; //for textgrid refactor
5176*b1cdbd2cSJim Jagielski }
5177*b1cdbd2cSJim Jagielski }
5178*b1cdbd2cSJim Jagielski else if ( bBorder )
5179*b1cdbd2cSJim Jagielski {
5180*b1cdbd2cSJim Jagielski SwRect aVert( Point( aGrid.Left(), nPosY ),
5181*b1cdbd2cSJim Jagielski Size( 1, nHeight ) );
5182*b1cdbd2cSJim Jagielski if( bLeft )
5183*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5184*b1cdbd2cSJim Jagielski if( bRight )
5185*b1cdbd2cSJim Jagielski {
5186*b1cdbd2cSJim Jagielski aVert.Pos().X() = nGridRight;
5187*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5188*b1cdbd2cSJim Jagielski }
5189*b1cdbd2cSJim Jagielski }
5190*b1cdbd2cSJim Jagielski }
5191*b1cdbd2cSJim Jagielski }
5192*b1cdbd2cSJim Jagielski else
5193*b1cdbd2cSJim Jagielski {
5194*b1cdbd2cSJim Jagielski nY += nRuby;
5195*b1cdbd2cSJim Jagielski if( bBorder )
5196*b1cdbd2cSJim Jagielski {
5197*b1cdbd2cSJim Jagielski SwTwips nPos = Max(aInter.Top(),aTmp.Pos().Y());
5198*b1cdbd2cSJim Jagielski SwTwips nH = Min( nBottom, nY ) - nPos;
5199*b1cdbd2cSJim Jagielski SwRect aVert( Point( aGrid.Left(), nPos ),
5200*b1cdbd2cSJim Jagielski Size( 1, nH ) );
5201*b1cdbd2cSJim Jagielski if( nH > 0 )
5202*b1cdbd2cSJim Jagielski {
5203*b1cdbd2cSJim Jagielski if( bLeft )
5204*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5205*b1cdbd2cSJim Jagielski if( bRight )
5206*b1cdbd2cSJim Jagielski {
5207*b1cdbd2cSJim Jagielski aVert.Pos().X() = nGridRight;
5208*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5209*b1cdbd2cSJim Jagielski }
5210*b1cdbd2cSJim Jagielski }
5211*b1cdbd2cSJim Jagielski }
5212*b1cdbd2cSJim Jagielski }
5213*b1cdbd2cSJim Jagielski bGrid = !bGrid;
5214*b1cdbd2cSJim Jagielski }
5215*b1cdbd2cSJim Jagielski while( nY <= nBottom )
5216*b1cdbd2cSJim Jagielski {
5217*b1cdbd2cSJim Jagielski aTmp.Pos().Y() = nY;
5218*b1cdbd2cSJim Jagielski PaintBorderLine( rRect, aTmp, this, pCol);
5219*b1cdbd2cSJim Jagielski if( bGrid )
5220*b1cdbd2cSJim Jagielski {
5221*b1cdbd2cSJim Jagielski nY += nGrid;
5222*b1cdbd2cSJim Jagielski SwTwips nHeight = Min(nBottom, nY) - aTmp.Pos().Y();
5223*b1cdbd2cSJim Jagielski if( nHeight )
5224*b1cdbd2cSJim Jagielski {
5225*b1cdbd2cSJim Jagielski if( bCell )
5226*b1cdbd2cSJim Jagielski {
5227*b1cdbd2cSJim Jagielski SwRect aVert( Point( nX, aTmp.Pos().Y() ),
5228*b1cdbd2cSJim Jagielski Size( 1, nHeight ) );
5229*b1cdbd2cSJim Jagielski while( aVert.Left() <= nRight )
5230*b1cdbd2cSJim Jagielski {
5231*b1cdbd2cSJim Jagielski PaintBorderLine( rRect, aVert, this, pCol);
5232*b1cdbd2cSJim Jagielski aVert.Pos().X() += nGridWidth; //for textgrid refactor
5233*b1cdbd2cSJim Jagielski }
5234*b1cdbd2cSJim Jagielski }
5235*b1cdbd2cSJim Jagielski else if( bBorder )
5236*b1cdbd2cSJim Jagielski {
5237*b1cdbd2cSJim Jagielski SwRect aVert( Point( aGrid.Left(),
5238*b1cdbd2cSJim Jagielski aTmp.Pos().Y() ), Size( 1, nHeight ) );
5239*b1cdbd2cSJim Jagielski if( bLeft )
5240*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5241*b1cdbd2cSJim Jagielski if( bRight )
5242*b1cdbd2cSJim Jagielski {
5243*b1cdbd2cSJim Jagielski aVert.Pos().X() = nGridRight;
5244*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5245*b1cdbd2cSJim Jagielski }
5246*b1cdbd2cSJim Jagielski }
5247*b1cdbd2cSJim Jagielski }
5248*b1cdbd2cSJim Jagielski }
5249*b1cdbd2cSJim Jagielski else
5250*b1cdbd2cSJim Jagielski {
5251*b1cdbd2cSJim Jagielski nY += nRuby;
5252*b1cdbd2cSJim Jagielski if( bBorder )
5253*b1cdbd2cSJim Jagielski {
5254*b1cdbd2cSJim Jagielski SwTwips nPos = Max(aInter.Top(),aTmp.Pos().Y());
5255*b1cdbd2cSJim Jagielski SwTwips nH = Min( nBottom, nY ) - nPos;
5256*b1cdbd2cSJim Jagielski SwRect aVert( Point( aGrid.Left(), nPos ),
5257*b1cdbd2cSJim Jagielski Size( 1, nH ) );
5258*b1cdbd2cSJim Jagielski if( nH > 0 )
5259*b1cdbd2cSJim Jagielski {
5260*b1cdbd2cSJim Jagielski if( bLeft )
5261*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5262*b1cdbd2cSJim Jagielski if( bRight )
5263*b1cdbd2cSJim Jagielski {
5264*b1cdbd2cSJim Jagielski aVert.Pos().X() = nGridRight;
5265*b1cdbd2cSJim Jagielski PaintBorderLine(rRect,aVert,this,pCol);
5266*b1cdbd2cSJim Jagielski }
5267*b1cdbd2cSJim Jagielski }
5268*b1cdbd2cSJim Jagielski }
5269*b1cdbd2cSJim Jagielski }
5270*b1cdbd2cSJim Jagielski bGrid = !bGrid;
5271*b1cdbd2cSJim Jagielski }
5272*b1cdbd2cSJim Jagielski }
5273*b1cdbd2cSJim Jagielski }
5274*b1cdbd2cSJim Jagielski }
5275*b1cdbd2cSJim Jagielski }
5276*b1cdbd2cSJim Jagielski }
5277*b1cdbd2cSJim Jagielski
5278*b1cdbd2cSJim Jagielski /** paint margin area of a page
5279*b1cdbd2cSJim Jagielski
5280*b1cdbd2cSJim Jagielski OD 20.11.2002 for #104598#:
5281*b1cdbd2cSJim Jagielski implement paint of margin area; margin area will be painted for a
5282*b1cdbd2cSJim Jagielski view shell with a window and if the document is not in online layout.
5283*b1cdbd2cSJim Jagielski
5284*b1cdbd2cSJim Jagielski @author OD
5285*b1cdbd2cSJim Jagielski
5286*b1cdbd2cSJim Jagielski @param _rOutputRect
5287*b1cdbd2cSJim Jagielski input parameter - constant instance reference of the rectangle, for
5288*b1cdbd2cSJim Jagielski which an output has to be generated.
5289*b1cdbd2cSJim Jagielski
5290*b1cdbd2cSJim Jagielski @param _pViewShell
5291*b1cdbd2cSJim Jagielski input parameter - instance of the view shell, on which the output
5292*b1cdbd2cSJim Jagielski has to be generated.
5293*b1cdbd2cSJim Jagielski */
PaintMarginArea(const SwRect & _rOutputRect,ViewShell * _pViewShell) const5294*b1cdbd2cSJim Jagielski void SwPageFrm::PaintMarginArea( const SwRect& _rOutputRect,
5295*b1cdbd2cSJim Jagielski ViewShell* _pViewShell ) const
5296*b1cdbd2cSJim Jagielski {
5297*b1cdbd2cSJim Jagielski if ( _pViewShell->GetWin() &&
5298*b1cdbd2cSJim Jagielski !_pViewShell->GetViewOptions()->getBrowseMode() )
5299*b1cdbd2cSJim Jagielski {
5300*b1cdbd2cSJim Jagielski SwRect aPgPrtRect( Prt() );
5301*b1cdbd2cSJim Jagielski aPgPrtRect.Pos() += Frm().Pos();
5302*b1cdbd2cSJim Jagielski if ( !aPgPrtRect.IsInside( _rOutputRect ) )
5303*b1cdbd2cSJim Jagielski {
5304*b1cdbd2cSJim Jagielski SwRect aPgRect = Frm();
5305*b1cdbd2cSJim Jagielski aPgRect._Intersection( _rOutputRect );
5306*b1cdbd2cSJim Jagielski SwRegionRects aPgRegion( aPgRect );
5307*b1cdbd2cSJim Jagielski aPgRegion -= aPgPrtRect;
5308*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = static_cast<const SwPageFrm*>(this);
5309*b1cdbd2cSJim Jagielski if ( pPage->GetSortedObjs() )
5310*b1cdbd2cSJim Jagielski ::lcl_SubtractFlys( this, pPage, aPgRect, aPgRegion );
5311*b1cdbd2cSJim Jagielski if ( aPgRegion.Count() )
5312*b1cdbd2cSJim Jagielski {
5313*b1cdbd2cSJim Jagielski OutputDevice *pOut = _pViewShell->GetOut();
5314*b1cdbd2cSJim Jagielski if ( pOut->GetFillColor() != aGlobalRetoucheColor )
5315*b1cdbd2cSJim Jagielski pOut->SetFillColor( aGlobalRetoucheColor );
5316*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aPgRegion.Count(); ++i )
5317*b1cdbd2cSJim Jagielski {
5318*b1cdbd2cSJim Jagielski if ( 1 < aPgRegion.Count() )
5319*b1cdbd2cSJim Jagielski {
5320*b1cdbd2cSJim Jagielski ::SwAlignRect( aPgRegion[i], pGlobalShell );
5321*b1cdbd2cSJim Jagielski if( !aPgRegion[i].HasArea() )
5322*b1cdbd2cSJim Jagielski continue;
5323*b1cdbd2cSJim Jagielski }
5324*b1cdbd2cSJim Jagielski pOut->DrawRect(aPgRegion[i].SVRect());
5325*b1cdbd2cSJim Jagielski }
5326*b1cdbd2cSJim Jagielski }
5327*b1cdbd2cSJim Jagielski }
5328*b1cdbd2cSJim Jagielski }
5329*b1cdbd2cSJim Jagielski }
5330*b1cdbd2cSJim Jagielski
5331*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------
5332*b1cdbd2cSJim Jagielski //
5333*b1cdbd2cSJim Jagielski // const SwPageFrm::mnBorderPxWidth, const SwPageFrm::mnShadowPxWidth
5334*b1cdbd2cSJim Jagielski // SwPageFrm::GetBorderRect (..), SwPageFrm::GetRightShadowRect(..),
5335*b1cdbd2cSJim Jagielski // SwPageFrm::GetBottomShadowRect(..),
5336*b1cdbd2cSJim Jagielski // SwPageFrm::PaintBorderAndShadow(..),
5337*b1cdbd2cSJim Jagielski // SwPageFrm::GetBorderAndShadowBoundRect(..)
5338*b1cdbd2cSJim Jagielski //
5339*b1cdbd2cSJim Jagielski // OD 12.02.2003 for #i9719# and #105645#
5340*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------
5341*b1cdbd2cSJim Jagielski
5342*b1cdbd2cSJim Jagielski const sal_Int8 SwPageFrm::mnBorderPxWidth = 1;
5343*b1cdbd2cSJim Jagielski const sal_Int8 SwPageFrm::mnShadowPxWidth = 2;
5344*b1cdbd2cSJim Jagielski
5345*b1cdbd2cSJim Jagielski /** determine rectangle for page border
5346*b1cdbd2cSJim Jagielski
5347*b1cdbd2cSJim Jagielski OD 12.02.2003 for #i9719# and #105645#
5348*b1cdbd2cSJim Jagielski
5349*b1cdbd2cSJim Jagielski @author OD
5350*b1cdbd2cSJim Jagielski */
GetBorderRect(const SwRect & _rPageRect,ViewShell * _pViewShell,SwRect & _orBorderRect,bool bRightSidebar)5351*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::GetBorderRect( const SwRect& _rPageRect,
5352*b1cdbd2cSJim Jagielski ViewShell* _pViewShell,
5353*b1cdbd2cSJim Jagielski SwRect& _orBorderRect,
5354*b1cdbd2cSJim Jagielski bool bRightSidebar )
5355*b1cdbd2cSJim Jagielski {
5356*b1cdbd2cSJim Jagielski SwRect aAlignedPageRect( _rPageRect );
5357*b1cdbd2cSJim Jagielski ::SwAlignRect( aAlignedPageRect, _pViewShell );
5358*b1cdbd2cSJim Jagielski Rectangle aBorderPxRect =
5359*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->LogicToPixel( aAlignedPageRect.SVRect() );
5360*b1cdbd2cSJim Jagielski
5361*b1cdbd2cSJim Jagielski aBorderPxRect.Left() = aBorderPxRect.Left() - mnBorderPxWidth;
5362*b1cdbd2cSJim Jagielski aBorderPxRect.Top() = aBorderPxRect.Top() - mnBorderPxWidth;
5363*b1cdbd2cSJim Jagielski aBorderPxRect.Right() = aBorderPxRect.Right() + mnBorderPxWidth;
5364*b1cdbd2cSJim Jagielski aBorderPxRect.Bottom() = aBorderPxRect.Bottom() + mnBorderPxWidth;
5365*b1cdbd2cSJim Jagielski
5366*b1cdbd2cSJim Jagielski AddSidebarBorders(aBorderPxRect,_pViewShell, bRightSidebar, true);
5367*b1cdbd2cSJim Jagielski
5368*b1cdbd2cSJim Jagielski _orBorderRect =
5369*b1cdbd2cSJim Jagielski SwRect( _pViewShell->GetOut()->PixelToLogic( aBorderPxRect ) );
5370*b1cdbd2cSJim Jagielski }
5371*b1cdbd2cSJim Jagielski
5372*b1cdbd2cSJim Jagielski /** determine rectangle for right page shadow
5373*b1cdbd2cSJim Jagielski
5374*b1cdbd2cSJim Jagielski OD 12.02.2003 for #i9719# and #105645#
5375*b1cdbd2cSJim Jagielski
5376*b1cdbd2cSJim Jagielski @author OD
5377*b1cdbd2cSJim Jagielski */
GetRightShadowRect(const SwRect & _rPageRect,ViewShell * _pViewShell,SwRect & _orRightShadowRect,bool bRightSidebar)5378*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::GetRightShadowRect( const SwRect& _rPageRect,
5379*b1cdbd2cSJim Jagielski ViewShell* _pViewShell,
5380*b1cdbd2cSJim Jagielski SwRect& _orRightShadowRect,
5381*b1cdbd2cSJim Jagielski bool bRightSidebar )
5382*b1cdbd2cSJim Jagielski {
5383*b1cdbd2cSJim Jagielski SwRect aAlignedPageRect( _rPageRect );
5384*b1cdbd2cSJim Jagielski ::SwAlignRect( aAlignedPageRect, _pViewShell );
5385*b1cdbd2cSJim Jagielski Rectangle aPagePxRect =
5386*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->LogicToPixel( aAlignedPageRect.SVRect() );
5387*b1cdbd2cSJim Jagielski
5388*b1cdbd2cSJim Jagielski Rectangle aRightShadowPxRect(
5389*b1cdbd2cSJim Jagielski aPagePxRect.Right() + mnShadowPxWidth,
5390*b1cdbd2cSJim Jagielski aPagePxRect.Top() + 1,
5391*b1cdbd2cSJim Jagielski aPagePxRect.Right() + mnBorderPxWidth + mnShadowPxWidth,
5392*b1cdbd2cSJim Jagielski aPagePxRect.Bottom() + mnBorderPxWidth + mnShadowPxWidth );
5393*b1cdbd2cSJim Jagielski
5394*b1cdbd2cSJim Jagielski if ( bRightSidebar )
5395*b1cdbd2cSJim Jagielski AddSidebarBorders(aRightShadowPxRect,_pViewShell, bRightSidebar, true);
5396*b1cdbd2cSJim Jagielski
5397*b1cdbd2cSJim Jagielski _orRightShadowRect =
5398*b1cdbd2cSJim Jagielski SwRect( _pViewShell->GetOut()->PixelToLogic( aRightShadowPxRect ) );
5399*b1cdbd2cSJim Jagielski }
5400*b1cdbd2cSJim Jagielski
5401*b1cdbd2cSJim Jagielski /** determine rectangle for bottom page shadow
5402*b1cdbd2cSJim Jagielski
5403*b1cdbd2cSJim Jagielski OD 12.02.2003 for #i9719# and #105645#
5404*b1cdbd2cSJim Jagielski
5405*b1cdbd2cSJim Jagielski @author OD
5406*b1cdbd2cSJim Jagielski */
GetBottomShadowRect(const SwRect & _rPageRect,ViewShell * _pViewShell,SwRect & _orBottomShadowRect,bool bRightSidebar)5407*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::GetBottomShadowRect( const SwRect& _rPageRect,
5408*b1cdbd2cSJim Jagielski ViewShell* _pViewShell,
5409*b1cdbd2cSJim Jagielski SwRect& _orBottomShadowRect,
5410*b1cdbd2cSJim Jagielski bool bRightSidebar )
5411*b1cdbd2cSJim Jagielski {
5412*b1cdbd2cSJim Jagielski SwRect aAlignedPageRect( _rPageRect );
5413*b1cdbd2cSJim Jagielski ::SwAlignRect( aAlignedPageRect, _pViewShell );
5414*b1cdbd2cSJim Jagielski Rectangle aPagePxRect =
5415*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->LogicToPixel( aAlignedPageRect.SVRect() );
5416*b1cdbd2cSJim Jagielski
5417*b1cdbd2cSJim Jagielski Rectangle aBottomShadowPxRect(
5418*b1cdbd2cSJim Jagielski aPagePxRect.Left() + 1,
5419*b1cdbd2cSJim Jagielski aPagePxRect.Bottom() + mnShadowPxWidth,
5420*b1cdbd2cSJim Jagielski aPagePxRect.Right() + mnBorderPxWidth + mnShadowPxWidth,
5421*b1cdbd2cSJim Jagielski aPagePxRect.Bottom() + mnBorderPxWidth + mnShadowPxWidth );
5422*b1cdbd2cSJim Jagielski
5423*b1cdbd2cSJim Jagielski AddSidebarBorders(aBottomShadowPxRect,_pViewShell, bRightSidebar, true);
5424*b1cdbd2cSJim Jagielski
5425*b1cdbd2cSJim Jagielski _orBottomShadowRect =
5426*b1cdbd2cSJim Jagielski SwRect( _pViewShell->GetOut()->PixelToLogic( aBottomShadowPxRect ) );
5427*b1cdbd2cSJim Jagielski }
5428*b1cdbd2cSJim Jagielski
5429*b1cdbd2cSJim Jagielski /** paint page border and shadow
5430*b1cdbd2cSJim Jagielski
5431*b1cdbd2cSJim Jagielski OD 12.02.2003 for #i9719# and #105645#
5432*b1cdbd2cSJim Jagielski implement paint of page border and shadow
5433*b1cdbd2cSJim Jagielski
5434*b1cdbd2cSJim Jagielski @author OD
5435*b1cdbd2cSJim Jagielski */
PaintBorderAndShadow(const SwRect & _rPageRect,ViewShell * _pViewShell,bool bPaintRightShadow,bool bRightSidebar)5436*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::PaintBorderAndShadow( const SwRect& _rPageRect,
5437*b1cdbd2cSJim Jagielski ViewShell* _pViewShell,
5438*b1cdbd2cSJim Jagielski bool bPaintRightShadow,
5439*b1cdbd2cSJim Jagielski bool bRightSidebar )
5440*b1cdbd2cSJim Jagielski {
5441*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
5442*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *_pViewShell->GetOut() );
5443*b1cdbd2cSJim Jagielski // <--
5444*b1cdbd2cSJim Jagielski
5445*b1cdbd2cSJim Jagielski // get color for page border and shadow paint
5446*b1cdbd2cSJim Jagielski const Color& rColor = SwViewOption::GetFontColor();
5447*b1cdbd2cSJim Jagielski
5448*b1cdbd2cSJim Jagielski // save current fill and line color of output device
5449*b1cdbd2cSJim Jagielski Color aFill( _pViewShell->GetOut()->GetFillColor() );
5450*b1cdbd2cSJim Jagielski Color aLine( _pViewShell->GetOut()->GetLineColor() );
5451*b1cdbd2cSJim Jagielski
5452*b1cdbd2cSJim Jagielski // paint page border
5453*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(); // OD 20.02.2003 #107369# - no fill color
5454*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor( rColor );
5455*b1cdbd2cSJim Jagielski SwRect aPaintRect;
5456*b1cdbd2cSJim Jagielski SwPageFrm::GetBorderRect( _rPageRect, _pViewShell, aPaintRect, bRightSidebar );
5457*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect( aPaintRect.SVRect() );
5458*b1cdbd2cSJim Jagielski
5459*b1cdbd2cSJim Jagielski // paint right shadow
5460*b1cdbd2cSJim Jagielski if ( bPaintRightShadow )
5461*b1cdbd2cSJim Jagielski {
5462*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor( rColor );
5463*b1cdbd2cSJim Jagielski SwPageFrm::GetRightShadowRect( _rPageRect, _pViewShell, aPaintRect, bRightSidebar );
5464*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect( aPaintRect.SVRect() );
5465*b1cdbd2cSJim Jagielski }
5466*b1cdbd2cSJim Jagielski
5467*b1cdbd2cSJim Jagielski // paint bottom shadow
5468*b1cdbd2cSJim Jagielski SwPageFrm::GetBottomShadowRect( _rPageRect, _pViewShell, aPaintRect, bRightSidebar );
5469*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect( aPaintRect.SVRect() );
5470*b1cdbd2cSJim Jagielski
5471*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor( aFill );
5472*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor( aLine );
5473*b1cdbd2cSJim Jagielski }
5474*b1cdbd2cSJim Jagielski
5475*b1cdbd2cSJim Jagielski //mod #i6193# paint sidebar for notes
5476*b1cdbd2cSJim Jagielski //IMPORTANT: if you change the rects here, also change SwPostItMgr::ScrollbarHit
PaintNotesSidebar(const SwRect & _rPageRect,ViewShell * _pViewShell,sal_uInt16 nPageNum,bool bRight)5477*b1cdbd2cSJim Jagielski /*static*/void SwPageFrm::PaintNotesSidebar(const SwRect& _rPageRect, ViewShell* _pViewShell, sal_uInt16 nPageNum, bool bRight)
5478*b1cdbd2cSJim Jagielski {
5479*b1cdbd2cSJim Jagielski //TOOD: cut out scrollbar area and arrows out of sidepane rect, otherwise it could flicker when pressing arrow buttons
5480*b1cdbd2cSJim Jagielski if (!_pViewShell )
5481*b1cdbd2cSJim Jagielski return;
5482*b1cdbd2cSJim Jagielski
5483*b1cdbd2cSJim Jagielski SwRect aPageRect( _rPageRect );
5484*b1cdbd2cSJim Jagielski SwAlignRect( aPageRect, _pViewShell );
5485*b1cdbd2cSJim Jagielski
5486*b1cdbd2cSJim Jagielski const SwPostItMgr *pMgr = _pViewShell->GetPostItMgr();
5487*b1cdbd2cSJim Jagielski if (pMgr && pMgr->ShowNotes() && pMgr->HasNotes()) // do not show anything in print preview
5488*b1cdbd2cSJim Jagielski {
5489*b1cdbd2cSJim Jagielski sal_Int32 nScrollerHeight = pMgr->GetSidebarScrollerHeight();
5490*b1cdbd2cSJim Jagielski const Rectangle &aVisRect = _pViewShell->VisArea().SVRect();
5491*b1cdbd2cSJim Jagielski //draw border and sidepane
5492*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor();
5493*b1cdbd2cSJim Jagielski if (!bRight)
5494*b1cdbd2cSJim Jagielski {
5495*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE_BORDER);
5496*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(Rectangle(Point(aPageRect.Left()-pMgr->GetSidebarBorderWidth(),aPageRect.Top()),Size(pMgr->GetSidebarBorderWidth(),aPageRect.Height()))) ;
5497*b1cdbd2cSJim Jagielski if (Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
5498*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_BLACK);
5499*b1cdbd2cSJim Jagielski else
5500*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE);
5501*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(Rectangle(Point(aPageRect.Left()-pMgr->GetSidebarWidth()-pMgr->GetSidebarBorderWidth(),aPageRect.Top()),Size(pMgr->GetSidebarWidth(),aPageRect.Height()))) ;
5502*b1cdbd2cSJim Jagielski }
5503*b1cdbd2cSJim Jagielski else
5504*b1cdbd2cSJim Jagielski {
5505*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE_BORDER);
5506*b1cdbd2cSJim Jagielski SwRect aSidebarBorder(aPageRect.TopRight(),Size(pMgr->GetSidebarBorderWidth(),aPageRect.Height()));
5507*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(aSidebarBorder.SVRect());
5508*b1cdbd2cSJim Jagielski if (Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
5509*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_BLACK);
5510*b1cdbd2cSJim Jagielski else
5511*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE);
5512*b1cdbd2cSJim Jagielski SwRect aSidebar(Point(aPageRect.Right()+pMgr->GetSidebarBorderWidth(),aPageRect.Top()),Size(pMgr->GetSidebarWidth(),aPageRect.Height()));
5513*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(aSidebar.SVRect());
5514*b1cdbd2cSJim Jagielski }
5515*b1cdbd2cSJim Jagielski if (pMgr->ShowScrollbar(nPageNum))
5516*b1cdbd2cSJim Jagielski {
5517*b1cdbd2cSJim Jagielski // draw scrollbar area and arrows
5518*b1cdbd2cSJim Jagielski Point aPointBottom;
5519*b1cdbd2cSJim Jagielski Point aPointTop;
5520*b1cdbd2cSJim Jagielski aPointBottom = !bRight ? Point(aPageRect.Left() - pMgr->GetSidebarWidth() - pMgr->GetSidebarBorderWidth() + _pViewShell->GetOut()->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- _pViewShell->GetOut()->PixelToLogic(Size(0,2+pMgr->GetSidebarScrollerHeight())).Height()) :
5521*b1cdbd2cSJim Jagielski Point(aPageRect.Right() + pMgr->GetSidebarBorderWidth() + _pViewShell->GetOut()->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- _pViewShell->GetOut()->PixelToLogic(Size(0,2+pMgr->GetSidebarScrollerHeight())).Height());
5522*b1cdbd2cSJim Jagielski aPointTop = !bRight ? Point(aPageRect.Left() - pMgr->GetSidebarWidth() + _pViewShell->GetOut()->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + _pViewShell->GetOut()->PixelToLogic(Size(0,2)).Height()) :
5523*b1cdbd2cSJim Jagielski Point(aPageRect.Right() + pMgr->GetSidebarBorderWidth() + _pViewShell->GetOut()->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + _pViewShell->GetOut()->PixelToLogic(Size(0,2)).Height());
5524*b1cdbd2cSJim Jagielski Size aSize(pMgr->GetSidebarWidth() - _pViewShell->GetOut()->PixelToLogic(Size(4,0)).Width(), _pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()) ;
5525*b1cdbd2cSJim Jagielski Rectangle aRectBottom(aPointBottom,aSize);
5526*b1cdbd2cSJim Jagielski Rectangle aRectTop(aPointTop,aSize);
5527*b1cdbd2cSJim Jagielski
5528*b1cdbd2cSJim Jagielski if (aRectBottom.IsOver(aVisRect))
5529*b1cdbd2cSJim Jagielski {
5530*b1cdbd2cSJim Jagielski
5531*b1cdbd2cSJim Jagielski if (Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
5532*b1cdbd2cSJim Jagielski {
5533*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor(COL_WHITE);
5534*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_BLACK);
5535*b1cdbd2cSJim Jagielski }
5536*b1cdbd2cSJim Jagielski else
5537*b1cdbd2cSJim Jagielski {
5538*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor(COL_BLACK);
5539*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE_SCROLLAREA);
5540*b1cdbd2cSJim Jagielski }
5541*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(aRectBottom);
5542*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawLine(aPointBottom + Point(pMgr->GetSidebarWidth()/3,0), aPointBottom + Point(pMgr->GetSidebarWidth()/3 , _pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()));
5543*b1cdbd2cSJim Jagielski
5544*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor();
5545*b1cdbd2cSJim Jagielski Point aMiddleFirst(aPointBottom + Point(pMgr->GetSidebarWidth()/6,_pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()/2));
5546*b1cdbd2cSJim Jagielski Point aMiddleSecond(aPointBottom + Point(pMgr->GetSidebarWidth()/3*2,_pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()/2));
5547*b1cdbd2cSJim Jagielski PaintNotesSidebarArrows(aMiddleFirst,aMiddleSecond,_pViewShell,pMgr->GetArrowColor(KEY_PAGEUP,nPageNum), pMgr->GetArrowColor(KEY_PAGEDOWN,nPageNum));
5548*b1cdbd2cSJim Jagielski }
5549*b1cdbd2cSJim Jagielski if (aRectTop.IsOver(aVisRect))
5550*b1cdbd2cSJim Jagielski {
5551*b1cdbd2cSJim Jagielski if (Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
5552*b1cdbd2cSJim Jagielski {
5553*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor(COL_WHITE);
5554*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_BLACK);
5555*b1cdbd2cSJim Jagielski }
5556*b1cdbd2cSJim Jagielski else
5557*b1cdbd2cSJim Jagielski {
5558*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor(COL_BLACK);
5559*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(COL_NOTES_SIDEPANE_SCROLLAREA);
5560*b1cdbd2cSJim Jagielski }
5561*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawRect(aRectTop);
5562*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawLine(aPointTop + Point(pMgr->GetSidebarWidth()/3*2,0), aPointTop + Point(pMgr->GetSidebarWidth()/3*2 , _pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()));
5563*b1cdbd2cSJim Jagielski
5564*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetLineColor();
5565*b1cdbd2cSJim Jagielski Point aMiddleFirst(aPointTop + Point(pMgr->GetSidebarWidth()/3,_pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()/2));
5566*b1cdbd2cSJim Jagielski Point aMiddleSecond(aPointTop + Point(pMgr->GetSidebarWidth()/6*5,_pViewShell->GetOut()->PixelToLogic(Size(0,nScrollerHeight)).Height()/2));
5567*b1cdbd2cSJim Jagielski PaintNotesSidebarArrows(aMiddleFirst,aMiddleSecond,_pViewShell, pMgr->GetArrowColor(KEY_PAGEUP,nPageNum), pMgr->GetArrowColor(KEY_PAGEDOWN,nPageNum));
5568*b1cdbd2cSJim Jagielski }
5569*b1cdbd2cSJim Jagielski }
5570*b1cdbd2cSJim Jagielski }
5571*b1cdbd2cSJim Jagielski }
5572*b1cdbd2cSJim Jagielski
PaintNotesSidebarArrows(const Point & aMiddleFirst,const Point & aMiddleSecond,ViewShell * _pViewShell,const Color aColorUp,const Color aColorDown)5573*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::PaintNotesSidebarArrows(const Point &aMiddleFirst, const Point &aMiddleSecond, ViewShell* _pViewShell, const Color aColorUp, const Color aColorDown)
5574*b1cdbd2cSJim Jagielski {
5575*b1cdbd2cSJim Jagielski Polygon aTriangleUp(3);
5576*b1cdbd2cSJim Jagielski Polygon aTriangleDown(3);
5577*b1cdbd2cSJim Jagielski
5578*b1cdbd2cSJim Jagielski aTriangleUp.SetPoint(aMiddleFirst + Point(0,_pViewShell->GetOut()->PixelToLogic(Size(0,-3)).Height()),0);
5579*b1cdbd2cSJim Jagielski aTriangleUp.SetPoint(aMiddleFirst + Point(_pViewShell->GetOut()->PixelToLogic(Size(-3,0)).Width(),_pViewShell->GetOut()->PixelToLogic(Size(0,3)).Height()),1);
5580*b1cdbd2cSJim Jagielski aTriangleUp.SetPoint(aMiddleFirst + Point(_pViewShell->GetOut()->PixelToLogic(Size(3,0)).Width(),_pViewShell->GetOut()->PixelToLogic(Size(0,3)).Height()),2);
5581*b1cdbd2cSJim Jagielski
5582*b1cdbd2cSJim Jagielski aTriangleDown.SetPoint(aMiddleSecond + Point(_pViewShell->GetOut()->PixelToLogic(Size(-3,0)).Width(),_pViewShell->GetOut()->PixelToLogic(Size(0,-3)).Height()),0);
5583*b1cdbd2cSJim Jagielski aTriangleDown.SetPoint(aMiddleSecond + Point(_pViewShell->GetOut()->PixelToLogic(Size(+3,0)).Width(),_pViewShell->GetOut()->PixelToLogic(Size(0,-3)).Height()),1);
5584*b1cdbd2cSJim Jagielski aTriangleDown.SetPoint(aMiddleSecond + Point(0,_pViewShell->GetOut()->PixelToLogic(Size(0,3)).Height()),2);
5585*b1cdbd2cSJim Jagielski
5586*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(aColorUp);
5587*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawPolygon(aTriangleUp);
5588*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->SetFillColor(aColorDown);
5589*b1cdbd2cSJim Jagielski _pViewShell->GetOut()->DrawPolygon(aTriangleDown);
5590*b1cdbd2cSJim Jagielski }
5591*b1cdbd2cSJim Jagielski
5592*b1cdbd2cSJim Jagielski /** get bound rectangle of border and shadow for repaints
5593*b1cdbd2cSJim Jagielski
5594*b1cdbd2cSJim Jagielski OD 12.02.2003 for #i9719# and #105645#
5595*b1cdbd2cSJim Jagielski
5596*b1cdbd2cSJim Jagielski author OD
5597*b1cdbd2cSJim Jagielski */
GetBorderAndShadowBoundRect(const SwRect & _rPageRect,ViewShell * _pViewShell,SwRect & _orBorderAndShadowBoundRect,bool bRightSidebar)5598*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::GetBorderAndShadowBoundRect( const SwRect& _rPageRect,
5599*b1cdbd2cSJim Jagielski ViewShell* _pViewShell,
5600*b1cdbd2cSJim Jagielski SwRect& _orBorderAndShadowBoundRect,
5601*b1cdbd2cSJim Jagielski bool bRightSidebar )
5602*b1cdbd2cSJim Jagielski {
5603*b1cdbd2cSJim Jagielski SwRect aTmpRect;
5604*b1cdbd2cSJim Jagielski SwPageFrm::GetBorderRect( _rPageRect, _pViewShell, _orBorderAndShadowBoundRect, bRightSidebar );
5605*b1cdbd2cSJim Jagielski SwPageFrm::GetRightShadowRect( _rPageRect, _pViewShell, aTmpRect, bRightSidebar );
5606*b1cdbd2cSJim Jagielski _orBorderAndShadowBoundRect.Union( aTmpRect );
5607*b1cdbd2cSJim Jagielski SwPageFrm::GetBottomShadowRect( _rPageRect, _pViewShell, aTmpRect, bRightSidebar );
5608*b1cdbd2cSJim Jagielski _orBorderAndShadowBoundRect.Union( aTmpRect );
5609*b1cdbd2cSJim Jagielski
5610*b1cdbd2cSJim Jagielski AddSidebarBorders(_orBorderAndShadowBoundRect, _pViewShell, bRightSidebar, false);
5611*b1cdbd2cSJim Jagielski }
5612*b1cdbd2cSJim Jagielski
AddSidebarBorders(SwRect & aRect,ViewShell * _pViewShell,bool bRightSidebar,bool bPx)5613*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::AddSidebarBorders(SwRect &aRect, ViewShell* _pViewShell, bool bRightSidebar, bool bPx)
5614*b1cdbd2cSJim Jagielski {
5615*b1cdbd2cSJim Jagielski const SwPostItMgr *pMgr = _pViewShell ? _pViewShell->GetPostItMgr() : 0;
5616*b1cdbd2cSJim Jagielski if (pMgr && pMgr->ShowNotes() && pMgr->HasNotes())
5617*b1cdbd2cSJim Jagielski {
5618*b1cdbd2cSJim Jagielski if (!bRightSidebar)
5619*b1cdbd2cSJim Jagielski aRect.SetLeftAndWidth(aRect.Left() - pMgr->GetSidebarWidth(bPx) - pMgr->GetSidebarBorderWidth(bPx), aRect.Width() + pMgr->GetSidebarWidth(bPx) + pMgr->GetSidebarBorderWidth(bPx));
5620*b1cdbd2cSJim Jagielski else
5621*b1cdbd2cSJim Jagielski aRect.AddRight(pMgr->GetSidebarWidth(bPx) + pMgr->GetSidebarBorderWidth(bPx));
5622*b1cdbd2cSJim Jagielski }
5623*b1cdbd2cSJim Jagielski }
5624*b1cdbd2cSJim Jagielski
AddSidebarBorders(Rectangle & aRect,ViewShell * _pViewShell,bool bRightSidebar,bool bPx)5625*b1cdbd2cSJim Jagielski /*static*/ void SwPageFrm::AddSidebarBorders(Rectangle &aRect, ViewShell* _pViewShell, bool bRightSidebar, bool bPx)
5626*b1cdbd2cSJim Jagielski {
5627*b1cdbd2cSJim Jagielski const SwPostItMgr *pMgr = _pViewShell ? _pViewShell->GetPostItMgr() : 0;
5628*b1cdbd2cSJim Jagielski if (pMgr && pMgr->ShowNotes() && pMgr->HasNotes())
5629*b1cdbd2cSJim Jagielski {
5630*b1cdbd2cSJim Jagielski if (!bRightSidebar)
5631*b1cdbd2cSJim Jagielski aRect.Left() -= (pMgr->GetSidebarWidth(bPx) + pMgr->GetSidebarBorderWidth(bPx));
5632*b1cdbd2cSJim Jagielski else
5633*b1cdbd2cSJim Jagielski aRect.Right() += pMgr->GetSidebarWidth(bPx) + pMgr->GetSidebarBorderWidth(bPx);
5634*b1cdbd2cSJim Jagielski }
5635*b1cdbd2cSJim Jagielski }
5636*b1cdbd2cSJim Jagielski
GetSidebarBorderWidth(const ViewShell * _pViewShell)5637*b1cdbd2cSJim Jagielski /*static*/ SwTwips SwPageFrm::GetSidebarBorderWidth( const ViewShell* _pViewShell )
5638*b1cdbd2cSJim Jagielski {
5639*b1cdbd2cSJim Jagielski const SwPostItMgr* pPostItMgr = _pViewShell ? _pViewShell->GetPostItMgr() : 0;
5640*b1cdbd2cSJim Jagielski const SwTwips nRet = pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() ? pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() : 0;
5641*b1cdbd2cSJim Jagielski return nRet;
5642*b1cdbd2cSJim Jagielski }
5643*b1cdbd2cSJim Jagielski
5644*b1cdbd2cSJim Jagielski /*************************************************************************
5645*b1cdbd2cSJim Jagielski |*
5646*b1cdbd2cSJim Jagielski |* SwFrm::PaintBaBo()
5647*b1cdbd2cSJim Jagielski |*
5648*b1cdbd2cSJim Jagielski |* Ersterstellung MA 22. Oct. 93
5649*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 19. Jun. 96
5650*b1cdbd2cSJim Jagielski |*
5651*b1cdbd2cSJim Jagielski |*************************************************************************/
5652*b1cdbd2cSJim Jagielski
PaintBaBo(const SwRect & rRect,const SwPageFrm * pPage,const sal_Bool bLowerBorder) const5653*b1cdbd2cSJim Jagielski void SwFrm::PaintBaBo( const SwRect& rRect, const SwPageFrm *pPage,
5654*b1cdbd2cSJim Jagielski const sal_Bool bLowerBorder ) const
5655*b1cdbd2cSJim Jagielski {
5656*b1cdbd2cSJim Jagielski if ( !pPage )
5657*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
5658*b1cdbd2cSJim Jagielski
5659*b1cdbd2cSJim Jagielski OutputDevice *pOut = pGlobalShell->GetOut();
5660*b1cdbd2cSJim Jagielski
5661*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
5662*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *pOut );
5663*b1cdbd2cSJim Jagielski // <--
5664*b1cdbd2cSJim Jagielski
5665*b1cdbd2cSJim Jagielski // OD 2004-04-23 #116347#
5666*b1cdbd2cSJim Jagielski pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR );
5667*b1cdbd2cSJim Jagielski pOut->SetLineColor();
5668*b1cdbd2cSJim Jagielski
5669*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)this );
5670*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
5671*b1cdbd2cSJim Jagielski
5672*b1cdbd2cSJim Jagielski // OD 20.11.2002 #104598# - take care of page margin area
5673*b1cdbd2cSJim Jagielski // Note: code move from <SwFrm::PaintBackground(..)> to new method
5674*b1cdbd2cSJim Jagielski // <SwPageFrm::Paintmargin(..)>.
5675*b1cdbd2cSJim Jagielski if ( IsPageFrm() )
5676*b1cdbd2cSJim Jagielski {
5677*b1cdbd2cSJim Jagielski static_cast<const SwPageFrm*>(this)->PaintMarginArea( rRect, pGlobalShell );
5678*b1cdbd2cSJim Jagielski }
5679*b1cdbd2cSJim Jagielski
5680*b1cdbd2cSJim Jagielski // OD 06.08.2002 #99657# - paint border before painting background
5681*b1cdbd2cSJim Jagielski // paint grid for page frame and paint border
5682*b1cdbd2cSJim Jagielski {
5683*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
5684*b1cdbd2cSJim Jagielski if( IsPageFrm() )
5685*b1cdbd2cSJim Jagielski ((SwPageFrm*)this)->PaintGrid( pOut, aRect );
5686*b1cdbd2cSJim Jagielski PaintBorder( aRect, pPage, rAttrs );
5687*b1cdbd2cSJim Jagielski }
5688*b1cdbd2cSJim Jagielski
5689*b1cdbd2cSJim Jagielski // paint background
5690*b1cdbd2cSJim Jagielski {
5691*b1cdbd2cSJim Jagielski PaintBackground( rRect, pPage, rAttrs, sal_False, bLowerBorder );
5692*b1cdbd2cSJim Jagielski }
5693*b1cdbd2cSJim Jagielski
5694*b1cdbd2cSJim Jagielski pOut->Pop();
5695*b1cdbd2cSJim Jagielski }
5696*b1cdbd2cSJim Jagielski
5697*b1cdbd2cSJim Jagielski /*************************************************************************
5698*b1cdbd2cSJim Jagielski |*
5699*b1cdbd2cSJim Jagielski |* SwFrm::PaintBackground()
5700*b1cdbd2cSJim Jagielski |*
5701*b1cdbd2cSJim Jagielski |* Ersterstellung MA 04. Jan. 93
5702*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 06. Feb. 97
5703*b1cdbd2cSJim Jagielski |*
5704*b1cdbd2cSJim Jagielski |*************************************************************************/
5705*b1cdbd2cSJim Jagielski /// OD 05.09.2002 #102912#
5706*b1cdbd2cSJim Jagielski /// Do not paint background for fly frames without a background brush by
5707*b1cdbd2cSJim Jagielski /// calling <PaintBaBo> at the page or at the fly frame its anchored
PaintBackground(const SwRect & rRect,const SwPageFrm * pPage,const SwBorderAttrs & rAttrs,const sal_Bool bLowerMode,const sal_Bool bLowerBorder) const5708*b1cdbd2cSJim Jagielski void SwFrm::PaintBackground( const SwRect &rRect, const SwPageFrm *pPage,
5709*b1cdbd2cSJim Jagielski const SwBorderAttrs & rAttrs,
5710*b1cdbd2cSJim Jagielski const sal_Bool bLowerMode,
5711*b1cdbd2cSJim Jagielski const sal_Bool bLowerBorder ) const
5712*b1cdbd2cSJim Jagielski {
5713*b1cdbd2cSJim Jagielski // OD 20.01.2003 #i1837# - no paint of table background, if corresponding
5714*b1cdbd2cSJim Jagielski // option is *not* set.
5715*b1cdbd2cSJim Jagielski if( IsTabFrm() &&
5716*b1cdbd2cSJim Jagielski !pGlobalShell->GetViewOptions()->IsTable() )
5717*b1cdbd2cSJim Jagielski {
5718*b1cdbd2cSJim Jagielski return;
5719*b1cdbd2cSJim Jagielski }
5720*b1cdbd2cSJim Jagielski
5721*b1cdbd2cSJim Jagielski // nothing to do for covered table cells:
5722*b1cdbd2cSJim Jagielski if( IsCellFrm() && IsCoveredCell() )
5723*b1cdbd2cSJim Jagielski return;
5724*b1cdbd2cSJim Jagielski
5725*b1cdbd2cSJim Jagielski ViewShell *pSh = pGlobalShell;
5726*b1cdbd2cSJim Jagielski
5727*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
5728*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *pSh->GetOut() );
5729*b1cdbd2cSJim Jagielski // <--
5730*b1cdbd2cSJim Jagielski
5731*b1cdbd2cSJim Jagielski const SvxBrushItem* pItem;
5732*b1cdbd2cSJim Jagielski /// OD 05.09.2002 #102912#
5733*b1cdbd2cSJim Jagielski /// temporary background brush for a fly frame without a background brush
5734*b1cdbd2cSJim Jagielski SvxBrushItem* pTmpBackBrush = 0;
5735*b1cdbd2cSJim Jagielski const Color* pCol;
5736*b1cdbd2cSJim Jagielski SwRect aOrigBackRect;
5737*b1cdbd2cSJim Jagielski const sal_Bool bPageFrm = IsPageFrm();
5738*b1cdbd2cSJim Jagielski sal_Bool bLowMode = sal_True;
5739*b1cdbd2cSJim Jagielski
5740*b1cdbd2cSJim Jagielski sal_Bool bBack = GetBackgroundBrush( pItem, pCol, aOrigBackRect, bLowerMode );
5741*b1cdbd2cSJim Jagielski //- Ausgabe wenn ein eigener Hintergrund mitgebracht wird.
5742*b1cdbd2cSJim Jagielski bool bNoFlyBackground = !bFlyMetafile && !bBack && IsFlyFrm();
5743*b1cdbd2cSJim Jagielski if ( bNoFlyBackground )
5744*b1cdbd2cSJim Jagielski {
5745*b1cdbd2cSJim Jagielski // OD 05.09.2002 #102912# - Fly frame has no background.
5746*b1cdbd2cSJim Jagielski // Try to find background brush at parents, if previous call of
5747*b1cdbd2cSJim Jagielski // <GetBackgroundBrush> disabled this option with the parameter <bLowerMode>
5748*b1cdbd2cSJim Jagielski if ( bLowerMode )
5749*b1cdbd2cSJim Jagielski {
5750*b1cdbd2cSJim Jagielski bBack = GetBackgroundBrush( pItem, pCol, aOrigBackRect, false );
5751*b1cdbd2cSJim Jagielski }
5752*b1cdbd2cSJim Jagielski // If still no background found for the fly frame, initialize the
5753*b1cdbd2cSJim Jagielski // background brush <pItem> with global retouche color and set <bBack>
5754*b1cdbd2cSJim Jagielski // to sal_True, that fly frame will paint its background using this color.
5755*b1cdbd2cSJim Jagielski if ( !bBack )
5756*b1cdbd2cSJim Jagielski {
5757*b1cdbd2cSJim Jagielski // OD 10.01.2003 #i6467# - on print output, pdf output and
5758*b1cdbd2cSJim Jagielski // in embedded mode not editing color COL_WHITE is used instead of
5759*b1cdbd2cSJim Jagielski // the global retouche color.
5760*b1cdbd2cSJim Jagielski if ( pSh->GetOut()->GetOutDevType() == OUTDEV_PRINTER ||
5761*b1cdbd2cSJim Jagielski pSh->GetViewOptions()->IsPDFExport() ||
5762*b1cdbd2cSJim Jagielski ( pSh->GetDoc()->GetDocShell()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED &&
5763*b1cdbd2cSJim Jagielski !pSh->GetDoc()->GetDocShell()->IsInPlaceActive()
5764*b1cdbd2cSJim Jagielski )
5765*b1cdbd2cSJim Jagielski )
5766*b1cdbd2cSJim Jagielski {
5767*b1cdbd2cSJim Jagielski pTmpBackBrush = new SvxBrushItem( Color( COL_WHITE ), RES_BACKGROUND );
5768*b1cdbd2cSJim Jagielski }
5769*b1cdbd2cSJim Jagielski else
5770*b1cdbd2cSJim Jagielski {
5771*b1cdbd2cSJim Jagielski pTmpBackBrush = new SvxBrushItem( aGlobalRetoucheColor, RES_BACKGROUND);
5772*b1cdbd2cSJim Jagielski }
5773*b1cdbd2cSJim Jagielski pItem = pTmpBackBrush;
5774*b1cdbd2cSJim Jagielski bBack = true;
5775*b1cdbd2cSJim Jagielski }
5776*b1cdbd2cSJim Jagielski }
5777*b1cdbd2cSJim Jagielski
5778*b1cdbd2cSJim Jagielski SwRect aPaintRect( Frm() );
5779*b1cdbd2cSJim Jagielski if( IsTxtFrm() || IsSctFrm() )
5780*b1cdbd2cSJim Jagielski aPaintRect = UnionFrm( sal_True );
5781*b1cdbd2cSJim Jagielski
5782*b1cdbd2cSJim Jagielski if ( aPaintRect.IsOver( rRect ) )
5783*b1cdbd2cSJim Jagielski {
5784*b1cdbd2cSJim Jagielski if ( bBack || bPageFrm || !bLowerMode )
5785*b1cdbd2cSJim Jagielski {
5786*b1cdbd2cSJim Jagielski const sal_Bool bBrowse = pSh->GetViewOptions()->getBrowseMode();
5787*b1cdbd2cSJim Jagielski SwRect aRect;
5788*b1cdbd2cSJim Jagielski if ( (bPageFrm && bBrowse) ||
5789*b1cdbd2cSJim Jagielski (IsTxtFrm() && Prt().SSize() == Frm().SSize()) )
5790*b1cdbd2cSJim Jagielski {
5791*b1cdbd2cSJim Jagielski aRect = Frm();
5792*b1cdbd2cSJim Jagielski ::SwAlignRect( aRect, pGlobalShell );
5793*b1cdbd2cSJim Jagielski }
5794*b1cdbd2cSJim Jagielski else
5795*b1cdbd2cSJim Jagielski {
5796*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( aRect, this, rAttrs, sal_False );
5797*b1cdbd2cSJim Jagielski if ( (IsTxtFrm() || IsTabFrm()) && GetPrev() )
5798*b1cdbd2cSJim Jagielski {
5799*b1cdbd2cSJim Jagielski if ( GetPrev()->GetAttrSet()->GetBackground() ==
5800*b1cdbd2cSJim Jagielski GetAttrSet()->GetBackground() )
5801*b1cdbd2cSJim Jagielski {
5802*b1cdbd2cSJim Jagielski aRect.Top( Frm().Top() );
5803*b1cdbd2cSJim Jagielski }
5804*b1cdbd2cSJim Jagielski }
5805*b1cdbd2cSJim Jagielski }
5806*b1cdbd2cSJim Jagielski aRect.Intersection( rRect );
5807*b1cdbd2cSJim Jagielski
5808*b1cdbd2cSJim Jagielski OutputDevice *pOut = pSh->GetOut();
5809*b1cdbd2cSJim Jagielski
5810*b1cdbd2cSJim Jagielski if ( aRect.HasArea() )
5811*b1cdbd2cSJim Jagielski {
5812*b1cdbd2cSJim Jagielski SvxBrushItem* pNewItem = 0;
5813*b1cdbd2cSJim Jagielski SwRegionRects aRegion( aRect );
5814*b1cdbd2cSJim Jagielski if( pCol )
5815*b1cdbd2cSJim Jagielski {
5816*b1cdbd2cSJim Jagielski pNewItem = new SvxBrushItem( *pCol, RES_BACKGROUND );
5817*b1cdbd2cSJim Jagielski pItem = pNewItem;
5818*b1cdbd2cSJim Jagielski }
5819*b1cdbd2cSJim Jagielski if ( pPage->GetSortedObjs() )
5820*b1cdbd2cSJim Jagielski ::lcl_SubtractFlys( this, pPage, aRect, aRegion );
5821*b1cdbd2cSJim Jagielski
5822*b1cdbd2cSJim Jagielski {
5823*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - determine, if background transparency
5824*b1cdbd2cSJim Jagielski /// have to be considered for drawing.
5825*b1cdbd2cSJim Jagielski /// --> Status Quo: background transparency have to be
5826*b1cdbd2cSJim Jagielski /// considered for fly frames
5827*b1cdbd2cSJim Jagielski const sal_Bool bConsiderBackgroundTransparency = IsFlyFrm();
5828*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
5829*b1cdbd2cSJim Jagielski {
5830*b1cdbd2cSJim Jagielski if ( 1 < aRegion.Count() )
5831*b1cdbd2cSJim Jagielski {
5832*b1cdbd2cSJim Jagielski ::SwAlignRect( aRegion[i], pGlobalShell );
5833*b1cdbd2cSJim Jagielski if( !aRegion[i].HasArea() )
5834*b1cdbd2cSJim Jagielski continue;
5835*b1cdbd2cSJim Jagielski }
5836*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - add 6th parameter to indicate, if
5837*b1cdbd2cSJim Jagielski /// background transparency have to be considered
5838*b1cdbd2cSJim Jagielski /// Set missing 5th parameter to the default value GRFNUM_NO
5839*b1cdbd2cSJim Jagielski /// - see declaration in /core/inc/frmtool.hxx.
5840*b1cdbd2cSJim Jagielski ::DrawGraphic( pItem, pOut, aOrigBackRect, aRegion[i], GRFNUM_NO,
5841*b1cdbd2cSJim Jagielski bConsiderBackgroundTransparency );
5842*b1cdbd2cSJim Jagielski }
5843*b1cdbd2cSJim Jagielski }
5844*b1cdbd2cSJim Jagielski if( pCol )
5845*b1cdbd2cSJim Jagielski delete pNewItem;
5846*b1cdbd2cSJim Jagielski }
5847*b1cdbd2cSJim Jagielski }
5848*b1cdbd2cSJim Jagielski else
5849*b1cdbd2cSJim Jagielski bLowMode = bLowerMode ? sal_True : sal_False;
5850*b1cdbd2cSJim Jagielski }
5851*b1cdbd2cSJim Jagielski
5852*b1cdbd2cSJim Jagielski /// OD 05.09.2002 #102912#
5853*b1cdbd2cSJim Jagielski /// delete temporary background brush.
5854*b1cdbd2cSJim Jagielski delete pTmpBackBrush;
5855*b1cdbd2cSJim Jagielski
5856*b1cdbd2cSJim Jagielski //Jetzt noch Lower und dessen Nachbarn.
5857*b1cdbd2cSJim Jagielski //Wenn ein Frn dabei die Kette verlaesst also nicht mehr Lower von mir ist
5858*b1cdbd2cSJim Jagielski //so hoert der Spass auf.
5859*b1cdbd2cSJim Jagielski const SwFrm *pFrm = GetLower();
5860*b1cdbd2cSJim Jagielski if ( pFrm )
5861*b1cdbd2cSJim Jagielski {
5862*b1cdbd2cSJim Jagielski SwRect aFrmRect;
5863*b1cdbd2cSJim Jagielski SwRect aRect( PaintArea() );
5864*b1cdbd2cSJim Jagielski aRect._Intersection( rRect );
5865*b1cdbd2cSJim Jagielski SwRect aBorderRect( aRect );
5866*b1cdbd2cSJim Jagielski SwShortCut aShortCut( *pFrm, aBorderRect );
5867*b1cdbd2cSJim Jagielski do
5868*b1cdbd2cSJim Jagielski { if ( pProgress )
5869*b1cdbd2cSJim Jagielski pProgress->Reschedule();
5870*b1cdbd2cSJim Jagielski
5871*b1cdbd2cSJim Jagielski aFrmRect = pFrm->PaintArea();
5872*b1cdbd2cSJim Jagielski if ( aFrmRect.IsOver( aBorderRect ) )
5873*b1cdbd2cSJim Jagielski {
5874*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), (SwFrm*)pFrm );
5875*b1cdbd2cSJim Jagielski const SwBorderAttrs &rTmpAttrs = *aAccess.Get();
5876*b1cdbd2cSJim Jagielski /// OD 06.08.2002 #99657# - paint border before painting background
5877*b1cdbd2cSJim Jagielski if ( bLowerBorder )
5878*b1cdbd2cSJim Jagielski pFrm->PaintBorder( aBorderRect, pPage, rTmpAttrs );
5879*b1cdbd2cSJim Jagielski if ( ( pFrm->IsLayoutFrm() && bLowerBorder ) ||
5880*b1cdbd2cSJim Jagielski aFrmRect.IsOver( aRect ) )
5881*b1cdbd2cSJim Jagielski pFrm->PaintBackground( aRect, pPage, rTmpAttrs, bLowMode,
5882*b1cdbd2cSJim Jagielski bLowerBorder );
5883*b1cdbd2cSJim Jagielski }
5884*b1cdbd2cSJim Jagielski pFrm = pFrm->GetNext();
5885*b1cdbd2cSJim Jagielski } while ( pFrm && pFrm->GetUpper() == this &&
5886*b1cdbd2cSJim Jagielski !aShortCut.Stop( aFrmRect ) );
5887*b1cdbd2cSJim Jagielski }
5888*b1cdbd2cSJim Jagielski }
5889*b1cdbd2cSJim Jagielski
5890*b1cdbd2cSJim Jagielski /*************************************************************************
5891*b1cdbd2cSJim Jagielski |*
5892*b1cdbd2cSJim Jagielski |* SwPageFrm::RefreshSubsidiary()
5893*b1cdbd2cSJim Jagielski |*
5894*b1cdbd2cSJim Jagielski |* Beschreibung Erneuert alle Hilfslinien der Seite.
5895*b1cdbd2cSJim Jagielski |* Ersterstellung MA 04. Nov. 92
5896*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 10. May. 95
5897*b1cdbd2cSJim Jagielski |*
5898*b1cdbd2cSJim Jagielski |*************************************************************************/
5899*b1cdbd2cSJim Jagielski
RefreshSubsidiary(const SwRect & rRect) const5900*b1cdbd2cSJim Jagielski void SwPageFrm::RefreshSubsidiary( const SwRect &rRect ) const
5901*b1cdbd2cSJim Jagielski {
5902*b1cdbd2cSJim Jagielski if ( IS_SUBS || IS_SUBS_TABLE || IS_SUBS_SECTION || IS_SUBS_FLYS )
5903*b1cdbd2cSJim Jagielski {
5904*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
5905*b1cdbd2cSJim Jagielski // OD 18.02.2003 #104989# - Not necessary and incorrect alignment of
5906*b1cdbd2cSJim Jagielski // the output rectangle.
5907*b1cdbd2cSJim Jagielski //::SwAlignRect( aRect, pGlobalShell );
5908*b1cdbd2cSJim Jagielski if ( aRect.HasArea() )
5909*b1cdbd2cSJim Jagielski {
5910*b1cdbd2cSJim Jagielski //Beim Paint ueber die Root wird das Array von dort gesteuert.
5911*b1cdbd2cSJim Jagielski //Anderfalls kuemmern wir uns selbst darum.
5912*b1cdbd2cSJim Jagielski sal_Bool bDelSubs = sal_False;
5913*b1cdbd2cSJim Jagielski if ( !pSubsLines )
5914*b1cdbd2cSJim Jagielski {
5915*b1cdbd2cSJim Jagielski pSubsLines = new SwSubsRects;
5916*b1cdbd2cSJim Jagielski // OD 20.12.2002 #106318# - create container for special subsidiary lines
5917*b1cdbd2cSJim Jagielski pSpecSubsLines = new SwSubsRects;
5918*b1cdbd2cSJim Jagielski bDelSubs = sal_True;
5919*b1cdbd2cSJim Jagielski }
5920*b1cdbd2cSJim Jagielski
5921*b1cdbd2cSJim Jagielski RefreshLaySubsidiary( this, aRect );
5922*b1cdbd2cSJim Jagielski
5923*b1cdbd2cSJim Jagielski if ( bDelSubs )
5924*b1cdbd2cSJim Jagielski {
5925*b1cdbd2cSJim Jagielski // OD 20.12.2002 #106318# - paint special subsidiary lines
5926*b1cdbd2cSJim Jagielski // and delete its container
5927*b1cdbd2cSJim Jagielski pSpecSubsLines->PaintSubsidiary( pGlobalShell->GetOut(), NULL );
5928*b1cdbd2cSJim Jagielski DELETEZ( pSpecSubsLines );
5929*b1cdbd2cSJim Jagielski
5930*b1cdbd2cSJim Jagielski pSubsLines->PaintSubsidiary( pGlobalShell->GetOut(), pLines );
5931*b1cdbd2cSJim Jagielski DELETEZ( pSubsLines );
5932*b1cdbd2cSJim Jagielski }
5933*b1cdbd2cSJim Jagielski }
5934*b1cdbd2cSJim Jagielski }
5935*b1cdbd2cSJim Jagielski }
5936*b1cdbd2cSJim Jagielski
5937*b1cdbd2cSJim Jagielski /*************************************************************************
5938*b1cdbd2cSJim Jagielski |*
5939*b1cdbd2cSJim Jagielski |* SwLayoutFrm::RefreshLaySubsidiary()
5940*b1cdbd2cSJim Jagielski |*
5941*b1cdbd2cSJim Jagielski |* Ersterstellung MA 04. Nov. 92
5942*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 22. Jan. 95
5943*b1cdbd2cSJim Jagielski |*
5944*b1cdbd2cSJim Jagielski |*************************************************************************/
RefreshLaySubsidiary(const SwPageFrm * pPage,const SwRect & rRect) const5945*b1cdbd2cSJim Jagielski void SwLayoutFrm::RefreshLaySubsidiary( const SwPageFrm *pPage,
5946*b1cdbd2cSJim Jagielski const SwRect &rRect ) const
5947*b1cdbd2cSJim Jagielski {
5948*b1cdbd2cSJim Jagielski const sal_Bool bNoLowerColumn = !Lower() || !Lower()->IsColumnFrm();
5949*b1cdbd2cSJim Jagielski const sal_Bool bSubsOpt = IS_SUBS;
5950*b1cdbd2cSJim Jagielski const sal_Bool bSubsTable = ((GetType() & (FRM_ROW | FRM_CELL)) && IS_SUBS_TABLE);
5951*b1cdbd2cSJim Jagielski const sal_Bool bSubsOther = (GetType() & (FRM_HEADER | FRM_FOOTER | FRM_FTN )) && bSubsOpt;
5952*b1cdbd2cSJim Jagielski const sal_Bool bSubsSect = IsSctFrm() &&
5953*b1cdbd2cSJim Jagielski bNoLowerColumn &&
5954*b1cdbd2cSJim Jagielski IS_SUBS_SECTION;
5955*b1cdbd2cSJim Jagielski const sal_Bool bSubsFly = IS_SUBS_FLYS &&
5956*b1cdbd2cSJim Jagielski (GetType() & FRM_FLY) &&
5957*b1cdbd2cSJim Jagielski bNoLowerColumn &&
5958*b1cdbd2cSJim Jagielski (!Lower() || !Lower()->IsNoTxtFrm() ||
5959*b1cdbd2cSJim Jagielski !((SwNoTxtFrm*)Lower())->HasAnimation());
5960*b1cdbd2cSJim Jagielski sal_Bool bSubsBody = sal_False;
5961*b1cdbd2cSJim Jagielski if ( GetType() & FRM_BODY )
5962*b1cdbd2cSJim Jagielski {
5963*b1cdbd2cSJim Jagielski if ( IsPageBodyFrm() )
5964*b1cdbd2cSJim Jagielski bSubsBody = bSubsOpt && bNoLowerColumn; //nur ohne Spalten
5965*b1cdbd2cSJim Jagielski else //Spaltenbody
5966*b1cdbd2cSJim Jagielski {
5967*b1cdbd2cSJim Jagielski if ( GetUpper()->GetUpper()->IsSctFrm() )
5968*b1cdbd2cSJim Jagielski bSubsBody = IS_SUBS_SECTION;
5969*b1cdbd2cSJim Jagielski else
5970*b1cdbd2cSJim Jagielski bSubsBody = bSubsOpt;
5971*b1cdbd2cSJim Jagielski }
5972*b1cdbd2cSJim Jagielski }
5973*b1cdbd2cSJim Jagielski
5974*b1cdbd2cSJim Jagielski if ( bSubsOther || bSubsSect || bSubsBody || bSubsTable || bSubsFly )
5975*b1cdbd2cSJim Jagielski PaintSubsidiaryLines( pPage, rRect );
5976*b1cdbd2cSJim Jagielski
5977*b1cdbd2cSJim Jagielski const SwFrm *pLow = Lower();
5978*b1cdbd2cSJim Jagielski if( !pLow )
5979*b1cdbd2cSJim Jagielski return;
5980*b1cdbd2cSJim Jagielski SwShortCut aShortCut( *pLow, rRect );
5981*b1cdbd2cSJim Jagielski while( pLow && !aShortCut.Stop( pLow->Frm() ) )
5982*b1cdbd2cSJim Jagielski {
5983*b1cdbd2cSJim Jagielski if ( pLow->Frm().IsOver( rRect ) && pLow->Frm().HasArea() )
5984*b1cdbd2cSJim Jagielski {
5985*b1cdbd2cSJim Jagielski if ( pLow->IsLayoutFrm() )
5986*b1cdbd2cSJim Jagielski ((const SwLayoutFrm*)pLow)->RefreshLaySubsidiary( pPage, rRect);
5987*b1cdbd2cSJim Jagielski else if ( pLow->GetDrawObjs() )
5988*b1cdbd2cSJim Jagielski {
5989*b1cdbd2cSJim Jagielski const SwSortedObjs& rObjs = *(pLow->GetDrawObjs());
5990*b1cdbd2cSJim Jagielski for ( sal_uInt32 i = 0; i < rObjs.Count(); ++i )
5991*b1cdbd2cSJim Jagielski {
5992*b1cdbd2cSJim Jagielski const SwAnchoredObject* pAnchoredObj = rObjs[i];
5993*b1cdbd2cSJim Jagielski if ( pPage->GetFmt()->GetDoc()->IsVisibleLayerId(
5994*b1cdbd2cSJim Jagielski pAnchoredObj->GetDrawObj()->GetLayer() ) &&
5995*b1cdbd2cSJim Jagielski pAnchoredObj->ISA(SwFlyFrm) )
5996*b1cdbd2cSJim Jagielski {
5997*b1cdbd2cSJim Jagielski const SwFlyFrm *pFly =
5998*b1cdbd2cSJim Jagielski static_cast<const SwFlyFrm*>(pAnchoredObj);
5999*b1cdbd2cSJim Jagielski if ( pFly->IsFlyInCntFrm() && pFly->Frm().IsOver( rRect ) )
6000*b1cdbd2cSJim Jagielski {
6001*b1cdbd2cSJim Jagielski if ( !pFly->Lower() || !pFly->Lower()->IsNoTxtFrm() ||
6002*b1cdbd2cSJim Jagielski !((SwNoTxtFrm*)pFly->Lower())->HasAnimation())
6003*b1cdbd2cSJim Jagielski pFly->RefreshLaySubsidiary( pPage, rRect );
6004*b1cdbd2cSJim Jagielski }
6005*b1cdbd2cSJim Jagielski }
6006*b1cdbd2cSJim Jagielski }
6007*b1cdbd2cSJim Jagielski }
6008*b1cdbd2cSJim Jagielski }
6009*b1cdbd2cSJim Jagielski pLow = pLow->GetNext();
6010*b1cdbd2cSJim Jagielski }
6011*b1cdbd2cSJim Jagielski }
6012*b1cdbd2cSJim Jagielski
6013*b1cdbd2cSJim Jagielski /*************************************************************************
6014*b1cdbd2cSJim Jagielski |*
6015*b1cdbd2cSJim Jagielski |* SwLayoutFrm::PaintSubsidiaryLines()
6016*b1cdbd2cSJim Jagielski |*
6017*b1cdbd2cSJim Jagielski |* Beschreibung Hilfslinien um die PrtAreas malen
6018*b1cdbd2cSJim Jagielski |* Nur die LayoutFrm's die direkt Cntnt enthalten.
6019*b1cdbd2cSJim Jagielski |* Ersterstellung MA 21. May. 92
6020*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 22. Jan. 95
6021*b1cdbd2cSJim Jagielski |*
6022*b1cdbd2cSJim Jagielski |*************************************************************************/
6023*b1cdbd2cSJim Jagielski
6024*b1cdbd2cSJim Jagielski //Malt die angegebene Linie, achtet darauf, dass keine Flys uebermalt werden.
6025*b1cdbd2cSJim Jagielski
6026*b1cdbd2cSJim Jagielski typedef long Size::* SizePtr;
6027*b1cdbd2cSJim Jagielski typedef long Point::* PointPtr;
6028*b1cdbd2cSJim Jagielski
6029*b1cdbd2cSJim Jagielski PointPtr pX = &Point::nA;
6030*b1cdbd2cSJim Jagielski PointPtr pY = &Point::nB;
6031*b1cdbd2cSJim Jagielski SizePtr pWidth = &Size::nA;
6032*b1cdbd2cSJim Jagielski SizePtr pHeight = &Size::nB;
6033*b1cdbd2cSJim Jagielski
6034*b1cdbd2cSJim Jagielski // OD 18.11.2002 #99672# - new parameter <_pSubsLines>
lcl_RefreshLine(const SwLayoutFrm * pLay,const SwPageFrm * pPage,const Point & rP1,const Point & rP2,const sal_uInt8 nSubColor,SwLineRects * _pSubsLines)6035*b1cdbd2cSJim Jagielski void MA_FASTCALL lcl_RefreshLine( const SwLayoutFrm *pLay,
6036*b1cdbd2cSJim Jagielski const SwPageFrm *pPage,
6037*b1cdbd2cSJim Jagielski const Point &rP1,
6038*b1cdbd2cSJim Jagielski const Point &rP2,
6039*b1cdbd2cSJim Jagielski const sal_uInt8 nSubColor,
6040*b1cdbd2cSJim Jagielski SwLineRects* _pSubsLines )
6041*b1cdbd2cSJim Jagielski {
6042*b1cdbd2cSJim Jagielski //In welche Richtung gehts? Kann nur Horizontal oder Vertikal sein.
6043*b1cdbd2cSJim Jagielski ASSERT( ((rP1.X() == rP2.X()) || (rP1.Y() == rP2.Y())),
6044*b1cdbd2cSJim Jagielski "Schraege Hilfslinien sind nicht erlaubt." );
6045*b1cdbd2cSJim Jagielski const PointPtr pDirPt = rP1.X() == rP2.X() ? pY : pX;
6046*b1cdbd2cSJim Jagielski const PointPtr pOthPt = pDirPt == pX ? pY : pX;
6047*b1cdbd2cSJim Jagielski const SizePtr pDirSz = pDirPt == pX ? pWidth : pHeight;
6048*b1cdbd2cSJim Jagielski const SizePtr pOthSz = pDirSz == pWidth ? pHeight : pWidth;
6049*b1cdbd2cSJim Jagielski Point aP1( rP1 ),
6050*b1cdbd2cSJim Jagielski aP2( rP2 );
6051*b1cdbd2cSJim Jagielski
6052*b1cdbd2cSJim Jagielski while ( aP1.*pDirPt < aP2.*pDirPt )
6053*b1cdbd2cSJim Jagielski { //Der Startpunkt wird jetzt, falls er in einem Fly sitzt, direkt
6054*b1cdbd2cSJim Jagielski //hinter den Fly gesetzt.
6055*b1cdbd2cSJim Jagielski //Wenn der Endpunkt in einem Fly sitzt oder zwischen Start und Endpunkt
6056*b1cdbd2cSJim Jagielski //ein Fly sitzt, so wird der Endpunkt eben an den Start herangezogen.
6057*b1cdbd2cSJim Jagielski //Auf diese art und weise wird eine Portion nach der anderen
6058*b1cdbd2cSJim Jagielski //ausgegeben.
6059*b1cdbd2cSJim Jagielski
6060*b1cdbd2cSJim Jagielski //Wenn ich selbst ein Fly bin, weiche ich nur denjenigen Flys aus,
6061*b1cdbd2cSJim Jagielski //die 'ueber' mir sitzen; d.h. die in dem Array hinter mir stehen.
6062*b1cdbd2cSJim Jagielski //Auch wenn ich in einem Fly sitze oder in einem Fly im Fly usw. weiche
6063*b1cdbd2cSJim Jagielski //ich keinem dieser Flys aus.
6064*b1cdbd2cSJim Jagielski SwOrderIter aIter( pPage );
6065*b1cdbd2cSJim Jagielski const SwFlyFrm *pMyFly = pLay->FindFlyFrm();
6066*b1cdbd2cSJim Jagielski if ( pMyFly )
6067*b1cdbd2cSJim Jagielski {
6068*b1cdbd2cSJim Jagielski aIter.Current( pMyFly->GetVirtDrawObj() );
6069*b1cdbd2cSJim Jagielski while ( 0 != (pMyFly = pMyFly->GetAnchorFrm()->FindFlyFrm()) )
6070*b1cdbd2cSJim Jagielski {
6071*b1cdbd2cSJim Jagielski if ( aIter()->GetOrdNum() > pMyFly->GetVirtDrawObj()->GetOrdNum() )
6072*b1cdbd2cSJim Jagielski aIter.Current( pMyFly->GetVirtDrawObj() );
6073*b1cdbd2cSJim Jagielski }
6074*b1cdbd2cSJim Jagielski }
6075*b1cdbd2cSJim Jagielski else
6076*b1cdbd2cSJim Jagielski aIter.Bottom();
6077*b1cdbd2cSJim Jagielski
6078*b1cdbd2cSJim Jagielski while ( aIter() )
6079*b1cdbd2cSJim Jagielski {
6080*b1cdbd2cSJim Jagielski const SwVirtFlyDrawObj *pObj = (SwVirtFlyDrawObj*)aIter();
6081*b1cdbd2cSJim Jagielski const SwFlyFrm *pFly = pObj ? pObj->GetFlyFrm() : 0;
6082*b1cdbd2cSJim Jagielski
6083*b1cdbd2cSJim Jagielski //Mir selbst weiche ich natuerlich nicht aus. Auch wenn ich
6084*b1cdbd2cSJim Jagielski //_in_ dem Fly sitze weiche ich nicht aus.
6085*b1cdbd2cSJim Jagielski if ( !pFly || (pFly == pLay || pFly->IsAnLower( pLay )) )
6086*b1cdbd2cSJim Jagielski {
6087*b1cdbd2cSJim Jagielski aIter.Next();
6088*b1cdbd2cSJim Jagielski continue;
6089*b1cdbd2cSJim Jagielski }
6090*b1cdbd2cSJim Jagielski
6091*b1cdbd2cSJim Jagielski // OD 19.12.2002 #106318# - do *not* consider fly frames with
6092*b1cdbd2cSJim Jagielski // a transparent background.
6093*b1cdbd2cSJim Jagielski // OD 2004-02-12 #110582#-2 - do *not* consider fly frame, which
6094*b1cdbd2cSJim Jagielski // belongs to a invisible layer
6095*b1cdbd2cSJim Jagielski if ( pFly->IsBackgroundTransparent() ||
6096*b1cdbd2cSJim Jagielski !pFly->GetFmt()->GetDoc()->IsVisibleLayerId( pObj->GetLayer() ) )
6097*b1cdbd2cSJim Jagielski {
6098*b1cdbd2cSJim Jagielski aIter.Next();
6099*b1cdbd2cSJim Jagielski continue;
6100*b1cdbd2cSJim Jagielski }
6101*b1cdbd2cSJim Jagielski
6102*b1cdbd2cSJim Jagielski //Sitzt das Obj auf der Linie
6103*b1cdbd2cSJim Jagielski const Rectangle &rBound = pObj->GetCurrentBoundRect();
6104*b1cdbd2cSJim Jagielski const Point aDrPt( rBound.TopLeft() );
6105*b1cdbd2cSJim Jagielski const Size aDrSz( rBound.GetSize() );
6106*b1cdbd2cSJim Jagielski if ( rP1.*pOthPt >= aDrPt.*pOthPt &&
6107*b1cdbd2cSJim Jagielski rP1.*pOthPt <= (aDrPt.*pOthPt + aDrSz.*pOthSz) )
6108*b1cdbd2cSJim Jagielski {
6109*b1cdbd2cSJim Jagielski if ( aP1.*pDirPt >= aDrPt.*pDirPt &&
6110*b1cdbd2cSJim Jagielski aP1.*pDirPt <= (aDrPt.*pDirPt + aDrSz.*pDirSz) )
6111*b1cdbd2cSJim Jagielski aP1.*pDirPt = aDrPt.*pDirPt + aDrSz.*pDirSz;
6112*b1cdbd2cSJim Jagielski
6113*b1cdbd2cSJim Jagielski if ( aP2.*pDirPt >= aDrPt.*pDirPt &&
6114*b1cdbd2cSJim Jagielski aP1.*pDirPt < (aDrPt.*pDirPt - 1) )
6115*b1cdbd2cSJim Jagielski aP2.*pDirPt = aDrPt.*pDirPt - 1;
6116*b1cdbd2cSJim Jagielski }
6117*b1cdbd2cSJim Jagielski aIter.Next();
6118*b1cdbd2cSJim Jagielski }
6119*b1cdbd2cSJim Jagielski
6120*b1cdbd2cSJim Jagielski if ( aP1.*pDirPt < aP2.*pDirPt )
6121*b1cdbd2cSJim Jagielski {
6122*b1cdbd2cSJim Jagielski SwRect aRect( aP1, aP2 );
6123*b1cdbd2cSJim Jagielski // OD 18.11.2002 #99672# - use parameter <_pSubsLines> instead of
6124*b1cdbd2cSJim Jagielski // global variable <pSubsLines>.
6125*b1cdbd2cSJim Jagielski _pSubsLines->AddLineRect( aRect, 0, 0, nSubColor );
6126*b1cdbd2cSJim Jagielski }
6127*b1cdbd2cSJim Jagielski aP1 = aP2;
6128*b1cdbd2cSJim Jagielski aP1.*pDirPt += 1;
6129*b1cdbd2cSJim Jagielski aP2 = rP2;
6130*b1cdbd2cSJim Jagielski }
6131*b1cdbd2cSJim Jagielski }
6132*b1cdbd2cSJim Jagielski
PaintSubsidiaryLines(const SwPageFrm * pPage,const SwRect & rRect) const6133*b1cdbd2cSJim Jagielski void SwLayoutFrm::PaintSubsidiaryLines( const SwPageFrm *pPage,
6134*b1cdbd2cSJim Jagielski const SwRect &rRect ) const
6135*b1cdbd2cSJim Jagielski {
6136*b1cdbd2cSJim Jagielski bool bNewTableModel = false;
6137*b1cdbd2cSJim Jagielski
6138*b1cdbd2cSJim Jagielski // --> collapsing borders FME 2005-05-27 #i29550#
6139*b1cdbd2cSJim Jagielski if ( IsTabFrm() || IsCellFrm() || IsRowFrm() )
6140*b1cdbd2cSJim Jagielski {
6141*b1cdbd2cSJim Jagielski const SwTabFrm* pTabFrm = FindTabFrm();
6142*b1cdbd2cSJim Jagielski if ( pTabFrm->IsCollapsingBorders() )
6143*b1cdbd2cSJim Jagielski return;
6144*b1cdbd2cSJim Jagielski
6145*b1cdbd2cSJim Jagielski bNewTableModel = pTabFrm->GetTable()->IsNewModel();
6146*b1cdbd2cSJim Jagielski // in the new table model, we have an early return for all cell-related
6147*b1cdbd2cSJim Jagielski // frames, except from non-covered table cells
6148*b1cdbd2cSJim Jagielski if ( bNewTableModel )
6149*b1cdbd2cSJim Jagielski if ( IsTabFrm() ||
6150*b1cdbd2cSJim Jagielski IsRowFrm() ||
6151*b1cdbd2cSJim Jagielski ( IsCellFrm() && IsCoveredCell() ) )
6152*b1cdbd2cSJim Jagielski return;
6153*b1cdbd2cSJim Jagielski }
6154*b1cdbd2cSJim Jagielski // <-- collapsing
6155*b1cdbd2cSJim Jagielski
6156*b1cdbd2cSJim Jagielski const bool bFlys = pPage->GetSortedObjs() ? true : false;
6157*b1cdbd2cSJim Jagielski
6158*b1cdbd2cSJim Jagielski const bool bCell = IsCellFrm() ? true : false;
6159*b1cdbd2cSJim Jagielski // use frame area for cells
6160*b1cdbd2cSJim Jagielski // OD 13.02.2003 #i3662# - for section use also frame area
6161*b1cdbd2cSJim Jagielski const bool bUseFrmArea = bCell || IsSctFrm();
6162*b1cdbd2cSJim Jagielski SwRect aOriginal( bUseFrmArea ? Frm() : Prt() );
6163*b1cdbd2cSJim Jagielski if ( !bUseFrmArea )
6164*b1cdbd2cSJim Jagielski aOriginal.Pos() += Frm().Pos();
6165*b1cdbd2cSJim Jagielski
6166*b1cdbd2cSJim Jagielski // OD 13.02.2003 #i3662# - enlarge top of column body frame's printing area
6167*b1cdbd2cSJim Jagielski // in sections to top of section frame.
6168*b1cdbd2cSJim Jagielski const bool bColBodyInSection = IsBodyFrm() &&
6169*b1cdbd2cSJim Jagielski !IsPageBodyFrm() &&
6170*b1cdbd2cSJim Jagielski GetUpper()->GetUpper()->IsSctFrm();
6171*b1cdbd2cSJim Jagielski if ( bColBodyInSection )
6172*b1cdbd2cSJim Jagielski {
6173*b1cdbd2cSJim Jagielski if ( IsVertical() )
6174*b1cdbd2cSJim Jagielski aOriginal.Right( GetUpper()->GetUpper()->Frm().Right() );
6175*b1cdbd2cSJim Jagielski else
6176*b1cdbd2cSJim Jagielski aOriginal.Top( GetUpper()->GetUpper()->Frm().Top() );
6177*b1cdbd2cSJim Jagielski }
6178*b1cdbd2cSJim Jagielski
6179*b1cdbd2cSJim Jagielski ::SwAlignRect( aOriginal, pGlobalShell );
6180*b1cdbd2cSJim Jagielski
6181*b1cdbd2cSJim Jagielski if ( !aOriginal.IsOver( rRect ) )
6182*b1cdbd2cSJim Jagielski return;
6183*b1cdbd2cSJim Jagielski
6184*b1cdbd2cSJim Jagielski SwRect aOut( aOriginal );
6185*b1cdbd2cSJim Jagielski aOut._Intersection( rRect );
6186*b1cdbd2cSJim Jagielski // OD 13.02.2003 #i3662# - do not intersect *enlarged* column body frame's
6187*b1cdbd2cSJim Jagielski // printing area with the paint area of the body frame. Otherwise enlargement
6188*b1cdbd2cSJim Jagielski // will get lost.
6189*b1cdbd2cSJim Jagielski if ( !bColBodyInSection )
6190*b1cdbd2cSJim Jagielski {
6191*b1cdbd2cSJim Jagielski aOut.Intersection( PaintArea() );
6192*b1cdbd2cSJim Jagielski }
6193*b1cdbd2cSJim Jagielski
6194*b1cdbd2cSJim Jagielski const SwTwips nRight = aOut.Right();
6195*b1cdbd2cSJim Jagielski const SwTwips nBottom= aOut.Bottom();
6196*b1cdbd2cSJim Jagielski
6197*b1cdbd2cSJim Jagielski const Point aRT( nRight, aOut.Top() );
6198*b1cdbd2cSJim Jagielski const Point aRB( nRight, nBottom );
6199*b1cdbd2cSJim Jagielski const Point aLB( aOut.Left(), nBottom );
6200*b1cdbd2cSJim Jagielski
6201*b1cdbd2cSJim Jagielski sal_uInt8 nSubColor = ( bCell || IsRowFrm() ) ? SUBCOL_TAB :
6202*b1cdbd2cSJim Jagielski ( IsInSct() ? SUBCOL_SECT :
6203*b1cdbd2cSJim Jagielski ( IsInFly() ? SUBCOL_FLY : SUBCOL_PAGE ) );
6204*b1cdbd2cSJim Jagielski
6205*b1cdbd2cSJim Jagielski // OD 05.11.2002 #102406# - body frames are responsible for page/column breaks.
6206*b1cdbd2cSJim Jagielski sal_Bool bBreak = sal_False;
6207*b1cdbd2cSJim Jagielski if ( IsBodyFrm() )
6208*b1cdbd2cSJim Jagielski {
6209*b1cdbd2cSJim Jagielski const SwCntntFrm *pCnt = ContainsCntnt();
6210*b1cdbd2cSJim Jagielski if ( pCnt )
6211*b1cdbd2cSJim Jagielski {
6212*b1cdbd2cSJim Jagielski // OD 05.11.2002 #102406# - adjust setting of <bBreak>.
6213*b1cdbd2cSJim Jagielski bBreak = pCnt->IsPageBreak( sal_True ) ||
6214*b1cdbd2cSJim Jagielski ( IsColBodyFrm() && pCnt->IsColBreak( sal_True ) );
6215*b1cdbd2cSJim Jagielski }
6216*b1cdbd2cSJim Jagielski }
6217*b1cdbd2cSJim Jagielski
6218*b1cdbd2cSJim Jagielski // OD 18.11.2002 #99672# - collect body, header, footer, footnote and section
6219*b1cdbd2cSJim Jagielski // sub-lines in <pSpecSubsLine> array.
6220*b1cdbd2cSJim Jagielski const bool bSpecialSublines = IsBodyFrm() || IsHeaderFrm() || IsFooterFrm() ||
6221*b1cdbd2cSJim Jagielski IsFtnFrm() || IsSctFrm();
6222*b1cdbd2cSJim Jagielski SwLineRects* pUsedSubsLines = bSpecialSublines ? pSpecSubsLines : pSubsLines;
6223*b1cdbd2cSJim Jagielski
6224*b1cdbd2cSJim Jagielski // NOTE: for cell frames only left and right (horizontal layout) respectively
6225*b1cdbd2cSJim Jagielski // top and bottom (vertical layout) lines painted.
6226*b1cdbd2cSJim Jagielski // NOTE2: this does not hold for the new table model!!! We paint the top border
6227*b1cdbd2cSJim Jagielski // of each non-covered table cell.
6228*b1cdbd2cSJim Jagielski const bool bVert = IsVertical() ? true : false;
6229*b1cdbd2cSJim Jagielski if ( bFlys )
6230*b1cdbd2cSJim Jagielski {
6231*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104822# - add control for drawing left and right lines
6232*b1cdbd2cSJim Jagielski if ( !bCell || bNewTableModel || !bVert )
6233*b1cdbd2cSJim Jagielski {
6234*b1cdbd2cSJim Jagielski if ( aOriginal.Left() == aOut.Left() )
6235*b1cdbd2cSJim Jagielski ::lcl_RefreshLine( this, pPage, aOut.Pos(), aLB, nSubColor,
6236*b1cdbd2cSJim Jagielski pUsedSubsLines );
6237*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104821# - in vertical layout set page/column break at right
6238*b1cdbd2cSJim Jagielski if ( aOriginal.Right() == nRight )
6239*b1cdbd2cSJim Jagielski ::lcl_RefreshLine( this, pPage, aRT, aRB,
6240*b1cdbd2cSJim Jagielski (bBreak && bVert) ? SUBCOL_BREAK : nSubColor,
6241*b1cdbd2cSJim Jagielski pUsedSubsLines );
6242*b1cdbd2cSJim Jagielski }
6243*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104822# - adjust control for drawing top and bottom lines
6244*b1cdbd2cSJim Jagielski if ( !bCell || bNewTableModel || bVert )
6245*b1cdbd2cSJim Jagielski {
6246*b1cdbd2cSJim Jagielski if ( aOriginal.Top() == aOut.Top() )
6247*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104821# - in horizontal layout set page/column break at top
6248*b1cdbd2cSJim Jagielski ::lcl_RefreshLine( this, pPage, aOut.Pos(), aRT,
6249*b1cdbd2cSJim Jagielski (bBreak && !bVert) ? SUBCOL_BREAK : nSubColor,
6250*b1cdbd2cSJim Jagielski pUsedSubsLines );
6251*b1cdbd2cSJim Jagielski if ( aOriginal.Bottom() == nBottom )
6252*b1cdbd2cSJim Jagielski ::lcl_RefreshLine( this, pPage, aLB, aRB, nSubColor,
6253*b1cdbd2cSJim Jagielski pUsedSubsLines );
6254*b1cdbd2cSJim Jagielski }
6255*b1cdbd2cSJim Jagielski }
6256*b1cdbd2cSJim Jagielski else
6257*b1cdbd2cSJim Jagielski {
6258*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104822# - add control for drawing left and right lines
6259*b1cdbd2cSJim Jagielski if ( !bCell || bNewTableModel || !bVert )
6260*b1cdbd2cSJim Jagielski {
6261*b1cdbd2cSJim Jagielski if ( aOriginal.Left() == aOut.Left() )
6262*b1cdbd2cSJim Jagielski {
6263*b1cdbd2cSJim Jagielski const SwRect aRect( aOut.Pos(), aLB );
6264*b1cdbd2cSJim Jagielski pUsedSubsLines->AddLineRect( aRect, 0, 0, nSubColor );
6265*b1cdbd2cSJim Jagielski }
6266*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104821# - in vertical layout set page/column break at right
6267*b1cdbd2cSJim Jagielski if ( aOriginal.Right() == nRight )
6268*b1cdbd2cSJim Jagielski {
6269*b1cdbd2cSJim Jagielski const SwRect aRect( aRT, aRB );
6270*b1cdbd2cSJim Jagielski pUsedSubsLines->AddLineRect( aRect, 0, 0,
6271*b1cdbd2cSJim Jagielski (bBreak && bVert) ? SUBCOL_BREAK : nSubColor );
6272*b1cdbd2cSJim Jagielski }
6273*b1cdbd2cSJim Jagielski }
6274*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104822# - adjust control for drawing top and bottom lines
6275*b1cdbd2cSJim Jagielski if ( !bCell || bNewTableModel || bVert )
6276*b1cdbd2cSJim Jagielski {
6277*b1cdbd2cSJim Jagielski if ( aOriginal.Top() == aOut.Top() )
6278*b1cdbd2cSJim Jagielski {
6279*b1cdbd2cSJim Jagielski // OD 14.11.2002 #104821# - in horizontal layout set page/column break at top
6280*b1cdbd2cSJim Jagielski const SwRect aRect( aOut.Pos(), aRT );
6281*b1cdbd2cSJim Jagielski pUsedSubsLines->AddLineRect( aRect, 0, 0,
6282*b1cdbd2cSJim Jagielski (bBreak && !bVert) ? SUBCOL_BREAK : nSubColor );
6283*b1cdbd2cSJim Jagielski }
6284*b1cdbd2cSJim Jagielski if ( aOriginal.Bottom() == nBottom )
6285*b1cdbd2cSJim Jagielski {
6286*b1cdbd2cSJim Jagielski const SwRect aRect( aLB, aRB );
6287*b1cdbd2cSJim Jagielski pUsedSubsLines->AddLineRect( aRect, 0, 0, nSubColor );
6288*b1cdbd2cSJim Jagielski }
6289*b1cdbd2cSJim Jagielski }
6290*b1cdbd2cSJim Jagielski }
6291*b1cdbd2cSJim Jagielski }
6292*b1cdbd2cSJim Jagielski
6293*b1cdbd2cSJim Jagielski /*************************************************************************
6294*b1cdbd2cSJim Jagielski |*
6295*b1cdbd2cSJim Jagielski |* SwPageFrm::RefreshExtraData(), SwLayoutFrm::RefreshExtraData()
6296*b1cdbd2cSJim Jagielski |*
6297*b1cdbd2cSJim Jagielski |* Beschreibung Erneuert alle Extradaten (Zeilennummern usw) der Seite.
6298*b1cdbd2cSJim Jagielski |* Grundsaetzlich sind nur diejenigen Objekte beruecksichtig,
6299*b1cdbd2cSJim Jagielski |* die in die seitliche Ausdehnung des Rects ragen.
6300*b1cdbd2cSJim Jagielski |* Ersterstellung MA 20. Jan. 98
6301*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 18. Feb. 98
6302*b1cdbd2cSJim Jagielski |*
6303*b1cdbd2cSJim Jagielski |*************************************************************************/
6304*b1cdbd2cSJim Jagielski
RefreshExtraData(const SwRect & rRect) const6305*b1cdbd2cSJim Jagielski void SwPageFrm::RefreshExtraData( const SwRect &rRect ) const
6306*b1cdbd2cSJim Jagielski {
6307*b1cdbd2cSJim Jagielski const SwLineNumberInfo &rInfo = GetFmt()->GetDoc()->GetLineNumberInfo();
6308*b1cdbd2cSJim Jagielski sal_Bool bLineInFly = (rInfo.IsPaintLineNumbers() && rInfo.IsCountInFlys())
6309*b1cdbd2cSJim Jagielski || (sal_Int16)SW_MOD()->GetRedlineMarkPos() != text::HoriOrientation::NONE;
6310*b1cdbd2cSJim Jagielski
6311*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
6312*b1cdbd2cSJim Jagielski ::SwAlignRect( aRect, pGlobalShell );
6313*b1cdbd2cSJim Jagielski if ( aRect.HasArea() )
6314*b1cdbd2cSJim Jagielski {
6315*b1cdbd2cSJim Jagielski SwLayoutFrm::RefreshExtraData( aRect );
6316*b1cdbd2cSJim Jagielski
6317*b1cdbd2cSJim Jagielski if ( bLineInFly && GetSortedObjs() )
6318*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < GetSortedObjs()->Count(); ++i )
6319*b1cdbd2cSJim Jagielski {
6320*b1cdbd2cSJim Jagielski const SwAnchoredObject* pAnchoredObj = (*GetSortedObjs())[i];
6321*b1cdbd2cSJim Jagielski if ( pAnchoredObj->ISA(SwFlyFrm) )
6322*b1cdbd2cSJim Jagielski {
6323*b1cdbd2cSJim Jagielski const SwFlyFrm *pFly = static_cast<const SwFlyFrm*>(pAnchoredObj);
6324*b1cdbd2cSJim Jagielski if ( pFly->Frm().Top() <= aRect.Bottom() &&
6325*b1cdbd2cSJim Jagielski pFly->Frm().Bottom() >= aRect.Top() )
6326*b1cdbd2cSJim Jagielski pFly->RefreshExtraData( aRect );
6327*b1cdbd2cSJim Jagielski }
6328*b1cdbd2cSJim Jagielski }
6329*b1cdbd2cSJim Jagielski }
6330*b1cdbd2cSJim Jagielski }
6331*b1cdbd2cSJim Jagielski
RefreshExtraData(const SwRect & rRect) const6332*b1cdbd2cSJim Jagielski void SwLayoutFrm::RefreshExtraData( const SwRect &rRect ) const
6333*b1cdbd2cSJim Jagielski {
6334*b1cdbd2cSJim Jagielski
6335*b1cdbd2cSJim Jagielski const SwLineNumberInfo &rInfo = GetFmt()->GetDoc()->GetLineNumberInfo();
6336*b1cdbd2cSJim Jagielski sal_Bool bLineInBody = rInfo.IsPaintLineNumbers(),
6337*b1cdbd2cSJim Jagielski bLineInFly = bLineInBody && rInfo.IsCountInFlys(),
6338*b1cdbd2cSJim Jagielski bRedLine = (sal_Int16)SW_MOD()->GetRedlineMarkPos()!=text::HoriOrientation::NONE;
6339*b1cdbd2cSJim Jagielski
6340*b1cdbd2cSJim Jagielski const SwCntntFrm *pCnt = ContainsCntnt();
6341*b1cdbd2cSJim Jagielski while ( pCnt && IsAnLower( pCnt ) )
6342*b1cdbd2cSJim Jagielski {
6343*b1cdbd2cSJim Jagielski if ( pCnt->IsTxtFrm() && ( bRedLine ||
6344*b1cdbd2cSJim Jagielski ( !pCnt->IsInTab() &&
6345*b1cdbd2cSJim Jagielski ((bLineInBody && pCnt->IsInDocBody()) ||
6346*b1cdbd2cSJim Jagielski (bLineInFly && pCnt->IsInFly())) ) ) &&
6347*b1cdbd2cSJim Jagielski pCnt->Frm().Top() <= rRect.Bottom() &&
6348*b1cdbd2cSJim Jagielski pCnt->Frm().Bottom() >= rRect.Top() )
6349*b1cdbd2cSJim Jagielski {
6350*b1cdbd2cSJim Jagielski ((SwTxtFrm*)pCnt)->PaintExtraData( rRect );
6351*b1cdbd2cSJim Jagielski }
6352*b1cdbd2cSJim Jagielski if ( bLineInFly && pCnt->GetDrawObjs() )
6353*b1cdbd2cSJim Jagielski for ( sal_uInt32 i = 0; i < pCnt->GetDrawObjs()->Count(); ++i )
6354*b1cdbd2cSJim Jagielski {
6355*b1cdbd2cSJim Jagielski const SwAnchoredObject* pAnchoredObj = (*pCnt->GetDrawObjs())[i];
6356*b1cdbd2cSJim Jagielski if ( pAnchoredObj->ISA(SwFlyFrm) )
6357*b1cdbd2cSJim Jagielski {
6358*b1cdbd2cSJim Jagielski const SwFlyFrm *pFly = static_cast<const SwFlyFrm*>(pAnchoredObj);
6359*b1cdbd2cSJim Jagielski if ( pFly->IsFlyInCntFrm() &&
6360*b1cdbd2cSJim Jagielski pFly->Frm().Top() <= rRect.Bottom() &&
6361*b1cdbd2cSJim Jagielski pFly->Frm().Bottom() >= rRect.Top() )
6362*b1cdbd2cSJim Jagielski pFly->RefreshExtraData( rRect );
6363*b1cdbd2cSJim Jagielski }
6364*b1cdbd2cSJim Jagielski }
6365*b1cdbd2cSJim Jagielski pCnt = pCnt->GetNextCntntFrm();
6366*b1cdbd2cSJim Jagielski }
6367*b1cdbd2cSJim Jagielski }
6368*b1cdbd2cSJim Jagielski
6369*b1cdbd2cSJim Jagielski /** SwPageFrm::GetDrawBackgrdColor - for #102450#
6370*b1cdbd2cSJim Jagielski
6371*b1cdbd2cSJim Jagielski determine the color, that is respectively will be drawn as background
6372*b1cdbd2cSJim Jagielski for the page frame.
6373*b1cdbd2cSJim Jagielski Using existing method SwFrm::GetBackgroundBrush to determine the color
6374*b1cdbd2cSJim Jagielski that is set at the page frame respectively is parent. If none is found
6375*b1cdbd2cSJim Jagielski return the global retouche color
6376*b1cdbd2cSJim Jagielski
6377*b1cdbd2cSJim Jagielski @author OD
6378*b1cdbd2cSJim Jagielski
6379*b1cdbd2cSJim Jagielski @return Color
6380*b1cdbd2cSJim Jagielski */
GetDrawBackgrdColor() const6381*b1cdbd2cSJim Jagielski const Color& SwPageFrm::GetDrawBackgrdColor() const
6382*b1cdbd2cSJim Jagielski {
6383*b1cdbd2cSJim Jagielski const SvxBrushItem* pBrushItem;
6384*b1cdbd2cSJim Jagielski const Color* pDummyColor;
6385*b1cdbd2cSJim Jagielski SwRect aDummyRect;
6386*b1cdbd2cSJim Jagielski
6387*b1cdbd2cSJim Jagielski if ( GetBackgroundBrush( pBrushItem, pDummyColor, aDummyRect, true) )
6388*b1cdbd2cSJim Jagielski {
6389*b1cdbd2cSJim Jagielski const Graphic* pGraphic = pBrushItem->GetGraphic();
6390*b1cdbd2cSJim Jagielski
6391*b1cdbd2cSJim Jagielski if(pGraphic)
6392*b1cdbd2cSJim Jagielski {
6393*b1cdbd2cSJim Jagielski // #29105# when a graphic is set, it may be possible to calculate a single
6394*b1cdbd2cSJim Jagielski // color which looks good in all places of the graphic. Since it is
6395*b1cdbd2cSJim Jagielski // planned to have text edit on the overlay one day and the fallback
6396*b1cdbd2cSJim Jagielski // to aGlobalRetoucheColor returns something useful, just use that
6397*b1cdbd2cSJim Jagielski // for now.
6398*b1cdbd2cSJim Jagielski }
6399*b1cdbd2cSJim Jagielski else
6400*b1cdbd2cSJim Jagielski {
6401*b1cdbd2cSJim Jagielski // not a graphic, use (hopefully) initialized color
6402*b1cdbd2cSJim Jagielski return pBrushItem->GetColor();
6403*b1cdbd2cSJim Jagielski }
6404*b1cdbd2cSJim Jagielski }
6405*b1cdbd2cSJim Jagielski
6406*b1cdbd2cSJim Jagielski return aGlobalRetoucheColor;
6407*b1cdbd2cSJim Jagielski }
6408*b1cdbd2cSJim Jagielski
6409*b1cdbd2cSJim Jagielski /*************************************************************************
6410*b1cdbd2cSJim Jagielski |*
6411*b1cdbd2cSJim Jagielski |* SwPageFrm::GetEmptyPageFont()
6412*b1cdbd2cSJim Jagielski |*
6413*b1cdbd2cSJim Jagielski |* create/return font used to paint the "empty page" string
6414*b1cdbd2cSJim Jagielski |*
6415*b1cdbd2cSJim Jagielski |*************************************************************************/
6416*b1cdbd2cSJim Jagielski
GetEmptyPageFont()6417*b1cdbd2cSJim Jagielski const Font& SwPageFrm::GetEmptyPageFont()
6418*b1cdbd2cSJim Jagielski {
6419*b1cdbd2cSJim Jagielski static Font* pEmptyPgFont = 0;
6420*b1cdbd2cSJim Jagielski if ( 0 == pEmptyPgFont )
6421*b1cdbd2cSJim Jagielski {
6422*b1cdbd2cSJim Jagielski pEmptyPgFont = new Font;
6423*b1cdbd2cSJim Jagielski pEmptyPgFont->SetSize( Size( 0, 80 * 20 )); // == 80 pt
6424*b1cdbd2cSJim Jagielski pEmptyPgFont->SetWeight( WEIGHT_BOLD );
6425*b1cdbd2cSJim Jagielski pEmptyPgFont->SetStyleName( aEmptyStr );
6426*b1cdbd2cSJim Jagielski pEmptyPgFont->SetName( String::CreateFromAscii(
6427*b1cdbd2cSJim Jagielski RTL_CONSTASCII_STRINGPARAM( "Helvetica" )) );
6428*b1cdbd2cSJim Jagielski pEmptyPgFont->SetFamily( FAMILY_SWISS );
6429*b1cdbd2cSJim Jagielski pEmptyPgFont->SetTransparent( sal_True );
6430*b1cdbd2cSJim Jagielski pEmptyPgFont->SetColor( COL_GRAY );
6431*b1cdbd2cSJim Jagielski }
6432*b1cdbd2cSJim Jagielski
6433*b1cdbd2cSJim Jagielski return *pEmptyPgFont;
6434*b1cdbd2cSJim Jagielski }
6435*b1cdbd2cSJim Jagielski
6436*b1cdbd2cSJim Jagielski /*************************************************************************
6437*b1cdbd2cSJim Jagielski |*
6438*b1cdbd2cSJim Jagielski |* SwFrm::Retouche
6439*b1cdbd2cSJim Jagielski |*
6440*b1cdbd2cSJim Jagielski |* Beschreibung Retouche fuer einen Bereich.
6441*b1cdbd2cSJim Jagielski |* Retouche wird nur dann durchgefuehrt, wenn der Frm der letzte seiner
6442*b1cdbd2cSJim Jagielski |* Kette ist. Der Gesamte Bereich des Upper unterhalb des Frm wird
6443*b1cdbd2cSJim Jagielski |* per PaintBackground gecleared.
6444*b1cdbd2cSJim Jagielski |* Ersterstellung MA 13. Apr. 93
6445*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 25. Jul. 96
6446*b1cdbd2cSJim Jagielski |*
6447*b1cdbd2cSJim Jagielski |*************************************************************************/
6448*b1cdbd2cSJim Jagielski
Retouche(const SwPageFrm * pPage,const SwRect & rRect) const6449*b1cdbd2cSJim Jagielski void SwFrm::Retouche( const SwPageFrm * pPage, const SwRect &rRect ) const
6450*b1cdbd2cSJim Jagielski {
6451*b1cdbd2cSJim Jagielski if ( bFlyMetafile )
6452*b1cdbd2cSJim Jagielski return;
6453*b1cdbd2cSJim Jagielski
6454*b1cdbd2cSJim Jagielski ASSERT( GetUpper(), "Retoucheversuch ohne Upper." );
6455*b1cdbd2cSJim Jagielski ASSERT( getRootFrm()->GetCurrShell() && pGlobalShell->GetWin(), "Retouche auf dem Drucker?" );
6456*b1cdbd2cSJim Jagielski
6457*b1cdbd2cSJim Jagielski SwRect aRetouche( GetUpper()->PaintArea() );
6458*b1cdbd2cSJim Jagielski aRetouche.Top( Frm().Top() + Frm().Height() );
6459*b1cdbd2cSJim Jagielski aRetouche.Intersection( pGlobalShell->VisArea() );
6460*b1cdbd2cSJim Jagielski
6461*b1cdbd2cSJim Jagielski if ( aRetouche.HasArea() )
6462*b1cdbd2cSJim Jagielski {
6463*b1cdbd2cSJim Jagielski //Uebergebenes Rect ausparen. Dafuer brauchen wir leider eine Region
6464*b1cdbd2cSJim Jagielski //zum ausstanzen.
6465*b1cdbd2cSJim Jagielski SwRegionRects aRegion( aRetouche );
6466*b1cdbd2cSJim Jagielski aRegion -= rRect;
6467*b1cdbd2cSJim Jagielski ViewShell *pSh = getRootFrm()->GetCurrShell();
6468*b1cdbd2cSJim Jagielski
6469*b1cdbd2cSJim Jagielski // --> FME 2004-06-24 #i16816# tagged pdf support
6470*b1cdbd2cSJim Jagielski SwTaggedPDFHelper aTaggedPDFHelper( 0, 0, 0, *pSh->GetOut() );
6471*b1cdbd2cSJim Jagielski // <--
6472*b1cdbd2cSJim Jagielski
6473*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i )
6474*b1cdbd2cSJim Jagielski {
6475*b1cdbd2cSJim Jagielski SwRect &rRetouche = aRegion[i];
6476*b1cdbd2cSJim Jagielski
6477*b1cdbd2cSJim Jagielski GetUpper()->PaintBaBo( rRetouche, pPage, sal_True );
6478*b1cdbd2cSJim Jagielski
6479*b1cdbd2cSJim Jagielski //Hoelle und Himmel muessen auch refreshed werden.
6480*b1cdbd2cSJim Jagielski //Um Rekursionen zu vermeiden muss mein Retouche Flag zuerst
6481*b1cdbd2cSJim Jagielski //zurueckgesetzt werden!
6482*b1cdbd2cSJim Jagielski ResetRetouche();
6483*b1cdbd2cSJim Jagielski SwRect aRetouchePart( rRetouche );
6484*b1cdbd2cSJim Jagielski if ( aRetouchePart.HasArea() )
6485*b1cdbd2cSJim Jagielski {
6486*b1cdbd2cSJim Jagielski const Color aPageBackgrdColor = pPage->GetDrawBackgrdColor();
6487*b1cdbd2cSJim Jagielski const IDocumentDrawModelAccess* pIDDMA = pSh->getIDocumentDrawModelAccess();
6488*b1cdbd2cSJim Jagielski // --> OD #i76669#
6489*b1cdbd2cSJim Jagielski SwViewObjectContactRedirector aSwRedirector( *pSh );
6490*b1cdbd2cSJim Jagielski // <--
6491*b1cdbd2cSJim Jagielski
6492*b1cdbd2cSJim Jagielski pSh->Imp()->PaintLayer( pIDDMA->GetHellId(), 0,
6493*b1cdbd2cSJim Jagielski aRetouchePart, &aPageBackgrdColor,
6494*b1cdbd2cSJim Jagielski (pPage->IsRightToLeft() ? true : false),
6495*b1cdbd2cSJim Jagielski &aSwRedirector );
6496*b1cdbd2cSJim Jagielski pSh->Imp()->PaintLayer( pIDDMA->GetHeavenId(), 0,
6497*b1cdbd2cSJim Jagielski aRetouchePart, &aPageBackgrdColor,
6498*b1cdbd2cSJim Jagielski (pPage->IsRightToLeft() ? true : false),
6499*b1cdbd2cSJim Jagielski &aSwRedirector );
6500*b1cdbd2cSJim Jagielski }
6501*b1cdbd2cSJim Jagielski
6502*b1cdbd2cSJim Jagielski SetRetouche();
6503*b1cdbd2cSJim Jagielski
6504*b1cdbd2cSJim Jagielski //Da wir uns ausserhalb aller Paint-Bereiche begeben muessen hier
6505*b1cdbd2cSJim Jagielski //leider die Hilfslinien erneuert werden.
6506*b1cdbd2cSJim Jagielski pPage->RefreshSubsidiary( aRetouchePart );
6507*b1cdbd2cSJim Jagielski }
6508*b1cdbd2cSJim Jagielski }
6509*b1cdbd2cSJim Jagielski if ( ViewShell::IsLstEndAction() )
6510*b1cdbd2cSJim Jagielski ResetRetouche();
6511*b1cdbd2cSJim Jagielski }
6512*b1cdbd2cSJim Jagielski
6513*b1cdbd2cSJim Jagielski /** SwFrm::GetBackgroundBrush
6514*b1cdbd2cSJim Jagielski
6515*b1cdbd2cSJim Jagielski @descr
6516*b1cdbd2cSJim Jagielski determine the background brush for the frame:
6517*b1cdbd2cSJim Jagielski the background brush is taken from it-self or from its parent (anchor/upper).
6518*b1cdbd2cSJim Jagielski Normally, the background brush is taken, which has no transparent color or
6519*b1cdbd2cSJim Jagielski which has a background graphic. But there are some special cases:
6520*b1cdbd2cSJim Jagielski (1) No background brush is taken from a page frame, if view option "IsPageBack"
6521*b1cdbd2cSJim Jagielski isn't set.
6522*b1cdbd2cSJim Jagielski (2) Background brush from a index section is taken under special conditions.
6523*b1cdbd2cSJim Jagielski In this case parameter <rpCol> is set to the index shading color.
6524*b1cdbd2cSJim Jagielski (3) New (OD 20.08.2002) - Background brush is taken, if on background drawing
6525*b1cdbd2cSJim Jagielski of the frame transparency is considered and its color is not "no fill"/"auto fill"
6526*b1cdbd2cSJim Jagielski ---- old description in german:
6527*b1cdbd2cSJim Jagielski Beschreibung Liefert die Backgroundbrush fuer den Bereich des
6528*b1cdbd2cSJim Jagielski des Frm. Die Brush wird entweder von ihm selbst oder von einem
6529*b1cdbd2cSJim Jagielski Upper vorgegeben, die erste Brush wird benutzt.
6530*b1cdbd2cSJim Jagielski Ist fuer keinen Frm eine Brush angegeben, so wird sal_False zurueck-
6531*b1cdbd2cSJim Jagielski geliefert.
6532*b1cdbd2cSJim Jagielski Ersterstellung MA 23. Dec. 92
6533*b1cdbd2cSJim Jagielski Letzte Aenderung MA 04. Feb. 97
6534*b1cdbd2cSJim Jagielski
6535*b1cdbd2cSJim Jagielski @param rpBrush
6536*b1cdbd2cSJim Jagielski output parameter - constant reference pointer the found background brush
6537*b1cdbd2cSJim Jagielski
6538*b1cdbd2cSJim Jagielski @param rpCol
6539*b1cdbd2cSJim Jagielski output parameter - constant reference pointer to the color of the index shading
6540*b1cdbd2cSJim Jagielski set under special conditions, if background brush is taken from an index section.
6541*b1cdbd2cSJim Jagielski
6542*b1cdbd2cSJim Jagielski @param rOrigRect
6543*b1cdbd2cSJim Jagielski in-/output parameter - reference to the retangle the background brush is
6544*b1cdbd2cSJim Jagielski considered for - adjusted to the frame, from which the background brush is
6545*b1cdbd2cSJim Jagielski taken.
6546*b1cdbd2cSJim Jagielski
6547*b1cdbd2cSJim Jagielski @parem bLowerMode
6548*b1cdbd2cSJim Jagielski input parameter - boolean indicating, if background brush should *not* be
6549*b1cdbd2cSJim Jagielski taken from parent.
6550*b1cdbd2cSJim Jagielski
6551*b1cdbd2cSJim Jagielski @author MA
6552*b1cdbd2cSJim Jagielski @change 20.08.2002 by OD
6553*b1cdbd2cSJim Jagielski @docdate 20.08.2002
6554*b1cdbd2cSJim Jagielski
6555*b1cdbd2cSJim Jagielski @return true, if a background brush for the frame is found
6556*b1cdbd2cSJim Jagielski */
GetBackgroundBrush(const SvxBrushItem * & rpBrush,const Color * & rpCol,SwRect & rOrigRect,sal_Bool bLowerMode) const6557*b1cdbd2cSJim Jagielski sal_Bool SwFrm::GetBackgroundBrush( const SvxBrushItem* & rpBrush,
6558*b1cdbd2cSJim Jagielski const Color*& rpCol,
6559*b1cdbd2cSJim Jagielski SwRect &rOrigRect,
6560*b1cdbd2cSJim Jagielski sal_Bool bLowerMode ) const
6561*b1cdbd2cSJim Jagielski {
6562*b1cdbd2cSJim Jagielski const SwFrm *pFrm = this;
6563*b1cdbd2cSJim Jagielski ViewShell *pSh = getRootFrm()->GetCurrShell();
6564*b1cdbd2cSJim Jagielski const SwViewOption *pOpt = pSh->GetViewOptions();
6565*b1cdbd2cSJim Jagielski rpBrush = 0;
6566*b1cdbd2cSJim Jagielski rpCol = NULL;
6567*b1cdbd2cSJim Jagielski do
6568*b1cdbd2cSJim Jagielski { if ( pFrm->IsPageFrm() && !pOpt->IsPageBack() )
6569*b1cdbd2cSJim Jagielski return sal_False;
6570*b1cdbd2cSJim Jagielski
6571*b1cdbd2cSJim Jagielski const SvxBrushItem &rBack = pFrm->GetAttrSet()->GetBackground();
6572*b1cdbd2cSJim Jagielski if( pFrm->IsSctFrm() )
6573*b1cdbd2cSJim Jagielski {
6574*b1cdbd2cSJim Jagielski const SwSection* pSection = ((SwSectionFrm*)pFrm)->GetSection();
6575*b1cdbd2cSJim Jagielski /// OD 20.08.2002 #99657# #GetTransChg#
6576*b1cdbd2cSJim Jagielski /// Note: If frame <pFrm> is a section of the index and
6577*b1cdbd2cSJim Jagielski /// it its background color is "no fill"/"auto fill" and
6578*b1cdbd2cSJim Jagielski /// it has no background graphic and
6579*b1cdbd2cSJim Jagielski /// we are not in the page preview and
6580*b1cdbd2cSJim Jagielski /// we are not in read-only mode and
6581*b1cdbd2cSJim Jagielski /// option "index shadings" is set and
6582*b1cdbd2cSJim Jagielski /// the output is not the printer
6583*b1cdbd2cSJim Jagielski /// then set <rpCol> to the color of the index shading
6584*b1cdbd2cSJim Jagielski if( pSection && ( TOX_HEADER_SECTION == pSection->GetType() ||
6585*b1cdbd2cSJim Jagielski TOX_CONTENT_SECTION == pSection->GetType() ) &&
6586*b1cdbd2cSJim Jagielski (rBack.GetColor() == COL_TRANSPARENT) &&
6587*b1cdbd2cSJim Jagielski ///rBack.GetColor().GetTransparency() &&
6588*b1cdbd2cSJim Jagielski rBack.GetGraphicPos() == GPOS_NONE &&
6589*b1cdbd2cSJim Jagielski !pOpt->IsPagePreview() &&
6590*b1cdbd2cSJim Jagielski !pOpt->IsReadonly() &&
6591*b1cdbd2cSJim Jagielski // --> FME 2004-06-29 #114856# Formular view
6592*b1cdbd2cSJim Jagielski !pOpt->IsFormView() &&
6593*b1cdbd2cSJim Jagielski // <--
6594*b1cdbd2cSJim Jagielski SwViewOption::IsIndexShadings() &&
6595*b1cdbd2cSJim Jagielski !pOpt->IsPDFExport() &&
6596*b1cdbd2cSJim Jagielski pSh->GetOut()->GetOutDevType() != OUTDEV_PRINTER )
6597*b1cdbd2cSJim Jagielski {
6598*b1cdbd2cSJim Jagielski rpCol = &SwViewOption::GetIndexShadingsColor();
6599*b1cdbd2cSJim Jagielski }
6600*b1cdbd2cSJim Jagielski }
6601*b1cdbd2cSJim Jagielski
6602*b1cdbd2cSJim Jagielski /// OD 20.08.2002 #99657#
6603*b1cdbd2cSJim Jagielski /// determine, if background draw of frame <pFrm> considers transparency
6604*b1cdbd2cSJim Jagielski /// --> Status Quo: background transparency have to be
6605*b1cdbd2cSJim Jagielski /// considered for fly frames
6606*b1cdbd2cSJim Jagielski const sal_Bool bConsiderBackgroundTransparency = pFrm->IsFlyFrm();
6607*b1cdbd2cSJim Jagielski /// OD 20.08.2002 #99657#
6608*b1cdbd2cSJim Jagielski /// add condition:
6609*b1cdbd2cSJim Jagielski /// If <bConsiderBackgroundTransparency> is set - see above -,
6610*b1cdbd2cSJim Jagielski /// return brush of frame <pFrm>, if its color is *not* "no fill"/"auto fill"
6611*b1cdbd2cSJim Jagielski if ( !rBack.GetColor().GetTransparency() ||
6612*b1cdbd2cSJim Jagielski rBack.GetGraphicPos() != GPOS_NONE ||
6613*b1cdbd2cSJim Jagielski rpCol ||
6614*b1cdbd2cSJim Jagielski (bConsiderBackgroundTransparency && (rBack.GetColor() != COL_TRANSPARENT))
6615*b1cdbd2cSJim Jagielski )
6616*b1cdbd2cSJim Jagielski {
6617*b1cdbd2cSJim Jagielski rpBrush = &rBack;
6618*b1cdbd2cSJim Jagielski if ( pFrm->IsPageFrm() &&
6619*b1cdbd2cSJim Jagielski pSh->GetViewOptions()->getBrowseMode() )
6620*b1cdbd2cSJim Jagielski rOrigRect = pFrm->Frm();
6621*b1cdbd2cSJim Jagielski else
6622*b1cdbd2cSJim Jagielski {
6623*b1cdbd2cSJim Jagielski if ( pFrm->Frm().SSize() != pFrm->Prt().SSize() )
6624*b1cdbd2cSJim Jagielski {
6625*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), pFrm );
6626*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
6627*b1cdbd2cSJim Jagielski ::lcl_CalcBorderRect( rOrigRect, pFrm, rAttrs, sal_False );
6628*b1cdbd2cSJim Jagielski }
6629*b1cdbd2cSJim Jagielski else
6630*b1cdbd2cSJim Jagielski {
6631*b1cdbd2cSJim Jagielski rOrigRect = pFrm->Prt();
6632*b1cdbd2cSJim Jagielski rOrigRect += pFrm->Frm().Pos();
6633*b1cdbd2cSJim Jagielski }
6634*b1cdbd2cSJim Jagielski }
6635*b1cdbd2cSJim Jagielski return sal_True;
6636*b1cdbd2cSJim Jagielski }
6637*b1cdbd2cSJim Jagielski
6638*b1cdbd2cSJim Jagielski if ( bLowerMode )
6639*b1cdbd2cSJim Jagielski /// Do not try to get background brush from parent (anchor/upper)
6640*b1cdbd2cSJim Jagielski return sal_False;
6641*b1cdbd2cSJim Jagielski
6642*b1cdbd2cSJim Jagielski /// get parent frame - anchor or upper - for next loop
6643*b1cdbd2cSJim Jagielski if ( pFrm->IsFlyFrm() )
6644*b1cdbd2cSJim Jagielski /// OD 20.08.2002 - use "static_cast" instead of "old C-cast"
6645*b1cdbd2cSJim Jagielski pFrm = (static_cast<const SwFlyFrm*>(pFrm))->GetAnchorFrm();
6646*b1cdbd2cSJim Jagielski ///pFrm = ((SwFlyFrm*)pFrm)->GetAnchor();
6647*b1cdbd2cSJim Jagielski else
6648*b1cdbd2cSJim Jagielski pFrm = pFrm->GetUpper();
6649*b1cdbd2cSJim Jagielski
6650*b1cdbd2cSJim Jagielski } while ( pFrm );
6651*b1cdbd2cSJim Jagielski
6652*b1cdbd2cSJim Jagielski return sal_False;
6653*b1cdbd2cSJim Jagielski }
6654*b1cdbd2cSJim Jagielski
6655*b1cdbd2cSJim Jagielski /*************************************************************************
6656*b1cdbd2cSJim Jagielski |*
6657*b1cdbd2cSJim Jagielski |* SwFrmFmt::GetGraphic()
6658*b1cdbd2cSJim Jagielski |*
6659*b1cdbd2cSJim Jagielski |* Ersterstellung MA 23. Jul. 96
6660*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 23. Jul. 96
6661*b1cdbd2cSJim Jagielski |*
6662*b1cdbd2cSJim Jagielski |*************************************************************************/
6663*b1cdbd2cSJim Jagielski
SetOutDevAndWin(ViewShell * pSh,OutputDevice * pO,Window * pW,sal_uInt16 nZoom)6664*b1cdbd2cSJim Jagielski void SetOutDevAndWin( ViewShell *pSh, OutputDevice *pO,
6665*b1cdbd2cSJim Jagielski Window *pW, sal_uInt16 nZoom )
6666*b1cdbd2cSJim Jagielski {
6667*b1cdbd2cSJim Jagielski pSh->pOut = pO;
6668*b1cdbd2cSJim Jagielski pSh->pWin = pW;
6669*b1cdbd2cSJim Jagielski pSh->pOpt->SetZoom( nZoom );
6670*b1cdbd2cSJim Jagielski }
6671*b1cdbd2cSJim Jagielski
MakeGraphic(ImageMap *)6672*b1cdbd2cSJim Jagielski Graphic SwFrmFmt::MakeGraphic( ImageMap* )
6673*b1cdbd2cSJim Jagielski {
6674*b1cdbd2cSJim Jagielski return Graphic();
6675*b1cdbd2cSJim Jagielski }
6676*b1cdbd2cSJim Jagielski
MakeGraphic(ImageMap * pMap)6677*b1cdbd2cSJim Jagielski Graphic SwFlyFrmFmt::MakeGraphic( ImageMap* pMap )
6678*b1cdbd2cSJim Jagielski {
6679*b1cdbd2cSJim Jagielski Graphic aRet;
6680*b1cdbd2cSJim Jagielski //irgendeinen Fly suchen!
6681*b1cdbd2cSJim Jagielski SwIterator<SwFrm,SwFmt> aIter( *this );
6682*b1cdbd2cSJim Jagielski SwFrm *pFirst = aIter.First();
6683*b1cdbd2cSJim Jagielski ViewShell *pSh;
6684*b1cdbd2cSJim Jagielski if ( pFirst && 0 != ( pSh = pFirst->getRootFrm()->GetCurrShell()) )
6685*b1cdbd2cSJim Jagielski {
6686*b1cdbd2cSJim Jagielski ViewShell *pOldGlobal = pGlobalShell;
6687*b1cdbd2cSJim Jagielski pGlobalShell = pSh;
6688*b1cdbd2cSJim Jagielski
6689*b1cdbd2cSJim Jagielski sal_Bool bNoteURL = pMap &&
6690*b1cdbd2cSJim Jagielski SFX_ITEM_SET != GetAttrSet().GetItemState( RES_URL, sal_True );
6691*b1cdbd2cSJim Jagielski if( bNoteURL )
6692*b1cdbd2cSJim Jagielski {
6693*b1cdbd2cSJim Jagielski ASSERT( !pNoteURL, "MakeGraphic: pNoteURL already used? " );
6694*b1cdbd2cSJim Jagielski pNoteURL = new SwNoteURL;
6695*b1cdbd2cSJim Jagielski }
6696*b1cdbd2cSJim Jagielski SwFlyFrm *pFly = (SwFlyFrm*)pFirst;
6697*b1cdbd2cSJim Jagielski
6698*b1cdbd2cSJim Jagielski OutputDevice *pOld = pSh->GetOut();
6699*b1cdbd2cSJim Jagielski VirtualDevice aDev( *pOld );
6700*b1cdbd2cSJim Jagielski aDev.EnableOutput( sal_False );
6701*b1cdbd2cSJim Jagielski
6702*b1cdbd2cSJim Jagielski GDIMetaFile aMet;
6703*b1cdbd2cSJim Jagielski MapMode aMap( pOld->GetMapMode().GetMapUnit() );
6704*b1cdbd2cSJim Jagielski aDev.SetMapMode( aMap );
6705*b1cdbd2cSJim Jagielski aMet.SetPrefMapMode( aMap );
6706*b1cdbd2cSJim Jagielski
6707*b1cdbd2cSJim Jagielski ::SwCalcPixStatics( pSh->GetOut() );
6708*b1cdbd2cSJim Jagielski aMet.SetPrefSize( pFly->Frm().SSize() );
6709*b1cdbd2cSJim Jagielski
6710*b1cdbd2cSJim Jagielski aMet.Record( &aDev );
6711*b1cdbd2cSJim Jagielski aDev.SetLineColor();
6712*b1cdbd2cSJim Jagielski aDev.SetFillColor();
6713*b1cdbd2cSJim Jagielski aDev.SetFont( pOld->GetFont() );
6714*b1cdbd2cSJim Jagielski
6715*b1cdbd2cSJim Jagielski //Rechteck ggf. ausdehnen, damit die Umrandunge mit aufgezeichnet werden.
6716*b1cdbd2cSJim Jagielski SwRect aOut( pFly->Frm() );
6717*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), pFly );
6718*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
6719*b1cdbd2cSJim Jagielski if ( rAttrs.CalcRightLine() )
6720*b1cdbd2cSJim Jagielski aOut.SSize().Width() += 2*nPixelSzW;
6721*b1cdbd2cSJim Jagielski if ( rAttrs.CalcBottomLine() )
6722*b1cdbd2cSJim Jagielski aOut.SSize().Height()+= 2*nPixelSzH;
6723*b1cdbd2cSJim Jagielski
6724*b1cdbd2cSJim Jagielski // #i92711# start Pre/PostPaint encapsulation before pOut is changed to the buffering VDev
6725*b1cdbd2cSJim Jagielski const Region aRepaintRegion(aOut.SVRect());
6726*b1cdbd2cSJim Jagielski pSh->DLPrePaint2(aRepaintRegion);
6727*b1cdbd2cSJim Jagielski
6728*b1cdbd2cSJim Jagielski Window *pWin = pSh->GetWin();
6729*b1cdbd2cSJim Jagielski sal_uInt16 nZoom = pSh->GetViewOptions()->GetZoom();
6730*b1cdbd2cSJim Jagielski ::SetOutDevAndWin( pSh, &aDev, 0, 100 );
6731*b1cdbd2cSJim Jagielski bFlyMetafile = sal_True;
6732*b1cdbd2cSJim Jagielski pFlyMetafileOut = pWin;
6733*b1cdbd2cSJim Jagielski
6734*b1cdbd2cSJim Jagielski SwViewImp *pImp = pSh->Imp();
6735*b1cdbd2cSJim Jagielski pFlyOnlyDraw = pFly;
6736*b1cdbd2cSJim Jagielski pLines = new SwLineRects;
6737*b1cdbd2cSJim Jagielski
6738*b1cdbd2cSJim Jagielski // OD 09.12.2002 #103045# - determine page, fly frame is on
6739*b1cdbd2cSJim Jagielski const SwPageFrm* pFlyPage = pFly->FindPageFrm();
6740*b1cdbd2cSJim Jagielski const Color aPageBackgrdColor = pFlyPage->GetDrawBackgrdColor();
6741*b1cdbd2cSJim Jagielski const IDocumentDrawModelAccess* pIDDMA = pSh->getIDocumentDrawModelAccess();
6742*b1cdbd2cSJim Jagielski // --> OD #i76669#
6743*b1cdbd2cSJim Jagielski SwViewObjectContactRedirector aSwRedirector( *pSh );
6744*b1cdbd2cSJim Jagielski // <--
6745*b1cdbd2cSJim Jagielski pImp->PaintLayer( pIDDMA->GetHellId(), 0, aOut, &aPageBackgrdColor,
6746*b1cdbd2cSJim Jagielski (pFlyPage->IsRightToLeft() ? true : false),
6747*b1cdbd2cSJim Jagielski &aSwRedirector );
6748*b1cdbd2cSJim Jagielski pLines->PaintLines( &aDev );
6749*b1cdbd2cSJim Jagielski if ( pFly->IsFlyInCntFrm() )
6750*b1cdbd2cSJim Jagielski pFly->Paint( aOut );
6751*b1cdbd2cSJim Jagielski pLines->PaintLines( &aDev );
6752*b1cdbd2cSJim Jagielski /// OD 30.08.2002 #102450# - add 3rd parameter
6753*b1cdbd2cSJim Jagielski pImp->PaintLayer( pIDDMA->GetHeavenId(), 0, aOut, &aPageBackgrdColor,
6754*b1cdbd2cSJim Jagielski (pFlyPage->IsRightToLeft() ? true : false),
6755*b1cdbd2cSJim Jagielski &aSwRedirector );
6756*b1cdbd2cSJim Jagielski pLines->PaintLines( &aDev );
6757*b1cdbd2cSJim Jagielski DELETEZ( pLines );
6758*b1cdbd2cSJim Jagielski pFlyOnlyDraw = 0;
6759*b1cdbd2cSJim Jagielski
6760*b1cdbd2cSJim Jagielski pFlyMetafileOut = 0;
6761*b1cdbd2cSJim Jagielski bFlyMetafile = sal_False;
6762*b1cdbd2cSJim Jagielski ::SetOutDevAndWin( pSh, pOld, pWin, nZoom );
6763*b1cdbd2cSJim Jagielski
6764*b1cdbd2cSJim Jagielski // #i92711# end Pre/PostPaint encapsulation when pOut is back and content is painted
6765*b1cdbd2cSJim Jagielski pSh->DLPostPaint2(true);
6766*b1cdbd2cSJim Jagielski
6767*b1cdbd2cSJim Jagielski aMet.Stop();
6768*b1cdbd2cSJim Jagielski aMet.Move( -pFly->Frm().Left(), -pFly->Frm().Top() );
6769*b1cdbd2cSJim Jagielski aRet = Graphic( aMet );
6770*b1cdbd2cSJim Jagielski
6771*b1cdbd2cSJim Jagielski if( bNoteURL )
6772*b1cdbd2cSJim Jagielski {
6773*b1cdbd2cSJim Jagielski ASSERT( pNoteURL, "MakeGraphic: Good Bye, NoteURL." );
6774*b1cdbd2cSJim Jagielski pNoteURL->FillImageMap( pMap, pFly->Frm().Pos(), aMap );
6775*b1cdbd2cSJim Jagielski delete pNoteURL;
6776*b1cdbd2cSJim Jagielski pNoteURL = NULL;
6777*b1cdbd2cSJim Jagielski }
6778*b1cdbd2cSJim Jagielski pGlobalShell = pOldGlobal;
6779*b1cdbd2cSJim Jagielski }
6780*b1cdbd2cSJim Jagielski return aRet;
6781*b1cdbd2cSJim Jagielski }
6782*b1cdbd2cSJim Jagielski
MakeGraphic(ImageMap *)6783*b1cdbd2cSJim Jagielski Graphic SwDrawFrmFmt::MakeGraphic( ImageMap* )
6784*b1cdbd2cSJim Jagielski {
6785*b1cdbd2cSJim Jagielski Graphic aRet;
6786*b1cdbd2cSJim Jagielski SdrModel *pMod = getIDocumentDrawModelAccess()->GetDrawModel();
6787*b1cdbd2cSJim Jagielski if ( pMod )
6788*b1cdbd2cSJim Jagielski {
6789*b1cdbd2cSJim Jagielski SdrObject *pObj = FindSdrObject();
6790*b1cdbd2cSJim Jagielski SdrView *pView = new SdrView( pMod );
6791*b1cdbd2cSJim Jagielski SdrPageView *pPgView = pView->ShowSdrPage(pView->GetModel()->GetPage(0));
6792*b1cdbd2cSJim Jagielski pView->MarkObj( pObj, pPgView );
6793*b1cdbd2cSJim Jagielski aRet = pView->GetMarkedObjBitmapEx();
6794*b1cdbd2cSJim Jagielski pView->HideSdrPage();
6795*b1cdbd2cSJim Jagielski delete pView;
6796*b1cdbd2cSJim Jagielski }
6797*b1cdbd2cSJim Jagielski return aRet;
6798*b1cdbd2cSJim Jagielski }
6799*b1cdbd2cSJim Jagielski
6800*b1cdbd2cSJim Jagielski
6801