Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sfx2/app.hxx>
21 : #include <sfx2/objsh.hxx>
22 : #include <tools/resary.hxx>
23 : #include <vcl/graph.hxx>
24 : #include <sfx2/viewsh.hxx>
25 : #include <svl/itemiter.hxx>
26 : #include <svl/languageoptions.hxx>
27 : #include <vcl/msgbox.hxx>
28 : #include <unotools/configitem.hxx>
29 : #include <sfx2/htmlmode.hxx>
30 : #include <sal/macros.h>
31 :
32 : #include <cuires.hrc>
33 : #include "helpid.hrc"
34 : #include "page.hxx"
35 : #include <svx/pageitem.hxx>
36 : #include <editeng/brushitem.hxx>
37 : #include <editeng/boxitem.hxx>
38 : #include <editeng/shaditem.hxx>
39 : #include <editeng/pbinitem.hxx>
40 : #include <editeng/lrspitem.hxx>
41 : #include <editeng/ulspitem.hxx>
42 : #include <editeng/sizeitem.hxx>
43 : #include <editeng/frmdiritem.hxx>
44 : #include "svx/dlgutil.hxx"
45 : #include <editeng/paperinf.hxx>
46 : #include <dialmgr.hxx>
47 : #include <sfx2/module.hxx>
48 : #include <svl/stritem.hxx>
49 : #include <svx/dialogs.hrc> // for RID_SVXPAGE_PAGE
50 : #include <editeng/eerdll.hxx>
51 : #include <editeng/editrids.hrc> // for RID_SVXSTR_PAPERBIN...,
52 : #include <svx/svxids.hrc>
53 :
54 : // #i4219#
55 : #include <svtools/optionsdrawinglayer.hxx>
56 : #include <svl/slstitm.hxx>
57 : #include <svl/aeitem.hxx>
58 : #include <sfx2/request.hxx>
59 :
60 : #include <numpages.hxx> // for GetI18nNumbering()
61 :
62 : // static ----------------------------------------------------------------
63 :
64 : static const long MINBODY = 284; // 0,5 cm rounded up in twips
65 : //static const long PRINT_OFFSET = 17; // 0,03 cm rounded down in twips
66 : static const long PRINT_OFFSET = 0; // why was this ever set to 17 ? it led to wrong right and bottom margins.
67 :
68 : static sal_uInt16 pRanges[] =
69 : {
70 : SID_ATTR_BORDER_OUTER,
71 : SID_ATTR_BORDER_SHADOW,
72 : SID_ATTR_LRSPACE,
73 : SID_ATTR_PAGE_SHARED,
74 : SID_SWREGISTER_COLLECTION,
75 : SID_SWREGISTER_MODE,
76 : 0
77 : };
78 : // ------- Mapping page layout ------------------------------------------
79 :
80 : sal_uInt16 aArr[] =
81 : {
82 : SVX_PAGE_ALL,
83 : SVX_PAGE_MIRROR,
84 : SVX_PAGE_RIGHT,
85 : SVX_PAGE_LEFT
86 : };
87 :
88 : // -----------------------------------------------------------------------
89 :
90 0 : sal_uInt16 PageUsageToPos_Impl( sal_uInt16 nUsage )
91 : {
92 0 : for ( sal_uInt16 i = 0; i < SAL_N_ELEMENTS(aArr); ++i )
93 0 : if ( aArr[i] == ( nUsage & 0x000f ) )
94 0 : return i;
95 0 : return SVX_PAGE_ALL;
96 : }
97 :
98 : // -----------------------------------------------------------------------
99 :
100 0 : sal_uInt16 PosToPageUsage_Impl( sal_uInt16 nPos )
101 : {
102 0 : if ( nPos >= SAL_N_ELEMENTS(aArr) )
103 0 : return 0;
104 0 : return aArr[nPos];
105 : }
106 :
107 : // -----------------------------------------------------------------------
108 :
109 0 : Size GetMinBorderSpace_Impl( const SvxShadowItem& rShadow, const SvxBoxItem& rBox )
110 : {
111 0 : Size aSz;
112 0 : aSz.Height() = rShadow.CalcShadowSpace( SHADOW_BOTTOM ) + rBox.CalcLineSpace( BOX_LINE_BOTTOM );
113 0 : aSz.Height() += rShadow.CalcShadowSpace( SHADOW_TOP ) + rBox.CalcLineSpace( BOX_LINE_TOP );
114 0 : aSz.Width() = rShadow.CalcShadowSpace( SHADOW_LEFT ) + rBox.CalcLineSpace( BOX_LINE_LEFT );
115 0 : aSz.Width() += rShadow.CalcShadowSpace( SHADOW_RIGHT ) + rBox.CalcLineSpace( BOX_LINE_RIGHT );
116 0 : return aSz;
117 : }
118 :
119 : // -----------------------------------------------------------------------
120 :
121 0 : long ConvertLong_Impl( const long nIn, SfxMapUnit eUnit )
122 : {
123 0 : return OutputDevice::LogicToLogic( nIn, (MapUnit)eUnit, MAP_TWIP );
124 : }
125 :
126 0 : sal_Bool IsEqualSize_Impl( const SvxSizeItem* pSize, const Size& rSize )
127 : {
128 0 : if ( pSize )
129 : {
130 0 : Size aSize = pSize->GetSize();
131 0 : long nDiffW = std::abs( rSize.Width () - aSize.Width () );
132 0 : long nDiffH = std::abs( rSize.Height() - aSize.Height() );
133 0 : return ( nDiffW < 10 && nDiffH < 10 );
134 : }
135 : else
136 0 : return sal_False;
137 : }
138 :
139 : // -----------------------------------------------------------------------
140 :
141 : #define MARGIN_LEFT ( (MarginPosition)0x0001 )
142 : #define MARGIN_RIGHT ( (MarginPosition)0x0002 )
143 : #define MARGIN_TOP ( (MarginPosition)0x0004 )
144 : #define MARGIN_BOTTOM ( (MarginPosition)0x0008 )
145 :
146 : struct SvxPage_Impl
147 : {
148 : MarginPosition m_nPos;
149 : Printer* mpDefPrinter;
150 : bool mbDelPrinter;
151 :
152 0 : SvxPage_Impl() :
153 : m_nPos( 0 ),
154 : mpDefPrinter( 0 ),
155 0 : mbDelPrinter( false ) {}
156 :
157 0 : ~SvxPage_Impl() { if ( mbDelPrinter ) delete mpDefPrinter; }
158 : };
159 :
160 : // class SvxPageDescPage --------------------------------------------------
161 :
162 : // returns the range of the Which values
163 0 : sal_uInt16* SvxPageDescPage::GetRanges()
164 : {
165 0 : return pRanges;
166 : }
167 :
168 : // -----------------------------------------------------------------------
169 :
170 0 : SfxTabPage* SvxPageDescPage::Create( Window* pParent, const SfxItemSet& rSet )
171 : {
172 0 : return new SvxPageDescPage( pParent, rSet );
173 : }
174 :
175 : // -----------------------------------------------------------------------
176 :
177 0 : SvxPageDescPage::SvxPageDescPage( Window* pParent, const SfxItemSet& rAttr ) :
178 :
179 : SfxTabPage( pParent, "PageFormatPage", "cui/ui/pageformatpage.ui", rAttr ),
180 :
181 : bLandscape ( sal_False ),
182 : eMode ( SVX_PAGE_MODE_STANDARD ),
183 : ePaperStart ( PAPER_A3 ),
184 : ePaperEnd ( PAPER_ENV_DL ),
185 0 : pImpl ( new SvxPage_Impl )
186 :
187 : {
188 0 : get(m_pPaperSizeBox,"comboPageFormat");
189 0 : get(m_pPaperWidthEdit,"spinWidth");
190 0 : get(m_pPaperHeightEdit,"spinHeight");
191 :
192 0 : get(m_pOrientationFT,"labelOrientation");
193 0 : get(m_pPortraitBtn,"radiobuttonPortrait");
194 0 : get(m_pLandscapeBtn,"radiobuttonLandscape");
195 :
196 0 : get(m_pBspWin,"drawingareaPageDirection");
197 0 : get(m_pTextFlowLbl,"labelTextFlow");
198 0 : get(m_pTextFlowBox,"comboTextFlowBox");
199 0 : get(m_pPaperTrayBox,"comboPaperTray");
200 :
201 0 : get(m_pLeftMarginLbl,"labelLeftMargin");
202 0 : get(m_pLeftMarginEdit,"spinMargLeft");
203 0 : get(m_pRightMarginLbl,"labelRightMargin");
204 0 : get(m_pRightMarginEdit,"spinMargRight");
205 :
206 0 : get(m_pTopMarginEdit,"spinMargTop");
207 :
208 0 : get(m_pBottomMarginEdit,"spinMargBot");
209 :
210 0 : get(m_pPageText,"labelPageLayout");
211 0 : get(m_pLayoutBox,"comboPageLayout");
212 0 : get(m_pNumberFormatBox,"comboLayoutFormat");
213 :
214 0 : get(m_pRegisterCB,"checkRegisterTrue");
215 0 : get(m_pRegisterFT,"labelRegisterStyle");
216 0 : get(m_pRegisterLB,"comboRegisterStyle");
217 :
218 0 : get(m_pTblAlignFT,"labelTblAlign");
219 0 : get(m_pHorzBox,"checkbuttonHorz");
220 0 : get(m_pVertBox,"checkbuttonVert");
221 :
222 0 : get(m_pAdaptBox,"checkAdaptBox");
223 : // Strings stored in UI
224 0 : get(m_pInsideLbl,"labelInner");
225 0 : get(m_pOutsideLbl,"labelOuter");
226 0 : get(m_pPrintRangeQueryText,"labelMsg");
227 :
228 0 : bBorderModified = sal_False;
229 0 : m_pBspWin->EnableRTL( sal_False );
230 :
231 : // this page needs ExchangeSupport
232 0 : SetExchangeSupport();
233 :
234 0 : SvtLanguageOptions aLangOptions;
235 0 : sal_Bool bCJK = aLangOptions.IsAsianTypographyEnabled();
236 0 : sal_Bool bCTL = aLangOptions.IsCTLFontEnabled();
237 0 : sal_Bool bWeb = sal_False;
238 : const SfxPoolItem* pItem;
239 :
240 : SfxObjectShell* pShell;
241 0 : if(SFX_ITEM_SET == rAttr.GetItemState(SID_HTML_MODE, sal_False, &pItem) ||
242 0 : ( 0 != (pShell = SfxObjectShell::Current()) &&
243 0 : 0 != (pItem = pShell->GetItem(SID_HTML_MODE))))
244 0 : bWeb = 0 != (((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON);
245 :
246 : // fill text flow listbox with valid entries
247 :
248 0 : m_pTextFlowBox->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_PAGEDIR_LTR_HORI ), FRMDIR_HORI_LEFT_TOP );
249 :
250 :
251 0 : if( bCTL )
252 0 : m_pTextFlowBox->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_PAGEDIR_RTL_HORI ), FRMDIR_HORI_RIGHT_TOP );
253 :
254 :
255 : // #109989# do not show vertical directions in Writer/Web
256 0 : if( !bWeb )
257 : {
258 0 : if( bCJK )
259 : {
260 0 : m_pTextFlowBox->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_PAGEDIR_RTL_VERT ), FRMDIR_VERT_TOP_RIGHT );
261 : // m_pTextFlowBox->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_PAGEDIR_LTR_VERT ), FRMDIR_VERT_TOP_LEFT );
262 : }
263 : }
264 :
265 : // #109989# show the text direction box in Writer/Web too
266 0 : if( (bCJK || bCTL) &&
267 0 : SFX_ITEM_UNKNOWN < rAttr.GetItemState(GetWhich( SID_ATTR_FRAMEDIRECTION )))
268 : {
269 0 : m_pTextFlowLbl->Show();
270 0 : m_pTextFlowBox->Show();
271 0 : m_pTextFlowBox->SetSelectHdl(LINK(this, SvxPageDescPage, FrameDirectionModify_Impl ));
272 :
273 0 : m_pBspWin->EnableFrameDirection(sal_True);
274 : }
275 0 : Init_Impl();
276 :
277 0 : FieldUnit eFUnit = GetModuleFieldUnit( rAttr );
278 0 : SetFieldUnit( *m_pLeftMarginEdit, eFUnit );
279 0 : SetFieldUnit( *m_pRightMarginEdit, eFUnit );
280 0 : SetFieldUnit( *m_pTopMarginEdit, eFUnit );
281 0 : SetFieldUnit( *m_pBottomMarginEdit, eFUnit );
282 0 : SetFieldUnit( *m_pPaperWidthEdit, eFUnit );
283 0 : SetFieldUnit( *m_pPaperHeightEdit, eFUnit );
284 :
285 0 : if ( SfxViewShell::Current() && SfxViewShell::Current()->GetPrinter() )
286 0 : pImpl->mpDefPrinter = (Printer*)SfxViewShell::Current()->GetPrinter();
287 : else
288 : {
289 0 : pImpl->mpDefPrinter = new Printer;
290 0 : pImpl->mbDelPrinter = true;
291 : }
292 :
293 0 : MapMode aOldMode = pImpl->mpDefPrinter->GetMapMode();
294 0 : pImpl->mpDefPrinter->SetMapMode( MAP_TWIP );
295 :
296 : // set first- and last-values for the margins
297 0 : Size aPaperSize = pImpl->mpDefPrinter->GetPaperSize();
298 0 : Size aPrintSize = pImpl->mpDefPrinter->GetOutputSize();
299 : /*
300 : * To convert a point ( 0,0 ) into logic coordinates
301 : * looks like nonsense; but it makes sense when the
302 : * coordinate system's origin has been moved.
303 : */
304 0 : Point aPrintOffset = pImpl->mpDefPrinter->GetPageOffset() -
305 0 : pImpl->mpDefPrinter->PixelToLogic( Point() );
306 0 : pImpl->mpDefPrinter->SetMapMode( aOldMode );
307 :
308 0 : long nOffset = !aPrintOffset.X() && !aPrintOffset.Y() ? 0 : PRINT_OFFSET;
309 0 : m_pLeftMarginEdit->SetFirst( m_pLeftMarginEdit->Normalize( aPrintOffset.X() ), FUNIT_TWIP );
310 0 : nFirstLeftMargin = static_cast<long>(m_pLeftMarginEdit->GetFirst());
311 :
312 0 : m_pRightMarginEdit->SetFirst( m_pRightMarginEdit->Normalize( aPaperSize.Width() - aPrintSize.Width() - aPrintOffset.X() + nOffset ), FUNIT_TWIP);
313 0 : nFirstRightMargin = static_cast<long>(m_pRightMarginEdit->GetFirst());
314 :
315 0 : m_pTopMarginEdit->SetFirst( m_pTopMarginEdit->Normalize( aPrintOffset.Y() ), FUNIT_TWIP );
316 0 : nFirstTopMargin = static_cast<long>(m_pTopMarginEdit->GetFirst());
317 :
318 0 : m_pBottomMarginEdit->SetFirst( m_pBottomMarginEdit->Normalize( aPaperSize.Height() - aPrintSize.Height() - aPrintOffset.Y() + nOffset ), FUNIT_TWIP );
319 0 : nFirstBottomMargin = static_cast<long>(m_pBottomMarginEdit->GetFirst());
320 :
321 0 : m_pLeftMarginEdit->SetLast( m_pLeftMarginEdit->Normalize( aPrintOffset.X() + aPrintSize.Width() ), FUNIT_TWIP );
322 0 : nLastLeftMargin = static_cast<long>(m_pLeftMarginEdit->GetLast());
323 :
324 0 : m_pRightMarginEdit->SetLast( m_pRightMarginEdit->Normalize( aPrintOffset.X() + aPrintSize.Width() ), FUNIT_TWIP );
325 0 : nLastRightMargin = static_cast<long>(m_pRightMarginEdit->GetLast());
326 :
327 0 : m_pTopMarginEdit->SetLast( m_pTopMarginEdit->Normalize( aPrintOffset.Y() + aPrintSize.Height() ), FUNIT_TWIP );
328 0 : nLastTopMargin = static_cast<long>(m_pTopMarginEdit->GetLast());
329 :
330 0 : m_pBottomMarginEdit->SetLast( m_pBottomMarginEdit->Normalize( aPrintOffset.Y() + aPrintSize.Height() ), FUNIT_TWIP );
331 0 : nLastBottomMargin = static_cast<long>(m_pBottomMarginEdit->GetLast());
332 :
333 : // #i4219# get DrawingLayer options
334 0 : const SvtOptionsDrawinglayer aDrawinglayerOpt;
335 :
336 : // #i4219# take Maximum now from configuration (1/100th cm)
337 : // was: 11900 -> 119 cm ;new value 3 meters -> 300 cm -> 30000
338 0 : m_pPaperWidthEdit->SetMax(m_pPaperWidthEdit->Normalize(aDrawinglayerOpt.GetMaximumPaperWidth()), FUNIT_CM);
339 0 : m_pPaperWidthEdit->SetLast(m_pPaperWidthEdit->Normalize(aDrawinglayerOpt.GetMaximumPaperWidth()), FUNIT_CM);
340 0 : m_pPaperHeightEdit->SetMax(m_pPaperHeightEdit->Normalize(aDrawinglayerOpt.GetMaximumPaperHeight()), FUNIT_CM);
341 0 : m_pPaperHeightEdit->SetLast(m_pPaperHeightEdit->Normalize(aDrawinglayerOpt.GetMaximumPaperHeight()), FUNIT_CM);
342 :
343 : // #i4219# also for margins (1/100th cm). Was: 9999, keeping.
344 0 : m_pLeftMarginEdit->SetMax(aDrawinglayerOpt.GetMaximumPaperLeftMargin());
345 0 : m_pLeftMarginEdit->SetLast(aDrawinglayerOpt.GetMaximumPaperLeftMargin());
346 0 : m_pRightMarginEdit->SetMax(aDrawinglayerOpt.GetMaximumPaperRightMargin());
347 0 : m_pRightMarginEdit->SetLast(aDrawinglayerOpt.GetMaximumPaperRightMargin());
348 0 : m_pTopMarginEdit->SetMax(aDrawinglayerOpt.GetMaximumPaperTopMargin());
349 0 : m_pTopMarginEdit->SetLast(aDrawinglayerOpt.GetMaximumPaperTopMargin());
350 0 : m_pBottomMarginEdit->SetMax(aDrawinglayerOpt.GetMaximumPaperBottomMargin());
351 0 : m_pBottomMarginEdit->SetLast(aDrawinglayerOpt.GetMaximumPaperBottomMargin());
352 :
353 0 : m_pPortraitBtn->SetAccessibleRelationMemberOf(m_pOrientationFT);
354 0 : m_pLandscapeBtn->SetAccessibleRelationMemberOf(m_pOrientationFT);
355 :
356 : // Get the i18n framework numberings and add them to the listbox.
357 0 : SvxNumOptionsTabPage::GetI18nNumbering( *m_pNumberFormatBox, ::std::numeric_limits<sal_uInt16>::max());
358 0 : }
359 :
360 : // -----------------------------------------------------------------------
361 :
362 0 : SvxPageDescPage::~SvxPageDescPage()
363 : {
364 0 : delete pImpl;
365 0 : }
366 :
367 : // -----------------------------------------------------------------------
368 :
369 0 : void SvxPageDescPage::Init_Impl()
370 : {
371 : // adjust the handler
372 0 : m_pLayoutBox->SetSelectHdl( LINK( this, SvxPageDescPage, LayoutHdl_Impl ) );
373 0 : m_pPaperSizeBox->SetDropDownLineCount(10);
374 :
375 0 : m_pPaperTrayBox->SetGetFocusHdl( LINK( this, SvxPageDescPage, PaperBinHdl_Impl ) );
376 0 : m_pPaperSizeBox->SetSelectHdl( LINK( this, SvxPageDescPage, PaperSizeSelect_Impl ) );
377 0 : m_pPaperWidthEdit->SetModifyHdl( LINK( this, SvxPageDescPage, PaperSizeModify_Impl ) );
378 0 : m_pPaperHeightEdit->SetModifyHdl( LINK( this, SvxPageDescPage, PaperSizeModify_Impl ) );
379 0 : m_pLandscapeBtn->SetClickHdl( LINK( this, SvxPageDescPage, SwapOrientation_Impl ) );
380 0 : m_pPortraitBtn->SetClickHdl( LINK( this, SvxPageDescPage, SwapOrientation_Impl ) );
381 :
382 0 : Link aLink = LINK( this, SvxPageDescPage, BorderModify_Impl );
383 0 : m_pLeftMarginEdit->SetModifyHdl( aLink );
384 0 : m_pRightMarginEdit->SetModifyHdl( aLink );
385 0 : m_pTopMarginEdit->SetModifyHdl( aLink );
386 0 : m_pBottomMarginEdit->SetModifyHdl( aLink );
387 :
388 0 : aLink = LINK( this, SvxPageDescPage, RangeHdl_Impl );
389 0 : m_pPaperWidthEdit->SetLoseFocusHdl( aLink );
390 0 : m_pPaperHeightEdit->SetLoseFocusHdl( aLink );
391 0 : m_pLeftMarginEdit->SetLoseFocusHdl( aLink );
392 0 : m_pRightMarginEdit->SetLoseFocusHdl( aLink );
393 0 : m_pTopMarginEdit->SetLoseFocusHdl( aLink );
394 0 : m_pBottomMarginEdit->SetLoseFocusHdl( aLink );
395 :
396 0 : m_pHorzBox->SetClickHdl( LINK( this, SvxPageDescPage, CenterHdl_Impl ) );
397 0 : m_pVertBox->SetClickHdl( LINK( this, SvxPageDescPage, CenterHdl_Impl ) );
398 :
399 0 : }
400 :
401 : // -----------------------------------------------------------------------
402 :
403 0 : void SvxPageDescPage::Reset( const SfxItemSet& rSet )
404 : {
405 0 : SfxItemPool* pPool = rSet.GetPool();
406 : DBG_ASSERT( pPool, "Wo ist der Pool" );
407 0 : SfxMapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) );
408 :
409 : // adjust margins (right/left)
410 0 : const SfxPoolItem* pItem = GetItem( rSet, SID_ATTR_LRSPACE );
411 :
412 0 : if ( pItem )
413 : {
414 0 : const SvxLRSpaceItem& rLRSpace = (const SvxLRSpaceItem&)*pItem;
415 0 : SetMetricValue( *m_pLeftMarginEdit, rLRSpace.GetLeft(), eUnit );
416 : m_pBspWin->SetLeft(
417 0 : (sal_uInt16)ConvertLong_Impl( (long)rLRSpace.GetLeft(), eUnit ) );
418 0 : SetMetricValue( *m_pRightMarginEdit, rLRSpace.GetRight(), eUnit );
419 : m_pBspWin->SetRight(
420 0 : (sal_uInt16)ConvertLong_Impl( (long)rLRSpace.GetRight(), eUnit ) );
421 : }
422 :
423 : // adjust margins (top/bottom)
424 0 : pItem = GetItem( rSet, SID_ATTR_ULSPACE );
425 :
426 0 : if ( pItem )
427 : {
428 0 : const SvxULSpaceItem& rULSpace = (const SvxULSpaceItem&)*pItem;
429 0 : SetMetricValue( *m_pTopMarginEdit, rULSpace.GetUpper(), eUnit );
430 : m_pBspWin->SetTop(
431 0 : (sal_uInt16)ConvertLong_Impl( (long)rULSpace.GetUpper(), eUnit ) );
432 0 : SetMetricValue( *m_pBottomMarginEdit, rULSpace.GetLower(), eUnit );
433 : m_pBspWin->SetBottom(
434 0 : (sal_uInt16)ConvertLong_Impl( (long)rULSpace.GetLower(), eUnit ) );
435 : }
436 :
437 : // general page data
438 0 : SvxNumType eNumType = SVX_ARABIC;
439 0 : bLandscape = ( pImpl->mpDefPrinter->GetOrientation() == ORIENTATION_LANDSCAPE );
440 0 : sal_uInt16 nUse = (sal_uInt16)SVX_PAGE_ALL;
441 0 : pItem = GetItem( rSet, SID_ATTR_PAGE );
442 :
443 0 : if ( pItem )
444 : {
445 0 : const SvxPageItem& rItem = (const SvxPageItem&)*pItem;
446 0 : eNumType = rItem.GetNumType();
447 0 : nUse = rItem.GetPageUsage();
448 0 : bLandscape = rItem.IsLandscape();
449 : }
450 :
451 : // alignment
452 0 : m_pLayoutBox->SelectEntryPos( ::PageUsageToPos_Impl( nUse ) );
453 0 : m_pBspWin->SetUsage( nUse );
454 0 : LayoutHdl_Impl( 0 );
455 :
456 : //adjust numeration type of the page style
457 : //Get the Position of the saved NumType
458 0 : for(int i=0; i<m_pNumberFormatBox->GetEntryCount(); i++)
459 0 : if(eNumType == (sal_uInt16)(sal_uLong)m_pNumberFormatBox->GetEntryData(i)){
460 0 : m_pNumberFormatBox->SelectEntryPos( i );
461 0 : break;
462 : }
463 :
464 0 : m_pPaperTrayBox->Clear();
465 0 : sal_uInt8 nPaperBin = PAPERBIN_PRINTER_SETTINGS;
466 0 : pItem = GetItem( rSet, SID_ATTR_PAGE_PAPERBIN );
467 :
468 0 : if ( pItem )
469 : {
470 0 : nPaperBin = ( (const SvxPaperBinItem*)pItem )->GetValue();
471 :
472 0 : if ( nPaperBin >= pImpl->mpDefPrinter->GetPaperBinCount() )
473 0 : nPaperBin = PAPERBIN_PRINTER_SETTINGS;
474 : }
475 :
476 0 : String aBinName;
477 :
478 0 : if ( PAPERBIN_PRINTER_SETTINGS == nPaperBin )
479 0 : aBinName = EE_RESSTR( RID_SVXSTR_PAPERBIN_SETTINGS );
480 : else
481 0 : aBinName = pImpl->mpDefPrinter->GetPaperBinName( (sal_uInt16)nPaperBin );
482 :
483 0 : sal_uInt16 nEntryPos = m_pPaperTrayBox->InsertEntry( aBinName );
484 0 : m_pPaperTrayBox->SetEntryData( nEntryPos, (void*)(sal_uLong)nPaperBin );
485 0 : m_pPaperTrayBox->SelectEntry( aBinName );
486 :
487 0 : Size aPaperSize = SvxPaperInfo::GetPaperSize( pImpl->mpDefPrinter );
488 0 : pItem = GetItem( rSet, SID_ATTR_PAGE_SIZE );
489 :
490 0 : if ( pItem )
491 0 : aPaperSize = ( (const SvxSizeItem*)pItem )->GetSize();
492 :
493 : bool bOrientationSupport =
494 0 : pImpl->mpDefPrinter->HasSupport( SUPPORT_SET_ORIENTATION );
495 :
496 0 : if ( !bOrientationSupport &&
497 0 : aPaperSize.Width() > aPaperSize.Height() )
498 0 : bLandscape = sal_True;
499 :
500 0 : m_pLandscapeBtn->Check( bLandscape );
501 0 : m_pPortraitBtn->Check( !bLandscape );
502 :
503 0 : m_pBspWin->SetSize( Size( ConvertLong_Impl( aPaperSize.Width(), eUnit ),
504 0 : ConvertLong_Impl( aPaperSize.Height(), eUnit ) ) );
505 :
506 0 : aPaperSize = OutputDevice::LogicToLogic(aPaperSize, (MapUnit)eUnit, MAP_100TH_MM);
507 0 : if ( bLandscape )
508 0 : Swap( aPaperSize );
509 :
510 : // Actual Paper Format
511 0 : Paper ePaper = SvxPaperInfo::GetSvxPaper( aPaperSize, MAP_100TH_MM, sal_True );
512 :
513 0 : if ( PAPER_USER != ePaper )
514 0 : aPaperSize = SvxPaperInfo::GetPaperSize( ePaper, MAP_100TH_MM );
515 :
516 0 : if ( bLandscape )
517 0 : Swap( aPaperSize );
518 :
519 : // write values into the edits
520 0 : SetMetricValue( *m_pPaperHeightEdit, aPaperSize.Height(), SFX_MAPUNIT_100TH_MM );
521 0 : SetMetricValue( *m_pPaperWidthEdit, aPaperSize.Width(), SFX_MAPUNIT_100TH_MM );
522 0 : m_pPaperSizeBox->Clear();
523 :
524 0 : sal_uInt16 nActPos = LISTBOX_ENTRY_NOTFOUND;
525 0 : sal_uInt16 nAryId = RID_SVXSTRARY_PAPERSIZE_STD;
526 :
527 0 : if ( ePaperStart != PAPER_A3 )
528 0 : nAryId = RID_SVXSTRARY_PAPERSIZE_DRAW;
529 0 : ResStringArray aPaperAry( CUI_RES( nAryId ) );
530 0 : sal_uInt32 nCnt = aPaperAry.Count();
531 :
532 0 : sal_uInt16 nUserPos = LISTBOX_ENTRY_NOTFOUND;
533 0 : for ( sal_uInt32 i = 0; i < nCnt; ++i )
534 : {
535 0 : String aStr = aPaperAry.GetString(i);
536 0 : Paper eSize = (Paper)aPaperAry.GetValue(i);
537 0 : sal_uInt16 nPos = m_pPaperSizeBox->InsertEntry( aStr );
538 0 : m_pPaperSizeBox->SetEntryData( nPos, (void*)(sal_uLong)eSize );
539 :
540 0 : if ( eSize == ePaper )
541 0 : nActPos = nPos;
542 0 : if( eSize == PAPER_USER )
543 0 : nUserPos = nPos;
544 0 : }
545 : // preselect current paper format - #115915#: ePaper might not be in aPaperSizeBox so use PAPER_USER instead
546 0 : m_pPaperSizeBox->SelectEntryPos( nActPos != LISTBOX_ENTRY_NOTFOUND ? nActPos : nUserPos );
547 :
548 : // application specific
549 :
550 0 : switch ( eMode )
551 : {
552 : case SVX_PAGE_MODE_CENTER:
553 : {
554 0 : m_pTblAlignFT->Show();
555 0 : m_pHorzBox->Show();
556 0 : m_pVertBox->Show();
557 0 : DisableVerticalPageDir();
558 :
559 : // horizontal alignment
560 0 : pItem = GetItem( rSet, SID_ATTR_PAGE_EXT1 );
561 0 : m_pHorzBox->Check( pItem ? ( (const SfxBoolItem*)pItem )->GetValue()
562 0 : : sal_False );
563 :
564 : // vertical alignment
565 0 : pItem = GetItem( rSet, SID_ATTR_PAGE_EXT2 );
566 0 : m_pVertBox->Check( pItem ? ( (const SfxBoolItem*)pItem )->GetValue()
567 0 : : sal_False );
568 :
569 : // set example window on the table
570 0 : m_pBspWin->SetTable( sal_True );
571 0 : m_pBspWin->SetHorz( m_pHorzBox->IsChecked() );
572 0 : m_pBspWin->SetVert( m_pVertBox->IsChecked() );
573 :
574 0 : break;
575 : }
576 :
577 : case SVX_PAGE_MODE_PRESENTATION:
578 : {
579 0 : DisableVerticalPageDir();
580 0 : m_pAdaptBox->Show();
581 0 : pItem = GetItem( rSet, SID_ATTR_PAGE_EXT1 );
582 : m_pAdaptBox->Check( pItem ?
583 0 : ( (const SfxBoolItem*)pItem )->GetValue() : sal_False );
584 :
585 : //!!! hidden, because not implemented by StarDraw
586 0 : m_pLayoutBox->Hide();
587 0 : m_pPageText->Hide();
588 :
589 0 : break;
590 : }
591 : default: ;//prevent warning
592 : }
593 :
594 :
595 : // display background and border in the example
596 0 : ResetBackground_Impl( rSet );
597 : //! UpdateExample_Impl();
598 0 : RangeHdl_Impl( 0 );
599 :
600 0 : InitHeadFoot_Impl( rSet );
601 :
602 0 : bBorderModified = sal_False;
603 0 : SwapFirstValues_Impl( sal_False );
604 0 : UpdateExample_Impl();
605 :
606 0 : m_pLeftMarginEdit->SaveValue();
607 0 : m_pRightMarginEdit->SaveValue();
608 0 : m_pTopMarginEdit->SaveValue();
609 0 : m_pBottomMarginEdit->SaveValue();
610 0 : m_pLayoutBox->SaveValue();
611 0 : m_pNumberFormatBox->SaveValue();
612 0 : m_pPaperSizeBox->SaveValue();
613 0 : m_pPaperWidthEdit->SaveValue();
614 0 : m_pPaperHeightEdit->SaveValue();
615 0 : m_pPortraitBtn->SaveValue();
616 0 : m_pLandscapeBtn->SaveValue();
617 0 : m_pPaperTrayBox->SaveValue();
618 0 : m_pVertBox->SaveValue();
619 0 : m_pHorzBox->SaveValue();
620 0 : m_pAdaptBox->SaveValue();
621 :
622 0 : CheckMarginEdits( true );
623 :
624 :
625 0 : if(SFX_ITEM_SET == rSet.GetItemState(SID_SWREGISTER_MODE))
626 : {
627 : m_pRegisterCB->Check(((const SfxBoolItem&)rSet.Get(
628 0 : SID_SWREGISTER_MODE)).GetValue());
629 0 : m_pRegisterCB->SaveValue();
630 0 : RegisterModify(m_pRegisterCB);
631 : }
632 0 : if(SFX_ITEM_SET == rSet.GetItemState(SID_SWREGISTER_COLLECTION))
633 : {
634 : m_pRegisterLB->SelectEntry(
635 0 : ((const SfxStringItem&)rSet.Get(SID_SWREGISTER_COLLECTION)).GetValue());
636 0 : m_pRegisterLB->SaveValue();
637 : }
638 :
639 0 : SfxItemState eState = rSet.GetItemState( GetWhich( SID_ATTR_FRAMEDIRECTION ),
640 0 : sal_True, &pItem );
641 0 : if( SFX_ITEM_UNKNOWN != eState )
642 : {
643 : sal_uInt32 nVal = SFX_ITEM_SET == eState
644 0 : ? ((SvxFrameDirectionItem*)pItem)->GetValue()
645 0 : : 0;
646 0 : m_pTextFlowBox->SelectEntryValue( static_cast< SvxFrameDirection >( nVal ) );
647 :
648 0 : m_pTextFlowBox->SaveValue();
649 0 : m_pBspWin->SetFrameDirection(nVal);
650 0 : }
651 0 : }
652 :
653 : // -----------------------------------------------------------------------
654 :
655 0 : void SvxPageDescPage::FillUserData()
656 : {
657 0 : if ( SVX_PAGE_MODE_PRESENTATION == eMode )
658 0 : SetUserData( m_pAdaptBox->IsChecked() ? OUString("1") : OUString("0") ) ;
659 :
660 0 : }
661 :
662 : // -----------------------------------------------------------------------
663 :
664 0 : sal_Bool SvxPageDescPage::FillItemSet( SfxItemSet& rSet )
665 : {
666 0 : sal_Bool bModified = sal_False;
667 0 : const SfxItemSet& rOldSet = GetItemSet();
668 0 : SfxItemPool* pPool = rOldSet.GetPool();
669 : DBG_ASSERT( pPool, "Wo ist der Pool" );
670 0 : sal_uInt16 nWhich = GetWhich( SID_ATTR_LRSPACE );
671 0 : SfxMapUnit eUnit = pPool->GetMetric( nWhich );
672 0 : const SfxPoolItem* pOld = 0;
673 :
674 : // copy old left and right margins
675 0 : SvxLRSpaceItem aMargin( (const SvxLRSpaceItem&)rOldSet.Get( nWhich ) );
676 :
677 : // copy old top and bottom margins
678 0 : nWhich = GetWhich( SID_ATTR_ULSPACE );
679 0 : SvxULSpaceItem aTopMargin( (const SvxULSpaceItem&)rOldSet.Get( nWhich ) );
680 :
681 0 : if ( m_pLeftMarginEdit->GetText() != m_pLeftMarginEdit->GetSavedValue() )
682 : {
683 0 : aMargin.SetLeft( (sal_uInt16)GetCoreValue( *m_pLeftMarginEdit, eUnit ) );
684 0 : bModified |= sal_True;
685 : }
686 :
687 0 : if ( m_pRightMarginEdit->GetText() != m_pRightMarginEdit->GetSavedValue() )
688 : {
689 0 : aMargin.SetRight( (sal_uInt16)GetCoreValue( *m_pRightMarginEdit, eUnit ) );
690 0 : bModified |= sal_True;
691 : }
692 :
693 : // set left and right margins
694 0 : if ( bModified )
695 : {
696 0 : pOld = GetOldItem( rSet, SID_ATTR_LRSPACE );
697 :
698 0 : if ( !pOld || !( *(const SvxLRSpaceItem*)pOld == aMargin ) )
699 0 : rSet.Put( aMargin );
700 : else
701 0 : bModified = sal_False;
702 : }
703 :
704 0 : sal_Bool bMod = sal_False;
705 :
706 0 : if ( m_pTopMarginEdit->GetText() != m_pTopMarginEdit->GetSavedValue() )
707 : {
708 0 : aTopMargin.SetUpper( (sal_uInt16)GetCoreValue( *m_pTopMarginEdit, eUnit ) );
709 0 : bMod |= sal_True;
710 : }
711 :
712 0 : if ( m_pBottomMarginEdit->GetText() != m_pBottomMarginEdit->GetSavedValue() )
713 : {
714 0 : aTopMargin.SetLower( (sal_uInt16)GetCoreValue( *m_pBottomMarginEdit, eUnit ) );
715 0 : bMod |= sal_True;
716 : }
717 :
718 : // set top and bottom margins
719 : //
720 0 : if ( bMod )
721 : {
722 0 : pOld = GetOldItem( rSet, SID_ATTR_ULSPACE );
723 :
724 0 : if ( !pOld || !( *(const SvxULSpaceItem*)pOld == aTopMargin ) )
725 : {
726 0 : bModified |= sal_True;
727 0 : rSet.Put( aTopMargin );
728 : }
729 : }
730 :
731 : // paper tray
732 0 : nWhich = GetWhich( SID_ATTR_PAGE_PAPERBIN );
733 0 : sal_uInt16 nPos = m_pPaperTrayBox->GetSelectEntryPos();
734 0 : sal_uInt16 nBin = (sal_uInt16)(sal_uLong)m_pPaperTrayBox->GetEntryData( nPos );
735 0 : pOld = GetOldItem( rSet, SID_ATTR_PAGE_PAPERBIN );
736 :
737 0 : if ( !pOld || ( (const SvxPaperBinItem*)pOld )->GetValue() != nBin )
738 : {
739 0 : rSet.Put( SvxPaperBinItem( nWhich, (sal_uInt8)nBin ) );
740 0 : bModified |= sal_True;
741 : }
742 :
743 0 : nPos = m_pPaperSizeBox->GetSelectEntryPos();
744 0 : Paper ePaper = (Paper)(sal_uLong)m_pPaperSizeBox->GetEntryData( nPos );
745 0 : const sal_uInt16 nOld = m_pPaperSizeBox->GetSavedValue();
746 0 : sal_Bool bChecked = m_pLandscapeBtn->IsChecked();
747 :
748 0 : if ( PAPER_USER == ePaper )
749 : {
750 0 : if ( nOld != nPos ||
751 0 : m_pPaperWidthEdit->IsValueModified() ||
752 0 : m_pPaperHeightEdit->IsValueModified() ||
753 0 : bChecked != m_pLandscapeBtn->GetSavedValue() )
754 : {
755 : Size aSize( GetCoreValue( *m_pPaperWidthEdit, eUnit ),
756 0 : GetCoreValue( *m_pPaperHeightEdit, eUnit ) );
757 0 : pOld = GetOldItem( rSet, SID_ATTR_PAGE_SIZE );
758 :
759 0 : if ( !pOld || ( (const SvxSizeItem*)pOld )->GetSize() != aSize )
760 : {
761 0 : rSet.Put( SvxSizeItem( GetWhich(SID_ATTR_PAGE_SIZE), aSize ) );
762 0 : bModified |= sal_True;
763 : }
764 : }
765 : }
766 : else
767 : {
768 0 : if ( nOld != nPos || bChecked != m_pLandscapeBtn->GetSavedValue() )
769 : {
770 0 : Size aSize( SvxPaperInfo::GetPaperSize( ePaper, (MapUnit)eUnit ) );
771 :
772 0 : if ( bChecked )
773 0 : Swap( aSize );
774 :
775 0 : pOld = GetOldItem( rSet, SID_ATTR_PAGE_SIZE );
776 :
777 0 : if ( !pOld || ( (const SvxSizeItem*)pOld )->GetSize() != aSize )
778 : {
779 0 : rSet.Put( SvxSizeItem( GetWhich(SID_ATTR_PAGE_SIZE), aSize ) );
780 0 : bModified |= sal_True;
781 : }
782 : }
783 : }
784 :
785 0 : nWhich = GetWhich( SID_ATTR_PAGE );
786 0 : SvxPageItem aPage( (const SvxPageItem&)rOldSet.Get( nWhich ) );
787 0 : bMod = m_pLayoutBox->GetSelectEntryPos() != m_pLayoutBox->GetSavedValue();
788 :
789 0 : if ( bMod )
790 : aPage.SetPageUsage(
791 0 : ::PosToPageUsage_Impl( m_pLayoutBox->GetSelectEntryPos() ) );
792 :
793 0 : if ( bChecked != m_pLandscapeBtn->GetSavedValue() )
794 : {
795 0 : aPage.SetLandscape(bChecked);
796 0 : bMod |= sal_True;
797 : }
798 :
799 : //Get the NumType value
800 0 : nPos = m_pNumberFormatBox->GetSelectEntryPos();
801 0 : sal_uInt16 nEntryData = (sal_uInt16)(sal_uLong)m_pNumberFormatBox->GetEntryData(nPos);
802 0 : if ( nPos != m_pNumberFormatBox->GetSavedValue() )
803 : {
804 0 : aPage.SetNumType( (SvxNumType)nEntryData );
805 0 : bMod |= sal_True;
806 : }
807 :
808 0 : if ( bMod )
809 : {
810 0 : pOld = GetOldItem( rSet, SID_ATTR_PAGE );
811 :
812 0 : if ( !pOld || !( *(const SvxPageItem*)pOld == aPage ) )
813 : {
814 0 : rSet.Put( aPage );
815 0 : bModified |= sal_True;
816 : }
817 : }
818 0 : else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich ) )
819 0 : rSet.ClearItem( nWhich );
820 : else
821 0 : rSet.Put( rOldSet.Get( nWhich ) );
822 :
823 : // evaluate mode specific controls
824 :
825 0 : switch ( eMode )
826 : {
827 : case SVX_PAGE_MODE_CENTER:
828 : {
829 0 : if ( m_pHorzBox->IsChecked() != m_pHorzBox->GetSavedValue() )
830 : {
831 0 : SfxBoolItem aHorz( GetWhich( SID_ATTR_PAGE_EXT1 ),
832 0 : m_pHorzBox->IsChecked() );
833 0 : rSet.Put( aHorz );
834 0 : bModified |= sal_True;
835 : }
836 :
837 0 : if ( m_pVertBox->IsChecked() != m_pVertBox->GetSavedValue() )
838 : {
839 0 : SfxBoolItem aVert( GetWhich( SID_ATTR_PAGE_EXT2 ),
840 0 : m_pVertBox->IsChecked() );
841 0 : rSet.Put( aVert );
842 0 : bModified |= sal_True;
843 : }
844 0 : break;
845 : }
846 :
847 : case SVX_PAGE_MODE_PRESENTATION:
848 : {
849 : // always put so that draw can evaluate this
850 0 : rSet.Put( SfxBoolItem( GetWhich( SID_ATTR_PAGE_EXT1 ),
851 0 : m_pAdaptBox->IsChecked() ) );
852 0 : bModified |= sal_True;
853 0 : break;
854 : }
855 : default: ;//prevent warning
856 :
857 : }
858 :
859 0 : if(m_pRegisterCB->IsVisible() &&
860 0 : (m_pRegisterCB->IsChecked() || m_pRegisterCB->GetSavedValue() != m_pRegisterCB->IsChecked()))
861 : {
862 0 : const SfxBoolItem& rRegItem = (const SfxBoolItem&)rOldSet.Get(SID_SWREGISTER_MODE);
863 0 : SfxBoolItem* pRegItem = (SfxBoolItem*)rRegItem.Clone();
864 0 : sal_Bool bCheck = m_pRegisterCB->IsChecked();
865 0 : pRegItem->SetValue(bCheck);
866 0 : rSet.Put(*pRegItem);
867 0 : bModified |= sal_True;
868 0 : if(bCheck)
869 : {
870 0 : bModified |= sal_True;
871 : rSet.Put(SfxStringItem(SID_SWREGISTER_COLLECTION,
872 0 : m_pRegisterLB->GetSelectEntry()));
873 : }
874 0 : delete pRegItem;
875 : }
876 :
877 0 : SvxFrameDirection eDirection = m_pTextFlowBox->GetSelectEntryValue();
878 0 : if( m_pTextFlowBox->IsVisible() && (eDirection != m_pTextFlowBox->GetSavedValue()) )
879 : {
880 0 : rSet.Put( SvxFrameDirectionItem( eDirection, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
881 0 : bModified = sal_True;
882 : }
883 :
884 0 : return bModified;
885 : }
886 :
887 : // -----------------------------------------------------------------------
888 :
889 0 : IMPL_LINK_NOARG(SvxPageDescPage, LayoutHdl_Impl)
890 : {
891 : // switch inside outside
892 0 : const sal_uInt16 nPos = PosToPageUsage_Impl( m_pLayoutBox->GetSelectEntryPos() );
893 :
894 0 : if ( nPos == SVX_PAGE_MIRROR )
895 : {
896 0 : m_pLeftMarginLbl->Hide();
897 0 : m_pRightMarginLbl->Hide();
898 0 : m_pInsideLbl->Show();
899 0 : m_pOutsideLbl->Show();
900 : }
901 : else
902 : {
903 0 : m_pLeftMarginLbl->Show();
904 0 : m_pRightMarginLbl->Show();
905 0 : m_pInsideLbl->Hide();
906 0 : m_pOutsideLbl->Hide();
907 : }
908 0 : UpdateExample_Impl( true );
909 0 : return 0;
910 : }
911 :
912 : // -----------------------------------------------------------------------
913 :
914 0 : IMPL_LINK_NOARG(SvxPageDescPage, PaperBinHdl_Impl)
915 : {
916 0 : if ( m_pPaperTrayBox->GetEntryCount() > 1 )
917 : // already filled
918 0 : return 0;
919 :
920 0 : String aOldName = m_pPaperTrayBox->GetSelectEntry();
921 0 : m_pPaperTrayBox->SetUpdateMode( sal_False );
922 0 : m_pPaperTrayBox->Clear();
923 : sal_uInt16 nEntryPos = m_pPaperTrayBox->InsertEntry(
924 0 : EE_RESSTR( RID_SVXSTR_PAPERBIN_SETTINGS ) );
925 : m_pPaperTrayBox->SetEntryData( nEntryPos,
926 0 : (void*)(sal_uLong)PAPERBIN_PRINTER_SETTINGS );
927 0 : String aPaperBin( EditResId( RID_SVXSTR_PAPERBIN ) );
928 0 : sal_uInt16 nBinCount = pImpl->mpDefPrinter->GetPaperBinCount();
929 :
930 0 : for ( sal_uInt16 i = 0; i < nBinCount; ++i )
931 : {
932 0 : String aName = pImpl->mpDefPrinter->GetPaperBinName(i);
933 :
934 0 : if ( !aName.Len() )
935 : {
936 0 : aName = aPaperBin;
937 0 : aName.Append( sal_Unicode(' ') );
938 0 : aName.Append( OUString::valueOf( static_cast<sal_Int32>(i+1) ) );
939 : }
940 0 : nEntryPos = m_pPaperTrayBox->InsertEntry( aName );
941 0 : m_pPaperTrayBox->SetEntryData( nEntryPos, (void*)(sal_uLong)i );
942 0 : }
943 0 : m_pPaperTrayBox->SelectEntry( aOldName );
944 0 : m_pPaperTrayBox->SetUpdateMode( sal_True );
945 :
946 0 : return 0;
947 : }
948 :
949 : // -----------------------------------------------------------------------
950 :
951 0 : IMPL_LINK( SvxPageDescPage, PaperSizeSelect_Impl, ListBox *, pBox )
952 : {
953 0 : const sal_uInt16 nPos = pBox->GetSelectEntryPos();
954 0 : Paper ePaper = (Paper)(sal_uLong)m_pPaperSizeBox->GetEntryData( nPos );
955 :
956 0 : if ( ePaper != PAPER_USER )
957 : {
958 0 : Size aSize( SvxPaperInfo::GetPaperSize( ePaper, MAP_100TH_MM ) );
959 :
960 0 : if ( m_pLandscapeBtn->IsChecked() )
961 0 : Swap( aSize );
962 :
963 0 : if ( aSize.Height() < m_pPaperHeightEdit->GetMin( FUNIT_100TH_MM ) )
964 : m_pPaperHeightEdit->SetMin(
965 0 : m_pPaperHeightEdit->Normalize( aSize.Height() ), FUNIT_100TH_MM );
966 0 : if ( aSize.Width() < m_pPaperWidthEdit->GetMin( FUNIT_100TH_MM ) )
967 : m_pPaperWidthEdit->SetMin(
968 0 : m_pPaperWidthEdit->Normalize( aSize.Width() ), FUNIT_100TH_MM );
969 0 : SetMetricValue( *m_pPaperHeightEdit, aSize.Height(), SFX_MAPUNIT_100TH_MM );
970 0 : SetMetricValue( *m_pPaperWidthEdit, aSize.Width(), SFX_MAPUNIT_100TH_MM );
971 :
972 0 : CalcMargin_Impl();
973 :
974 0 : RangeHdl_Impl( 0 );
975 0 : UpdateExample_Impl( true );
976 :
977 0 : if ( eMode == SVX_PAGE_MODE_PRESENTATION )
978 : {
979 : // Draw: if paper format the margin shall be 1 cm
980 0 : long nTmp = 0;
981 0 : sal_Bool bScreen = (( PAPER_SCREEN_4_3 == ePaper )||( PAPER_SCREEN_16_9 == ePaper)||( PAPER_SCREEN_16_10 == ePaper));
982 :
983 0 : if ( !bScreen )
984 : // no margin if screen
985 0 : nTmp = 1; // accordingly 1 cm
986 :
987 0 : if ( bScreen || m_pRightMarginEdit->GetValue() == 0 )
988 : {
989 0 : SetMetricValue( *m_pRightMarginEdit, nTmp, SFX_MAPUNIT_CM );
990 0 : if ( !bScreen &&
991 0 : m_pRightMarginEdit->GetFirst() > m_pRightMarginEdit->GetValue() )
992 0 : m_pRightMarginEdit->SetValue( m_pRightMarginEdit->GetFirst() );
993 : }
994 0 : if ( bScreen || m_pLeftMarginEdit->GetValue() == 0 )
995 : {
996 0 : SetMetricValue( *m_pLeftMarginEdit, nTmp, SFX_MAPUNIT_CM );
997 0 : if ( !bScreen &&
998 0 : m_pLeftMarginEdit->GetFirst() > m_pLeftMarginEdit->GetValue() )
999 0 : m_pLeftMarginEdit->SetValue( m_pLeftMarginEdit->GetFirst() );
1000 : }
1001 0 : if ( bScreen || m_pBottomMarginEdit->GetValue() == 0 )
1002 : {
1003 0 : SetMetricValue( *m_pBottomMarginEdit, nTmp, SFX_MAPUNIT_CM );
1004 0 : if ( !bScreen &&
1005 0 : m_pBottomMarginEdit->GetFirst() > m_pBottomMarginEdit->GetValue() )
1006 0 : m_pBottomMarginEdit->SetValue( m_pBottomMarginEdit->GetFirst() );
1007 : }
1008 0 : if ( bScreen || m_pTopMarginEdit->GetValue() == 0 )
1009 : {
1010 0 : SetMetricValue( *m_pTopMarginEdit, nTmp, SFX_MAPUNIT_CM );
1011 0 : if ( !bScreen &&
1012 0 : m_pTopMarginEdit->GetFirst() > m_pTopMarginEdit->GetValue() )
1013 0 : m_pTopMarginEdit->SetValue( m_pTopMarginEdit->GetFirst() );
1014 : }
1015 0 : UpdateExample_Impl( true );
1016 : }
1017 : }
1018 0 : return 0;
1019 : }
1020 :
1021 : // -----------------------------------------------------------------------
1022 :
1023 0 : IMPL_LINK_NOARG(SvxPageDescPage, PaperSizeModify_Impl)
1024 : {
1025 0 : sal_uInt16 nWhich = GetWhich( SID_ATTR_LRSPACE );
1026 0 : SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( nWhich );
1027 : Size aSize( GetCoreValue( *m_pPaperWidthEdit, eUnit ),
1028 0 : GetCoreValue( *m_pPaperHeightEdit, eUnit ) );
1029 0 : Paper ePaper = SvxPaperInfo::GetSvxPaper( aSize, (MapUnit)eUnit, sal_True );
1030 0 : sal_uInt16 nEntryCount = m_pPaperSizeBox->GetEntryCount();
1031 :
1032 0 : for ( sal_uInt16 i = 0; i < nEntryCount; ++i )
1033 : {
1034 0 : Paper eTmp = (Paper)(sal_uLong)m_pPaperSizeBox->GetEntryData(i);
1035 :
1036 0 : if ( eTmp == ePaper )
1037 : {
1038 0 : m_pPaperSizeBox->SelectEntryPos(i);
1039 0 : break;
1040 : }
1041 : }
1042 0 : UpdateExample_Impl( true );
1043 0 : return 0;
1044 : }
1045 :
1046 : // -----------------------------------------------------------------------
1047 :
1048 0 : IMPL_LINK( SvxPageDescPage, SwapOrientation_Impl, RadioButton *, pBtn )
1049 : {
1050 0 : if (
1051 0 : (!bLandscape && pBtn == m_pLandscapeBtn) ||
1052 0 : (bLandscape && pBtn == m_pPortraitBtn)
1053 : )
1054 : {
1055 0 : bLandscape = m_pLandscapeBtn->IsChecked();
1056 :
1057 0 : const long lWidth = GetCoreValue( *m_pPaperWidthEdit, SFX_MAPUNIT_100TH_MM );
1058 0 : const long lHeight = GetCoreValue( *m_pPaperHeightEdit, SFX_MAPUNIT_100TH_MM );
1059 :
1060 : // swap with and height
1061 0 : SetMetricValue( *m_pPaperWidthEdit, lHeight, SFX_MAPUNIT_100TH_MM );
1062 0 : SetMetricValue( *m_pPaperHeightEdit, lWidth, SFX_MAPUNIT_100TH_MM );
1063 :
1064 : // recalculate margins if necessary
1065 0 : CalcMargin_Impl();
1066 :
1067 0 : PaperSizeSelect_Impl( m_pPaperSizeBox );
1068 0 : RangeHdl_Impl( 0 );
1069 0 : SwapFirstValues_Impl( bBorderModified );
1070 0 : UpdateExample_Impl( true );
1071 : }
1072 0 : return 0;
1073 : }
1074 :
1075 : // -----------------------------------------------------------------------
1076 :
1077 0 : void SvxPageDescPage::SwapFirstValues_Impl( bool bSet )
1078 : {
1079 0 : MapMode aOldMode = pImpl->mpDefPrinter->GetMapMode();
1080 0 : Orientation eOri = ORIENTATION_PORTRAIT;
1081 :
1082 0 : if ( bLandscape )
1083 0 : eOri = ORIENTATION_LANDSCAPE;
1084 0 : Orientation eOldOri = pImpl->mpDefPrinter->GetOrientation();
1085 0 : pImpl->mpDefPrinter->SetOrientation( eOri );
1086 0 : pImpl->mpDefPrinter->SetMapMode( MAP_TWIP );
1087 :
1088 : // set first- and last-values for margins
1089 0 : Size aPaperSize = pImpl->mpDefPrinter->GetPaperSize();
1090 0 : Size aPrintSize = pImpl->mpDefPrinter->GetOutputSize();
1091 : /*
1092 : * To convert a point ( 0,0 ) into logic coordinates
1093 : * looks like nonsense; but it makes sense if the
1094 : * coordinate system's origin has been moved.
1095 : */
1096 0 : Point aPrintOffset = pImpl->mpDefPrinter->GetPageOffset() -
1097 0 : pImpl->mpDefPrinter->PixelToLogic( Point() );
1098 0 : pImpl->mpDefPrinter->SetMapMode( aOldMode );
1099 0 : pImpl->mpDefPrinter->SetOrientation( eOldOri );
1100 :
1101 : sal_Int64 nSetL = m_pLeftMarginEdit->Denormalize(
1102 0 : m_pLeftMarginEdit->GetValue( FUNIT_TWIP ) );
1103 : sal_Int64 nSetR = m_pRightMarginEdit->Denormalize(
1104 0 : m_pRightMarginEdit->GetValue( FUNIT_TWIP ) );
1105 : sal_Int64 nSetT = m_pTopMarginEdit->Denormalize(
1106 0 : m_pTopMarginEdit->GetValue( FUNIT_TWIP ) );
1107 : sal_Int64 nSetB = m_pBottomMarginEdit->Denormalize(
1108 0 : m_pBottomMarginEdit->GetValue( FUNIT_TWIP ) );
1109 :
1110 0 : long nOffset = !aPrintOffset.X() && !aPrintOffset.Y() ? 0 : PRINT_OFFSET;
1111 0 : long nNewL = aPrintOffset.X();
1112 : long nNewR =
1113 0 : aPaperSize.Width() - aPrintSize.Width() - aPrintOffset.X() + nOffset;
1114 0 : long nNewT = aPrintOffset.Y();
1115 : long nNewB =
1116 0 : aPaperSize.Height() - aPrintSize.Height() - aPrintOffset.Y() + nOffset;
1117 :
1118 0 : m_pLeftMarginEdit->SetFirst( m_pLeftMarginEdit->Normalize( nNewL ), FUNIT_TWIP );
1119 0 : nFirstLeftMargin = static_cast<long>(m_pLeftMarginEdit->GetFirst());
1120 0 : m_pRightMarginEdit->SetFirst( m_pRightMarginEdit->Normalize( nNewR ), FUNIT_TWIP );
1121 0 : nFirstRightMargin = static_cast<long>(m_pRightMarginEdit->GetFirst());
1122 0 : m_pTopMarginEdit->SetFirst( m_pTopMarginEdit->Normalize( nNewT ), FUNIT_TWIP );
1123 0 : nFirstTopMargin = static_cast<long>(m_pTopMarginEdit->GetFirst());
1124 0 : m_pBottomMarginEdit->SetFirst( m_pBottomMarginEdit->Normalize( nNewB ), FUNIT_TWIP );
1125 0 : nFirstBottomMargin = static_cast<long>(m_pBottomMarginEdit->GetFirst());
1126 :
1127 0 : if ( bSet )
1128 : {
1129 0 : if ( nSetL < nNewL )
1130 : m_pLeftMarginEdit->SetValue( m_pLeftMarginEdit->Normalize( nNewL ),
1131 0 : FUNIT_TWIP );
1132 0 : if ( nSetR < nNewR )
1133 : m_pRightMarginEdit->SetValue( m_pRightMarginEdit->Normalize( nNewR ),
1134 0 : FUNIT_TWIP );
1135 0 : if ( nSetT < nNewT )
1136 : m_pTopMarginEdit->SetValue( m_pTopMarginEdit->Normalize( nNewT ),
1137 0 : FUNIT_TWIP );
1138 0 : if ( nSetB < nNewB )
1139 : m_pBottomMarginEdit->SetValue( m_pBottomMarginEdit->Normalize( nNewB ),
1140 0 : FUNIT_TWIP );
1141 0 : }
1142 0 : }
1143 :
1144 : // -----------------------------------------------------------------------
1145 :
1146 0 : IMPL_LINK_NOARG_INLINE_START(SvxPageDescPage, BorderModify_Impl)
1147 : {
1148 0 : if ( !bBorderModified )
1149 0 : bBorderModified = sal_True;
1150 0 : UpdateExample_Impl();
1151 0 : return 0;
1152 : }
1153 0 : IMPL_LINK_NOARG_INLINE_END(SvxPageDescPage, BorderModify_Impl)
1154 :
1155 : // -----------------------------------------------------------------------
1156 :
1157 0 : void SvxPageDescPage::UpdateExample_Impl( bool bResetbackground )
1158 : {
1159 : // Size
1160 : Size aSize( GetCoreValue( *m_pPaperWidthEdit, SFX_MAPUNIT_TWIP ),
1161 0 : GetCoreValue( *m_pPaperHeightEdit, SFX_MAPUNIT_TWIP ) );
1162 :
1163 0 : m_pBspWin->SetSize( aSize );
1164 :
1165 : // Margins
1166 0 : m_pBspWin->SetTop( GetCoreValue( *m_pTopMarginEdit, SFX_MAPUNIT_TWIP ) );
1167 0 : m_pBspWin->SetBottom( GetCoreValue( *m_pBottomMarginEdit, SFX_MAPUNIT_TWIP ) );
1168 0 : m_pBspWin->SetLeft( GetCoreValue( *m_pLeftMarginEdit, SFX_MAPUNIT_TWIP ) );
1169 0 : m_pBspWin->SetRight( GetCoreValue( *m_pRightMarginEdit, SFX_MAPUNIT_TWIP ) );
1170 :
1171 : // Layout
1172 0 : m_pBspWin->SetUsage( PosToPageUsage_Impl( m_pLayoutBox->GetSelectEntryPos() ) );
1173 0 : if ( bResetbackground )
1174 0 : m_pBspWin->ResetBackground();
1175 0 : m_pBspWin->Invalidate();
1176 0 : }
1177 :
1178 : // -----------------------------------------------------------------------
1179 :
1180 0 : void SvxPageDescPage::ResetBackground_Impl( const SfxItemSet& rSet )
1181 : {
1182 0 : sal_uInt16 nWhich = GetWhich( SID_ATTR_PAGE_HEADERSET );
1183 :
1184 0 : if ( rSet.GetItemState( nWhich, sal_False ) == SFX_ITEM_SET )
1185 : {
1186 : const SvxSetItem& rSetItem =
1187 0 : (const SvxSetItem&)rSet.Get( nWhich, sal_False );
1188 0 : const SfxItemSet& rTmpSet = rSetItem.GetItemSet();
1189 : const SfxBoolItem& rOn =
1190 0 : (const SfxBoolItem&)rTmpSet.Get( GetWhich( SID_ATTR_PAGE_ON ) );
1191 :
1192 0 : if ( rOn.GetValue() )
1193 : {
1194 0 : nWhich = GetWhich( SID_ATTR_BRUSH );
1195 :
1196 0 : if ( rTmpSet.GetItemState( nWhich ) == SFX_ITEM_SET )
1197 : {
1198 : const SvxBrushItem& rItem =
1199 0 : (const SvxBrushItem&)rTmpSet.Get( nWhich );
1200 0 : m_pBspWin->SetHdColor( rItem.GetColor() );
1201 : }
1202 0 : nWhich = GetWhich( SID_ATTR_BORDER_OUTER );
1203 :
1204 0 : if ( rTmpSet.GetItemState( nWhich ) == SFX_ITEM_SET )
1205 : {
1206 : const SvxBoxItem& rItem =
1207 0 : (const SvxBoxItem&)rTmpSet.Get( nWhich );
1208 0 : m_pBspWin->SetHdBorder( rItem );
1209 : }
1210 : }
1211 : }
1212 :
1213 0 : nWhich = GetWhich( SID_ATTR_PAGE_FOOTERSET );
1214 :
1215 0 : if ( rSet.GetItemState( nWhich, sal_False ) == SFX_ITEM_SET )
1216 : {
1217 : const SvxSetItem& rSetItem =
1218 0 : (const SvxSetItem&)rSet.Get( nWhich, sal_False );
1219 0 : const SfxItemSet& rTmpSet = rSetItem.GetItemSet();
1220 : const SfxBoolItem& rOn =
1221 0 : (const SfxBoolItem&)rTmpSet.Get( GetWhich( SID_ATTR_PAGE_ON ) );
1222 :
1223 0 : if ( rOn.GetValue() )
1224 : {
1225 0 : nWhich = GetWhich( SID_ATTR_BRUSH );
1226 :
1227 0 : if ( rTmpSet.GetItemState( nWhich ) == SFX_ITEM_SET )
1228 : {
1229 : const SvxBrushItem& rItem =
1230 0 : (const SvxBrushItem&)rTmpSet.Get( nWhich );
1231 0 : m_pBspWin->SetFtColor( rItem.GetColor() );
1232 : }
1233 0 : nWhich = GetWhich( SID_ATTR_BORDER_OUTER );
1234 :
1235 0 : if ( rTmpSet.GetItemState( nWhich ) == SFX_ITEM_SET )
1236 : {
1237 : const SvxBoxItem& rItem =
1238 0 : (const SvxBoxItem&)rTmpSet.Get( nWhich );
1239 0 : m_pBspWin->SetFtBorder( rItem );
1240 : }
1241 : }
1242 : }
1243 :
1244 0 : const SfxPoolItem* pItem = GetItem( rSet, SID_ATTR_BRUSH );
1245 :
1246 0 : if ( pItem )
1247 : {
1248 0 : m_pBspWin->SetColor( ( (const SvxBrushItem*)pItem )->GetColor() );
1249 0 : const Graphic* pGrf = ( (const SvxBrushItem*)pItem )->GetGraphic();
1250 :
1251 0 : if ( pGrf )
1252 : {
1253 0 : Bitmap aBitmap = pGrf->GetBitmap();
1254 0 : m_pBspWin->SetBitmap( &aBitmap );
1255 : }
1256 : else
1257 0 : m_pBspWin->SetBitmap( NULL );
1258 : }
1259 :
1260 0 : pItem = GetItem( rSet, SID_ATTR_BORDER_OUTER );
1261 :
1262 0 : if ( pItem )
1263 0 : m_pBspWin->SetBorder( (SvxBoxItem&)*pItem );
1264 0 : }
1265 :
1266 : // -----------------------------------------------------------------------
1267 :
1268 0 : void SvxPageDescPage::InitHeadFoot_Impl( const SfxItemSet& rSet )
1269 : {
1270 0 : bLandscape = m_pLandscapeBtn->IsChecked();
1271 0 : const SfxPoolItem* pItem = GetItem( rSet, SID_ATTR_PAGE_SIZE );
1272 :
1273 0 : if ( pItem )
1274 0 : m_pBspWin->SetSize( ( (const SvxSizeItem*)pItem )->GetSize() );
1275 :
1276 0 : const SvxSetItem* pSetItem = 0;
1277 :
1278 : // evaluate header attributes
1279 :
1280 0 : if ( SFX_ITEM_SET ==
1281 0 : rSet.GetItemState( GetWhich( SID_ATTR_PAGE_HEADERSET ),
1282 0 : sal_False, (const SfxPoolItem**)&pSetItem ) )
1283 : {
1284 0 : const SfxItemSet& rHeaderSet = pSetItem->GetItemSet();
1285 : const SfxBoolItem& rHeaderOn =
1286 0 : (const SfxBoolItem&)rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_ON ) );
1287 :
1288 0 : if ( rHeaderOn.GetValue() )
1289 : {
1290 : const SvxSizeItem& rSize = (const SvxSizeItem&)
1291 0 : rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) );
1292 : const SvxULSpaceItem& rUL = (const SvxULSpaceItem&)
1293 0 : rHeaderSet.Get( GetWhich( SID_ATTR_ULSPACE ) );
1294 0 : long nDist = rUL.GetLower();
1295 0 : m_pBspWin->SetHdHeight( rSize.GetSize().Height() - nDist );
1296 0 : m_pBspWin->SetHdDist( nDist );
1297 : const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)
1298 0 : rHeaderSet.Get( GetWhich( SID_ATTR_LRSPACE ) );
1299 0 : m_pBspWin->SetHdLeft( rLR.GetLeft() );
1300 0 : m_pBspWin->SetHdRight( rLR.GetRight() );
1301 0 : m_pBspWin->SetHeader( sal_True );
1302 : }
1303 : else
1304 0 : m_pBspWin->SetHeader( sal_False );
1305 :
1306 : // show background and border in the example
1307 0 : sal_uInt16 nWhich = GetWhich( SID_ATTR_BRUSH );
1308 :
1309 0 : if ( rHeaderSet.GetItemState( nWhich ) >= SFX_ITEM_AVAILABLE )
1310 : {
1311 : const SvxBrushItem& rItem =
1312 0 : (const SvxBrushItem&)rHeaderSet.Get( nWhich );
1313 0 : m_pBspWin->SetHdColor( rItem.GetColor() );
1314 : }
1315 0 : nWhich = GetWhich( SID_ATTR_BORDER_OUTER );
1316 :
1317 0 : if ( rHeaderSet.GetItemState( nWhich ) >= SFX_ITEM_AVAILABLE )
1318 : {
1319 : const SvxBoxItem& rItem =
1320 0 : (const SvxBoxItem&)rHeaderSet.Get( nWhich );
1321 0 : m_pBspWin->SetHdBorder( rItem );
1322 : }
1323 : }
1324 :
1325 : // evaluate footer attributes
1326 :
1327 0 : if ( SFX_ITEM_SET ==
1328 0 : rSet.GetItemState( GetWhich( SID_ATTR_PAGE_FOOTERSET ),
1329 0 : sal_False, (const SfxPoolItem**)&pSetItem ) )
1330 : {
1331 0 : const SfxItemSet& rFooterSet = pSetItem->GetItemSet();
1332 : const SfxBoolItem& rFooterOn =
1333 0 : (const SfxBoolItem&)rFooterSet.Get( GetWhich( SID_ATTR_PAGE_ON ) );
1334 :
1335 0 : if ( rFooterOn.GetValue() )
1336 : {
1337 : const SvxSizeItem& rSize = (const SvxSizeItem&)
1338 0 : rFooterSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) );
1339 : const SvxULSpaceItem& rUL = (const SvxULSpaceItem&)
1340 0 : rFooterSet.Get( GetWhich( SID_ATTR_ULSPACE ) );
1341 0 : long nDist = rUL.GetUpper();
1342 0 : m_pBspWin->SetFtHeight( rSize.GetSize().Height() - nDist );
1343 0 : m_pBspWin->SetFtDist( nDist );
1344 : const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)
1345 0 : rFooterSet.Get( GetWhich( SID_ATTR_LRSPACE ) );
1346 0 : m_pBspWin->SetFtLeft( rLR.GetLeft() );
1347 0 : m_pBspWin->SetFtRight( rLR.GetRight() );
1348 0 : m_pBspWin->SetFooter( sal_True );
1349 : }
1350 : else
1351 0 : m_pBspWin->SetFooter( sal_False );
1352 :
1353 : // show background and border in the example
1354 0 : sal_uInt16 nWhich = GetWhich( SID_ATTR_BRUSH );
1355 :
1356 0 : if ( rFooterSet.GetItemState( nWhich ) >= SFX_ITEM_AVAILABLE )
1357 : {
1358 : const SvxBrushItem& rItem =
1359 0 : (const SvxBrushItem&)rFooterSet.Get( nWhich );
1360 0 : m_pBspWin->SetFtColor( rItem.GetColor() );
1361 : }
1362 0 : nWhich = GetWhich( SID_ATTR_BORDER_OUTER );
1363 :
1364 0 : if ( rFooterSet.GetItemState( nWhich ) >= SFX_ITEM_AVAILABLE )
1365 : {
1366 : const SvxBoxItem& rItem =
1367 0 : (const SvxBoxItem&)rFooterSet.Get( nWhich );
1368 0 : m_pBspWin->SetFtBorder( rItem );
1369 : }
1370 : }
1371 0 : }
1372 :
1373 : // -----------------------------------------------------------------------
1374 :
1375 0 : void SvxPageDescPage::ActivatePage( const SfxItemSet& rSet )
1376 : {
1377 0 : InitHeadFoot_Impl( rSet );
1378 0 : ResetBackground_Impl( rSet );
1379 0 : RangeHdl_Impl( 0 );
1380 0 : }
1381 :
1382 : // -----------------------------------------------------------------------
1383 :
1384 0 : int SvxPageDescPage::DeactivatePage( SfxItemSet* _pSet )
1385 : {
1386 : // Inquiry whether the page margins are beyond the printing area.
1387 : // If not, ask user whether they shall be taken.
1388 : // If not, stay on the TabPage.
1389 0 : sal_uInt16 nPos = m_pPaperSizeBox->GetSelectEntryPos();
1390 0 : Paper ePaper = (Paper)(sal_uLong)m_pPaperSizeBox->GetEntryData( nPos );
1391 :
1392 0 : if ( ePaper != PAPER_SCREEN_4_3 && ePaper != PAPER_SCREEN_16_9 && ePaper != PAPER_SCREEN_16_10 && IsMarginOutOfRange() )
1393 : {
1394 0 : if ( QueryBox( this, WB_YES_NO | WB_DEF_NO, m_pPrintRangeQueryText->GetText() ).Execute() == RET_NO )
1395 : {
1396 0 : MetricField* pField = NULL;
1397 0 : if ( IsPrinterRangeOverflow( *m_pLeftMarginEdit, nFirstLeftMargin, nLastLeftMargin, MARGIN_LEFT ) )
1398 0 : pField = m_pLeftMarginEdit;
1399 0 : if ( IsPrinterRangeOverflow( *m_pRightMarginEdit, nFirstRightMargin, nLastRightMargin, MARGIN_RIGHT )
1400 0 : && !pField )
1401 0 : pField = m_pRightMarginEdit;
1402 0 : if ( IsPrinterRangeOverflow( *m_pTopMarginEdit, nFirstTopMargin, nLastTopMargin, MARGIN_TOP )
1403 0 : && !pField )
1404 0 : pField = m_pTopMarginEdit;
1405 0 : if ( IsPrinterRangeOverflow( *m_pBottomMarginEdit, nFirstBottomMargin, nLastBottomMargin, MARGIN_BOTTOM )
1406 0 : && !pField )
1407 0 : pField = m_pBottomMarginEdit;
1408 0 : if ( pField )
1409 0 : pField->GrabFocus();
1410 0 : UpdateExample_Impl();
1411 0 : return KEEP_PAGE;
1412 : }
1413 : else
1414 0 : CheckMarginEdits( false );
1415 : }
1416 :
1417 0 : if ( _pSet )
1418 : {
1419 0 : FillItemSet( *_pSet );
1420 :
1421 : // put portray/landscape if applicable
1422 0 : sal_uInt16 nWh = GetWhich( SID_ATTR_PAGE_SIZE );
1423 0 : SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( nWh );
1424 : Size aSize( GetCoreValue( *m_pPaperWidthEdit, eUnit ),
1425 0 : GetCoreValue( *m_pPaperHeightEdit, eUnit ) );
1426 :
1427 : // put, if current size is different to the value in _pSet
1428 0 : const SvxSizeItem* pSize = (const SvxSizeItem*)GetItem( *_pSet, SID_ATTR_PAGE_SIZE );
1429 0 : if ( aSize.Width() && ( !pSize || !IsEqualSize_Impl( pSize, aSize ) ) )
1430 0 : _pSet->Put( SvxSizeItem( nWh, aSize ) );
1431 : }
1432 :
1433 0 : return LEAVE_PAGE;
1434 : }
1435 :
1436 : // -----------------------------------------------------------------------
1437 :
1438 0 : IMPL_LINK_NOARG(SvxPageDescPage, RangeHdl_Impl)
1439 : {
1440 : // example window
1441 0 : long nHHeight = m_pBspWin->GetHdHeight();
1442 0 : long nHDist = m_pBspWin->GetHdDist();
1443 :
1444 0 : long nFHeight = m_pBspWin->GetFtHeight();
1445 0 : long nFDist = m_pBspWin->GetFtDist();
1446 :
1447 0 : long nHFLeft = std::max( m_pBspWin->GetHdLeft(), m_pBspWin->GetFtLeft() );
1448 0 : long nHFRight = std::max( m_pBspWin->GetHdRight(), m_pBspWin->GetFtRight() );
1449 :
1450 : // current values for page margins
1451 0 : long nBT = static_cast<long>(m_pTopMarginEdit->Denormalize(m_pTopMarginEdit->GetValue(FUNIT_TWIP)));
1452 0 : long nBB = static_cast<long>(m_pBottomMarginEdit->Denormalize(m_pBottomMarginEdit->GetValue(FUNIT_TWIP)));
1453 0 : long nBL = static_cast<long>(m_pLeftMarginEdit->Denormalize(m_pLeftMarginEdit->GetValue(FUNIT_TWIP)));
1454 0 : long nBR = static_cast<long>(m_pRightMarginEdit->Denormalize(m_pRightMarginEdit->GetValue(FUNIT_TWIP)));
1455 :
1456 : // calculate width of page border
1457 0 : const SfxItemSet* _pSet = &GetItemSet();
1458 0 : Size aBorder;
1459 :
1460 0 : if ( _pSet->GetItemState( GetWhich(SID_ATTR_BORDER_SHADOW) ) >=
1461 0 : SFX_ITEM_AVAILABLE &&
1462 0 : _pSet->GetItemState( GetWhich(SID_ATTR_BORDER_OUTER) ) >=
1463 : SFX_ITEM_AVAILABLE )
1464 : {
1465 : aBorder = ( GetMinBorderSpace_Impl(
1466 0 : (const SvxShadowItem&)_pSet->Get(GetWhich(SID_ATTR_BORDER_SHADOW)),
1467 0 : (const SvxBoxItem&)_pSet->Get(GetWhich(SID_ATTR_BORDER_OUTER))));
1468 : }
1469 :
1470 0 : long nH = static_cast<long>(m_pPaperHeightEdit->Denormalize(m_pPaperHeightEdit->GetValue(FUNIT_TWIP)));
1471 0 : long nW = static_cast<long>(m_pPaperWidthEdit->Denormalize(m_pPaperWidthEdit->GetValue(FUNIT_TWIP)));
1472 :
1473 : // limits paper
1474 : // maximum is 54 cm
1475 : //
1476 0 : long nMin = nHHeight + nHDist + nFDist + nFHeight + nBT + nBB +
1477 0 : MINBODY + aBorder.Height();
1478 0 : m_pPaperHeightEdit->SetMin(m_pPaperHeightEdit->Normalize(nMin), FUNIT_TWIP);
1479 :
1480 0 : nMin = MINBODY + nBL + nBR + aBorder.Width();
1481 0 : m_pPaperWidthEdit->SetMin(m_pPaperWidthEdit->Normalize(nMin), FUNIT_TWIP);
1482 :
1483 : // if the paper size has been changed
1484 0 : nH = static_cast<long>(m_pPaperHeightEdit->Denormalize(m_pPaperHeightEdit->GetValue(FUNIT_TWIP)));
1485 0 : nW = static_cast<long>(m_pPaperWidthEdit->Denormalize(m_pPaperWidthEdit->GetValue(FUNIT_TWIP)));
1486 :
1487 : // Top
1488 0 : long nMax = nH - nBB - aBorder.Height() - MINBODY -
1489 0 : nFDist - nFHeight - nHDist - nHHeight;
1490 :
1491 0 : m_pTopMarginEdit->SetMax(m_pTopMarginEdit->Normalize(nMax), FUNIT_TWIP);
1492 :
1493 : // Bottom
1494 0 : nMax = nH - nBT - aBorder.Height() - MINBODY -
1495 0 : nFDist - nFHeight - nHDist - nHHeight;
1496 :
1497 0 : m_pBottomMarginEdit->SetMax(m_pTopMarginEdit->Normalize(nMax), FUNIT_TWIP);
1498 :
1499 : // Left
1500 0 : nMax = nW - nBR - MINBODY - aBorder.Width() - nHFLeft - nHFRight;
1501 0 : m_pLeftMarginEdit->SetMax(m_pLeftMarginEdit->Normalize(nMax), FUNIT_TWIP);
1502 :
1503 : // Right
1504 0 : nMax = nW - nBL - MINBODY - aBorder.Width() - nHFLeft - nHFRight;
1505 0 : m_pRightMarginEdit->SetMax(m_pRightMarginEdit->Normalize(nMax), FUNIT_TWIP);
1506 0 : return 0;
1507 : }
1508 :
1509 : // -----------------------------------------------------------------------
1510 :
1511 0 : void SvxPageDescPage::CalcMargin_Impl()
1512 : {
1513 : // current values for page margins
1514 0 : long nBT = GetCoreValue( *m_pTopMarginEdit, SFX_MAPUNIT_TWIP );
1515 0 : long nBB = GetCoreValue( *m_pBottomMarginEdit, SFX_MAPUNIT_TWIP );
1516 :
1517 0 : long nBL = GetCoreValue( *m_pLeftMarginEdit, SFX_MAPUNIT_TWIP );
1518 0 : long nBR = GetCoreValue( *m_pRightMarginEdit, SFX_MAPUNIT_TWIP );
1519 :
1520 0 : long nH = GetCoreValue( *m_pPaperHeightEdit, SFX_MAPUNIT_TWIP );
1521 0 : long nW = GetCoreValue( *m_pPaperWidthEdit, SFX_MAPUNIT_TWIP );
1522 :
1523 0 : long nWidth = nBL + nBR + MINBODY;
1524 0 : long nHeight = nBT + nBB + MINBODY;
1525 :
1526 0 : if ( nWidth > nW || nHeight > nH )
1527 : {
1528 0 : if ( nWidth > nW )
1529 : {
1530 0 : long nTmp = nBL <= nBR ? nBR : nBL;
1531 0 : nTmp -= nWidth - nW;
1532 :
1533 0 : if ( nBL <= nBR )
1534 0 : SetMetricValue( *m_pRightMarginEdit, nTmp, SFX_MAPUNIT_TWIP );
1535 : else
1536 0 : SetMetricValue( *m_pLeftMarginEdit, nTmp, SFX_MAPUNIT_TWIP );
1537 : }
1538 :
1539 0 : if ( nHeight > nH )
1540 : {
1541 0 : long nTmp = nBT <= nBB ? nBB : nBT;
1542 0 : nTmp -= nHeight - nH;
1543 :
1544 0 : if ( nBT <= nBB )
1545 0 : SetMetricValue( *m_pBottomMarginEdit, nTmp, SFX_MAPUNIT_TWIP );
1546 : else
1547 0 : SetMetricValue( *m_pTopMarginEdit, nTmp, SFX_MAPUNIT_TWIP );
1548 : }
1549 : }
1550 0 : }
1551 :
1552 : // -----------------------------------------------------------------------
1553 :
1554 0 : IMPL_LINK_NOARG_INLINE_START(SvxPageDescPage, CenterHdl_Impl)
1555 : {
1556 0 : m_pBspWin->SetHorz( m_pHorzBox->IsChecked() );
1557 0 : m_pBspWin->SetVert( m_pVertBox->IsChecked() );
1558 0 : UpdateExample_Impl();
1559 0 : return 0;
1560 : }
1561 0 : IMPL_LINK_NOARG_INLINE_END(SvxPageDescPage, CenterHdl_Impl)
1562 :
1563 : // -----------------------------------------------------------------------
1564 :
1565 0 : void SvxPageDescPage::SetCollectionList(const std::vector<OUString> &aList)
1566 : {
1567 : OSL_ENSURE(!aList.empty(), "Empty string list");
1568 :
1569 0 : sStandardRegister = aList[0];
1570 0 : for( sal_uInt16 i = 1; i < aList.size(); i++ )
1571 0 : m_pRegisterLB->InsertEntry(aList[i]);
1572 :
1573 0 : m_pRegisterCB->Show();
1574 0 : m_pRegisterFT->Show();
1575 0 : m_pRegisterLB->Show();
1576 0 : m_pRegisterCB->SetClickHdl(LINK(this, SvxPageDescPage, RegisterModify));
1577 0 : }
1578 :
1579 : // -----------------------------------------------------------------------
1580 :
1581 0 : IMPL_LINK( SvxPageDescPage, RegisterModify, CheckBox*, pBox )
1582 : {
1583 0 : sal_Bool bEnable = sal_False;
1584 0 : if(pBox->IsChecked())
1585 : {
1586 0 : bEnable = sal_True;
1587 0 : if(USHRT_MAX == m_pRegisterLB->GetSelectEntryPos())
1588 0 : m_pRegisterLB->SelectEntry(sStandardRegister);
1589 : }
1590 0 : m_pRegisterFT->Enable( bEnable );
1591 0 : m_pRegisterLB->Enable( bEnable );
1592 0 : return 0;
1593 : }
1594 :
1595 : // ----------------------------------------------------------------------------
1596 :
1597 0 : void SvxPageDescPage::DisableVerticalPageDir()
1598 : {
1599 0 : m_pTextFlowBox->RemoveEntryValue( FRMDIR_VERT_TOP_RIGHT );
1600 0 : m_pTextFlowBox->RemoveEntryValue( FRMDIR_VERT_TOP_LEFT );
1601 0 : if( m_pTextFlowBox->GetEntryCount() < 2 )
1602 : {
1603 0 : m_pTextFlowLbl->Hide();
1604 0 : m_pTextFlowBox->Hide();
1605 0 : m_pBspWin->EnableFrameDirection( sal_False );
1606 : }
1607 0 : }
1608 :
1609 0 : IMPL_LINK( SvxPageDescPage, FrameDirectionModify_Impl, ListBox*, EMPTYARG)
1610 : {
1611 0 : m_pBspWin->SetFrameDirection( (sal_uInt32) m_pTextFlowBox->GetSelectEntryValue() );
1612 0 : m_pBspWin->Invalidate();
1613 0 : return 0;
1614 : }
1615 :
1616 0 : bool SvxPageDescPage::IsPrinterRangeOverflow(
1617 : MetricField& rField, long nFirstMargin, long nLastMargin, MarginPosition nPos )
1618 : {
1619 0 : bool bRet = false;
1620 0 : bool bCheck = ( ( pImpl->m_nPos & nPos ) == 0 );
1621 0 : long nValue = static_cast<long>(rField.GetValue());
1622 0 : if ( bCheck &&
1623 0 : ( nValue < nFirstMargin || nValue > nLastMargin ) &&
1624 0 : rField.GetText() != rField.GetSavedValue() )
1625 : {
1626 0 : rField.SetValue( nValue < nFirstMargin ? nFirstMargin : nLastMargin );
1627 0 : bRet = true;
1628 : }
1629 :
1630 0 : return bRet;
1631 : }
1632 :
1633 : /** Check if a value of a margin edit is outside the printer paper margins
1634 : and save this information.
1635 : */
1636 0 : void SvxPageDescPage::CheckMarginEdits( bool _bClear )
1637 : {
1638 0 : if ( _bClear )
1639 0 : pImpl->m_nPos = 0;
1640 :
1641 0 : sal_Int64 nValue = m_pLeftMarginEdit->GetValue();
1642 0 : if ( nValue < nFirstLeftMargin || nValue > nLastLeftMargin )
1643 0 : pImpl->m_nPos |= MARGIN_LEFT;
1644 0 : nValue = m_pRightMarginEdit->GetValue();
1645 0 : if ( nValue < nFirstRightMargin || nValue > nLastRightMargin )
1646 0 : pImpl->m_nPos |= MARGIN_RIGHT;
1647 0 : nValue = m_pTopMarginEdit->GetValue();
1648 0 : if ( nValue < nFirstTopMargin || nValue > nLastTopMargin )
1649 0 : pImpl->m_nPos |= MARGIN_TOP;
1650 0 : nValue = m_pBottomMarginEdit->GetValue();
1651 0 : if ( nValue < nFirstBottomMargin || nValue > nLastBottomMargin )
1652 0 : pImpl->m_nPos |= MARGIN_BOTTOM;
1653 0 : }
1654 :
1655 0 : bool SvxPageDescPage::IsMarginOutOfRange()
1656 : {
1657 0 : bool bRet = ( ( ( !( pImpl->m_nPos & MARGIN_LEFT ) &&
1658 0 : ( m_pLeftMarginEdit->GetText() != m_pLeftMarginEdit->GetSavedValue() ) ) &&
1659 0 : ( m_pLeftMarginEdit->GetValue() < nFirstLeftMargin ||
1660 0 : m_pLeftMarginEdit->GetValue() > nLastLeftMargin ) ) ||
1661 0 : ( ( !( pImpl->m_nPos & MARGIN_RIGHT ) &&
1662 0 : ( m_pRightMarginEdit->GetText() != m_pRightMarginEdit->GetSavedValue() ) ) &&
1663 0 : ( m_pRightMarginEdit->GetValue() < nFirstRightMargin ||
1664 0 : m_pRightMarginEdit->GetValue() > nLastRightMargin ) ) ||
1665 0 : ( ( !( pImpl->m_nPos & MARGIN_TOP ) &&
1666 0 : ( m_pTopMarginEdit->GetText() != m_pTopMarginEdit->GetSavedValue() ) ) &&
1667 0 : ( m_pTopMarginEdit->GetValue() < nFirstTopMargin ||
1668 0 : m_pTopMarginEdit->GetValue() > nLastTopMargin ) ) ||
1669 0 : ( ( !( pImpl->m_nPos & MARGIN_BOTTOM ) &&
1670 0 : ( m_pBottomMarginEdit->GetText() != m_pBottomMarginEdit->GetSavedValue() ) ) &&
1671 0 : ( m_pBottomMarginEdit->GetValue() < nFirstBottomMargin ||
1672 0 : m_pBottomMarginEdit->GetValue() > nLastBottomMargin ) ) );
1673 0 : return bRet;
1674 : }
1675 :
1676 0 : void SvxPageDescPage::PageCreated (SfxAllItemSet aSet)
1677 : {
1678 0 : SFX_ITEMSET_ARG (&aSet,pModeItem,SfxAllEnumItem,SID_ENUM_PAGE_MODE,sal_False);
1679 0 : SFX_ITEMSET_ARG (&aSet,pPaperStartItem,SfxAllEnumItem,SID_PAPER_START,sal_False);
1680 0 : SFX_ITEMSET_ARG (&aSet,pPaperEndItem,SfxAllEnumItem,SID_PAPER_END,sal_False);
1681 0 : SFX_ITEMSET_ARG (&aSet,pCollectListItem,SfxStringListItem,SID_COLLECT_LIST,sal_False);
1682 0 : if (pModeItem)
1683 0 : SetMode((SvxModeType)pModeItem->GetEnumValue());
1684 0 : if (pPaperStartItem && pPaperEndItem)
1685 0 : SetPaperFormatRanges( (Paper)pPaperStartItem->GetEnumValue(), (Paper)pPaperEndItem->GetEnumValue() );
1686 0 : if (pCollectListItem)
1687 0 : SetCollectionList(pCollectListItem->GetList());
1688 0 : }
1689 :
1690 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
