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 <sal/config.h>
21 :
22 : #include <cstdlib>
23 :
24 : #include "PagePropertyPanel.hxx"
25 : #include "PagePropertyPanel.hrc"
26 :
27 : #include "PropertyPanel.hrc"
28 :
29 : #include <svx/sidebar/PopupContainer.hxx>
30 : #include "PageOrientationControl.hxx"
31 : #include "PageMarginControl.hxx"
32 : #include "PageSizeControl.hxx"
33 : #include "PageColumnControl.hxx"
34 :
35 : #include <swtypes.hxx>
36 : #include <cmdid.h>
37 :
38 : #include <svl/intitem.hxx>
39 : #include <editeng/sizeitem.hxx>
40 : #include <editeng/paperinf.hxx>
41 : #include <svx/svxids.hrc>
42 : #include <svx/dlgutil.hxx>
43 : #include <svx/rulritem.hxx>
44 :
45 : #include <sfx2/sidebar/ControlFactory.hxx>
46 : #include <sfx2/dispatch.hxx>
47 : #include <sfx2/bindings.hxx>
48 : #include <sfx2/viewsh.hxx>
49 : #include <sfx2/objsh.hxx>
50 :
51 : #include <boost/bind.hpp>
52 :
53 : #include <com/sun/star/frame/XController.hpp>
54 : #include <com/sun/star/frame/XModel.hpp>
55 : #include <com/sun/star/document/XUndoManagerSupplier.hpp>
56 :
57 : const char UNO_ORIENTATION[] = ".uno:Orientation";
58 : const char UNO_MARGIN[] = ".uno:Margin";
59 : const char UNO_SIZE[] = ".uno:Size";
60 : const char UNO_COLUMN[] = ".uno:Column";
61 :
62 : namespace {
63 337 : const css::uno::Reference< css::document::XUndoManager > getUndoManager( const css::uno::Reference< css::frame::XFrame >& rxFrame )
64 : {
65 337 : const css::uno::Reference< css::frame::XController >& xController = rxFrame->getController();
66 337 : if ( xController.is() )
67 : {
68 337 : const css::uno::Reference< css::frame::XModel >& xModel = xController->getModel();
69 337 : if ( xModel.is() )
70 : {
71 337 : const css::uno::Reference< css::document::XUndoManagerSupplier > xSuppUndo( xModel, css::uno::UNO_QUERY_THROW );
72 337 : if ( xSuppUndo.is() )
73 : {
74 337 : const css::uno::Reference< css::document::XUndoManager > xUndoManager( xSuppUndo->getUndoManager(), css::uno::UNO_QUERY_THROW );
75 337 : return xUndoManager;
76 0 : }
77 0 : }
78 : }
79 :
80 0 : return css::uno::Reference< css::document::XUndoManager > ();
81 : }
82 : }
83 :
84 : namespace sw { namespace sidebar {
85 :
86 350 : VclPtr<vcl::Window> PagePropertyPanel::Create (
87 : vcl::Window* pParent,
88 : const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame>& rxFrame,
89 : SfxBindings* pBindings)
90 : {
91 350 : if (pParent == NULL)
92 0 : throw ::com::sun::star::lang::IllegalArgumentException("no parent Window given to PagePropertyPanel::Create", NULL, 0);
93 350 : if ( ! rxFrame.is())
94 0 : throw ::com::sun::star::lang::IllegalArgumentException("no XFrame given to PagePropertyPanel::Create", NULL, 1);
95 350 : if (pBindings == NULL)
96 0 : throw ::com::sun::star::lang::IllegalArgumentException("no SfxBindings given to PagePropertyPanel::Create", NULL, 2);
97 :
98 : return VclPtr<PagePropertyPanel>::Create( pParent,
99 : rxFrame,
100 350 : pBindings);
101 : }
102 :
103 350 : PagePropertyPanel::PagePropertyPanel(
104 : vcl::Window* pParent,
105 : const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame>& rxFrame,
106 : SfxBindings* pBindings)
107 : : PanelLayout(pParent, "PagePropertyPanel", "modules/swriter/ui/sidebarpage.ui", rxFrame)
108 : , mpBindings(pBindings)
109 :
110 : // image resources
111 : , maImgSize (NULL)
112 : , maImgSize_L (NULL)
113 : , mImgPortrait (SW_RES(IMG_PAGE_PORTRAIT))
114 : , mImgLandscape (SW_RES(IMG_PAGE_LANDSCAPE))
115 : , mImgNarrow (SW_RES(IMG_PAGE_NARROW))
116 : , mImgNormal (SW_RES(IMG_PAGE_NORMAL))
117 : , mImgWide (SW_RES(IMG_PAGE_WIDE))
118 : , mImgMirrored (SW_RES(IMG_PAGE_MIRRORED))
119 : , mImgMarginCustom (SW_RES(IMG_PAGE_MARGIN_CUSTOM))
120 : , mImgNarrow_L (SW_RES(IMG_PAGE_NARROW_L))
121 : , mImgNormal_L (SW_RES(IMG_PAGE_NORMAL_L))
122 : , mImgWide_L (SW_RES(IMG_PAGE_WIDE_L))
123 : , mImgMirrored_L (SW_RES(IMG_PAGE_MIRRORED_L))
124 : , mImgMarginCustom_L (SW_RES(IMG_PAGE_MARGIN_CUSTOM_L))
125 : , mImgA3 (SW_RES(IMG_PAGE_A3))
126 : , mImgA4 (SW_RES(IMG_PAGE_A4))
127 : , mImgA5 (SW_RES(IMG_PAGE_A5))
128 : , mImgB4 (SW_RES(IMG_PAGE_B4))
129 : , mImgB5 (SW_RES(IMG_PAGE_B5))
130 : , mImgC5 (SW_RES(IMG_PAGE_C5))
131 : , mImgLetter (SW_RES(IMG_PAGE_LETTER))
132 : , mImgLegal (SW_RES(IMG_PAGE_LEGAL))
133 : , mImgSizeNone (SW_RES(IMG_PAGE_SIZE_NONE))
134 : , mImgA3_L (SW_RES(IMG_PAGE_A3_L))
135 : , mImgA4_L (SW_RES(IMG_PAGE_A4_L))
136 : , mImgA5_L (SW_RES(IMG_PAGE_A5_L))
137 : , mImgB4_L (SW_RES(IMG_PAGE_B4_L))
138 : , mImgB5_L (SW_RES(IMG_PAGE_B5_L))
139 : , mImgC5_L (SW_RES(IMG_PAGE_C5_L))
140 : , mImgLetter_L (SW_RES(IMG_PAGE_LETTER_L))
141 : , mImgLegal_L (SW_RES(IMG_PAGE_LEGAL_L))
142 : , mImgSizeNone_L (SW_RES(IMG_PAGE_SIZE_NONE_L))
143 : , mImgColumn1 (SW_RES(IMG_PAGE_COLUMN_1))
144 : , mImgColumn2 (SW_RES(IMG_PAGE_COLUMN_2))
145 : , mImgColumn3 (SW_RES(IMG_PAGE_COLUMN_3))
146 : , mImgLeft (SW_RES(IMG_PAGE_COLUMN_LEFT))
147 : , mImgRight (SW_RES(IMG_PAGE_COLUMN_RIGHT))
148 : , mImgColumnNone (SW_RES(IMG_PAGE_COLUMN_NONE))
149 : , mImgColumn1_L (SW_RES(IMG_PAGE_COLUMN_1_L))
150 : , mImgColumn2_L (SW_RES(IMG_PAGE_COLUMN_2_L))
151 : , mImgColumn3_L (SW_RES(IMG_PAGE_COLUMN_3_L))
152 : , mImgLeft_L (SW_RES(IMG_PAGE_COLUMN_LEFT_L))
153 : , mImgRight_L (SW_RES(IMG_PAGE_COLUMN_RIGHT_L))
154 : , mImgColumnNone_L (SW_RES(IMG_PAGE_COLUMN_NONE_L))
155 :
156 337 : , mpPageItem( new SvxPageItem(SID_ATTR_PAGE) )
157 337 : , mpPageLRMarginItem( new SvxLongLRSpaceItem( 0, 0, SID_ATTR_PAGE_LRSPACE ) )
158 337 : , mpPageULMarginItem( new SvxLongULSpaceItem( 0, 0, SID_ATTR_PAGE_ULSPACE ) )
159 337 : , mpPageSizeItem( new SvxSizeItem(SID_ATTR_PAGE_SIZE) )
160 : , mePaper( PAPER_USER )
161 337 : , mpPageColumnTypeItem( new SfxInt16Item(SID_ATTR_PAGE_COLUMN) )
162 :
163 : , meFUnit()
164 : , meUnit()
165 :
166 : , m_aSwPagePgULControl(SID_ATTR_PAGE_ULSPACE, *pBindings, *this)
167 : , m_aSwPagePgLRControl(SID_ATTR_PAGE_LRSPACE, *pBindings, *this)
168 : , m_aSwPagePgSizeControl(SID_ATTR_PAGE_SIZE, *pBindings, *this)
169 : , m_aSwPagePgControl(SID_ATTR_PAGE, *pBindings, *this)
170 : , m_aSwPageColControl(SID_ATTR_PAGE_COLUMN, *pBindings, *this)
171 : , m_aSwPagePgMetricControl(SID_ATTR_METRIC, *pBindings, *this)
172 :
173 : , maOrientationPopup( this,
174 : ::boost::bind( &PagePropertyPanel::CreatePageOrientationControl, this, _1 ),
175 : OUString("Page orientation") )
176 : , maMarginPopup( this,
177 : ::boost::bind( &PagePropertyPanel::CreatePageMarginControl, this, _1 ),
178 : OUString("Page margins") )
179 : , maSizePopup( this,
180 : ::boost::bind( &PagePropertyPanel::CreatePageSizeControl, this, _1 ),
181 : OUString("Page size") )
182 : , maColumnPopup( this,
183 : ::boost::bind( &PagePropertyPanel::CreatePageColumnControl, this, _1 ),
184 : OUString("Page columns") )
185 :
186 : , mxUndoManager( getUndoManager( rxFrame ) )
187 :
188 2048 : , mbInvalidateSIDAttrPageOnSIDAttrPageSizeNotify( false )
189 : {
190 : // visible controls
191 337 : get(mpToolBoxOrientation, "selectorientation");
192 337 : get(mpToolBoxMargin, "selectmargin");
193 337 : get(mpToolBoxSize, "selectsize");
194 337 : get(mpToolBoxColumn, "selectcolumn");
195 :
196 337 : Initialize();
197 337 : mbInvalidateSIDAttrPageOnSIDAttrPageSizeNotify = true;
198 337 : }
199 :
200 0 : PagePropertyPanel::~PagePropertyPanel()
201 : {
202 0 : disposeOnce();
203 0 : }
204 :
205 337 : void PagePropertyPanel::dispose()
206 : {
207 337 : delete[] maImgSize;
208 337 : maImgSize = NULL;
209 337 : delete[] maImgSize_L;
210 337 : maImgSize_L = NULL;
211 :
212 337 : mpPageItem.reset();
213 337 : mpPageLRMarginItem.reset();
214 337 : mpPageULMarginItem.reset();
215 337 : mpPageSizeItem.reset();
216 :
217 337 : mpToolBoxOrientation.clear();
218 337 : mpToolBoxMargin.clear();
219 337 : mpToolBoxSize.clear();
220 337 : mpToolBoxColumn.clear();
221 :
222 337 : m_aSwPagePgULControl.dispose();
223 337 : m_aSwPagePgLRControl.dispose();
224 337 : m_aSwPagePgSizeControl.dispose();
225 337 : m_aSwPagePgControl.dispose();
226 337 : m_aSwPageColControl.dispose();
227 337 : m_aSwPagePgMetricControl.dispose();
228 :
229 337 : PanelLayout::dispose();
230 337 : }
231 :
232 337 : void PagePropertyPanel::Initialize()
233 : {
234 : // popup for page orientation
235 337 : const sal_uInt16 nIdOrientation = mpToolBoxOrientation->GetItemId(UNO_ORIENTATION);
236 337 : Link<ToolBox *, void> aLink = LINK( this, PagePropertyPanel, ClickOrientationHdl );
237 337 : mpToolBoxOrientation->SetDropdownClickHdl( aLink );
238 337 : mpToolBoxOrientation->SetSelectHdl( aLink );
239 337 : mpToolBoxOrientation->SetItemImage( nIdOrientation, mImgPortrait);
240 337 : mpToolBoxOrientation->SetItemBits( nIdOrientation, mpToolBoxOrientation->GetItemBits( nIdOrientation ) | ToolBoxItemBits::DROPDOWNONLY );
241 :
242 : // popup for page margins
243 337 : const sal_uInt16 nIdMargin = mpToolBoxMargin->GetItemId(UNO_MARGIN);
244 337 : aLink = LINK( this, PagePropertyPanel, ClickMarginHdl );
245 337 : mpToolBoxMargin->SetDropdownClickHdl( aLink );
246 337 : mpToolBoxMargin->SetSelectHdl( aLink );
247 337 : mpToolBoxMargin->SetItemImage(nIdMargin, mImgNormal);
248 337 : mpToolBoxMargin->SetItemBits( nIdMargin, mpToolBoxMargin->GetItemBits( nIdMargin ) | ToolBoxItemBits::DROPDOWNONLY );
249 :
250 : // popup for page size
251 337 : const sal_uInt16 nIdSize = mpToolBoxSize->GetItemId(UNO_SIZE);
252 337 : aLink = LINK( this, PagePropertyPanel, ClickSizeHdl );
253 337 : mpToolBoxSize->SetDropdownClickHdl( aLink );
254 337 : mpToolBoxSize->SetSelectHdl( aLink );
255 337 : mpToolBoxSize->SetItemImage(nIdSize, mImgLetter);
256 337 : mpToolBoxSize->SetItemBits( nIdSize, mpToolBoxSize->GetItemBits( nIdSize ) | ToolBoxItemBits::DROPDOWNONLY );
257 337 : maImgSize = new Image[8];
258 337 : maImgSize[0] = mImgA3;
259 337 : maImgSize[1] = mImgA4;
260 337 : maImgSize[2] = mImgA5;
261 337 : maImgSize[3] = mImgB4;
262 337 : maImgSize[4] = mImgB5;
263 337 : maImgSize[5] = mImgC5;
264 337 : maImgSize[6] = mImgLetter;
265 337 : maImgSize[7] = mImgLegal;
266 337 : maImgSize_L = new Image[8];
267 337 : maImgSize_L[0] = mImgA3_L;
268 337 : maImgSize_L[1] = mImgA4_L;
269 337 : maImgSize_L[2] = mImgA5_L;
270 337 : maImgSize_L[3] = mImgB4_L;
271 337 : maImgSize_L[4] = mImgB5_L;
272 337 : maImgSize_L[5] = mImgC5_L;
273 337 : maImgSize_L[6] = mImgLetter_L;
274 337 : maImgSize_L[7] = mImgLegal_L;
275 :
276 : // popup for page column property
277 337 : const sal_uInt16 nIdColumn = mpToolBoxColumn->GetItemId(UNO_COLUMN);
278 337 : aLink = LINK( this, PagePropertyPanel, ClickColumnHdl );
279 337 : mpToolBoxColumn->SetDropdownClickHdl( aLink );
280 337 : mpToolBoxColumn->SetSelectHdl( aLink );
281 337 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn1);
282 337 : mpToolBoxColumn->SetItemBits( nIdColumn, mpToolBoxColumn->GetItemBits( nIdColumn ) | ToolBoxItemBits::DROPDOWNONLY );
283 :
284 337 : meFUnit = GetModuleFieldUnit();
285 337 : meUnit = m_aSwPagePgSizeControl.GetCoreMetric();
286 :
287 : // 'pull' for page style's attribute values
288 337 : mpBindings->Update( SID_ATTR_PAGE_LRSPACE );
289 337 : mpBindings->Update( SID_ATTR_PAGE_ULSPACE );
290 337 : mpBindings->Update( SID_ATTR_PAGE );
291 337 : mpBindings->Update( SID_ATTR_PAGE_SIZE );
292 337 : }
293 :
294 0 : VclPtr< svx::sidebar::PopupControl> PagePropertyPanel::CreatePageOrientationControl( svx::sidebar::PopupContainer* pParent )
295 : {
296 0 : return VclPtr<PageOrientationControl>::Create( pParent, *this , mpPageItem->IsLandscape() );
297 : }
298 :
299 0 : IMPL_LINK_TYPED( PagePropertyPanel, ClickOrientationHdl, ToolBox*, pToolBox, void )
300 : {
301 0 : maOrientationPopup.Show( *pToolBox );
302 0 : }
303 :
304 0 : void PagePropertyPanel::ExecuteOrientationChange( const bool bLandscape )
305 : {
306 0 : StartUndo();
307 :
308 : {
309 : // set new page orientation
310 0 : mpPageItem->SetLandscape( bLandscape );
311 :
312 : // swap the width and height of the page size
313 0 : const long nRotatedWidth = mpPageSizeItem->GetSize().Height();
314 0 : const long nRotatedHeight = mpPageSizeItem->GetSize().Width();
315 0 : mpPageSizeItem->SetSize(Size(nRotatedWidth, nRotatedHeight));
316 :
317 : // apply changed attributes
318 0 : GetBindings()->GetDispatcher()->Execute( SID_ATTR_PAGE_SIZE, SfxCallMode::RECORD, mpPageSizeItem.get(), mpPageItem.get(), 0L );
319 : }
320 :
321 : // check, if margin values still fit to the changed page size.
322 : // if not, adjust margin values
323 : {
324 0 : const long nML = mpPageLRMarginItem->GetLeft();
325 0 : const long nMR = mpPageLRMarginItem->GetRight();
326 0 : const long nTmpPW = nML + nMR + MINBODY;
327 :
328 0 : const long nPW = mpPageSizeItem->GetSize().Width();
329 :
330 0 : if ( nTmpPW > nPW )
331 : {
332 0 : if ( nML <= nMR )
333 : {
334 0 : ExecuteMarginLRChange( mpPageLRMarginItem->GetLeft(), nMR - (nTmpPW - nPW ) );
335 : }
336 : else
337 : {
338 0 : ExecuteMarginLRChange( nML - (nTmpPW - nPW ), mpPageLRMarginItem->GetRight() );
339 : }
340 : }
341 :
342 0 : const long nMT = mpPageULMarginItem->GetUpper();
343 0 : const long nMB = mpPageULMarginItem->GetLower();
344 0 : const long nTmpPH = nMT + nMB + MINBODY;
345 :
346 0 : const long nPH = mpPageSizeItem->GetSize().Height();
347 :
348 0 : if ( nTmpPH > nPH )
349 : {
350 0 : if ( nMT <= nMB )
351 : {
352 0 : ExecuteMarginULChange( mpPageULMarginItem->GetUpper(), nMB - ( nTmpPH - nPH ) );
353 : }
354 : else
355 : {
356 0 : ExecuteMarginULChange( nMT - ( nTmpPH - nPH ), mpPageULMarginItem->GetLower() );
357 : }
358 : }
359 : }
360 :
361 0 : EndUndo();
362 0 : }
363 :
364 0 : void PagePropertyPanel::ClosePageOrientationPopup()
365 : {
366 0 : maOrientationPopup.Hide();
367 0 : }
368 :
369 0 : VclPtr< svx::sidebar::PopupControl> PagePropertyPanel::CreatePageMarginControl( svx::sidebar::PopupContainer* pParent )
370 : {
371 : return VclPtr<PageMarginControl>::Create(
372 :
373 : pParent,
374 : *this,
375 0 : *mpPageLRMarginItem.get(),
376 0 : *mpPageULMarginItem.get(),
377 0 : mpPageItem->GetPageUsage() == SVX_PAGE_MIRROR,
378 0 : mpPageSizeItem->GetSize(),
379 0 : mpPageItem->IsLandscape(),
380 : meFUnit,
381 0 : meUnit );
382 : }
383 :
384 0 : void PagePropertyPanel::ExecuteMarginLRChange(
385 : const long nPageLeftMargin,
386 : const long nPageRightMargin )
387 : {
388 0 : mpPageLRMarginItem->SetLeft( nPageLeftMargin );
389 0 : mpPageLRMarginItem->SetRight( nPageRightMargin );
390 0 : GetBindings()->GetDispatcher()->Execute( SID_ATTR_PAGE_LRSPACE, SfxCallMode::RECORD, mpPageLRMarginItem.get(), 0L );
391 0 : }
392 :
393 0 : void PagePropertyPanel::ExecuteMarginULChange(
394 : const long nPageTopMargin,
395 : const long nPageBottomMargin )
396 : {
397 0 : mpPageULMarginItem->SetUpper( nPageTopMargin );
398 0 : mpPageULMarginItem->SetLower( nPageBottomMargin );
399 0 : GetBindings()->GetDispatcher()->Execute( SID_ATTR_PAGE_ULSPACE, SfxCallMode::RECORD, mpPageULMarginItem.get(), 0L );
400 0 : }
401 :
402 0 : void PagePropertyPanel::ExecutePageLayoutChange( const bool bMirrored )
403 : {
404 0 : mpPageItem->SetPageUsage( bMirrored ? SVX_PAGE_MIRROR : SVX_PAGE_ALL );
405 0 : GetBindings()->GetDispatcher()->Execute( SID_ATTR_PAGE, SfxCallMode::RECORD, mpPageItem.get(), 0L );
406 0 : }
407 :
408 0 : IMPL_LINK_TYPED( PagePropertyPanel, ClickMarginHdl, ToolBox*, pToolBox, void )
409 : {
410 0 : maMarginPopup.Show( *pToolBox );
411 0 : }
412 :
413 0 : void PagePropertyPanel::ClosePageMarginPopup()
414 : {
415 0 : maMarginPopup.Hide();
416 0 : }
417 :
418 0 : VclPtr< svx::sidebar::PopupControl> PagePropertyPanel::CreatePageSizeControl( svx::sidebar::PopupContainer* pParent )
419 : {
420 : return VclPtr<PageSizeControl>::Create(
421 :
422 : pParent,
423 : *this,
424 : mePaper,
425 0 : mpPageItem->IsLandscape(),
426 0 : meFUnit );
427 : }
428 :
429 0 : void PagePropertyPanel::ExecuteSizeChange( const Paper ePaper )
430 : {
431 0 : Size aPageSize = SvxPaperInfo::GetPaperSize( ePaper, (MapUnit)(meUnit) );
432 0 : if ( mpPageItem->IsLandscape() )
433 : {
434 0 : Swap( aPageSize );
435 : }
436 0 : mpPageSizeItem->SetSize( aPageSize );
437 :
438 0 : mpBindings->GetDispatcher()->Execute(SID_ATTR_PAGE_SIZE, SfxCallMode::RECORD, mpPageSizeItem.get(), 0L );
439 0 : }
440 :
441 0 : IMPL_LINK_TYPED( PagePropertyPanel, ClickSizeHdl, ToolBox*, pToolBox, void )
442 : {
443 0 : maSizePopup.Show( *pToolBox );
444 0 : }
445 :
446 0 : void PagePropertyPanel::ClosePageSizePopup()
447 : {
448 0 : maSizePopup.Hide();
449 0 : }
450 :
451 0 : VclPtr< svx::sidebar::PopupControl> PagePropertyPanel::CreatePageColumnControl( svx::sidebar::PopupContainer* pParent )
452 : {
453 : return VclPtr<PageColumnControl>::Create(
454 :
455 : pParent,
456 : *this,
457 0 : mpPageColumnTypeItem->GetValue(),
458 0 : mpPageItem->IsLandscape() );
459 : }
460 :
461 0 : void PagePropertyPanel::ExecuteColumnChange( const sal_uInt16 nColumnType )
462 : {
463 0 : mpPageColumnTypeItem->SetValue( nColumnType );
464 0 : mpBindings->GetDispatcher()->Execute(SID_ATTR_PAGE_COLUMN, SfxCallMode::RECORD, mpPageColumnTypeItem.get(), 0L );
465 0 : }
466 :
467 0 : IMPL_LINK_TYPED( PagePropertyPanel, ClickColumnHdl, ToolBox*, pToolBox, void )
468 : {
469 0 : maColumnPopup.Show( *pToolBox );
470 0 : }
471 :
472 0 : void PagePropertyPanel::ClosePageColumnPopup()
473 : {
474 0 : maColumnPopup.Hide();
475 0 : }
476 :
477 1873 : void PagePropertyPanel::NotifyItemUpdate(
478 : const sal_uInt16 nSId,
479 : const SfxItemState eState,
480 : const SfxPoolItem* pState,
481 : const bool bIsEnabled)
482 : {
483 : (void)bIsEnabled;
484 :
485 1873 : if (IsDisposed())
486 1873 : return;
487 :
488 1873 : switch( nSId )
489 : {
490 : case SID_ATTR_PAGE_COLUMN:
491 : {
492 520 : if ( eState >= SfxItemState::DEFAULT &&
493 520 : pState && pState->ISA(SfxInt16Item) )
494 : {
495 260 : mpPageColumnTypeItem.reset( static_cast<SfxInt16Item*>(pState->Clone()) );
496 260 : ChangeColumnImage( mpPageColumnTypeItem->GetValue() );
497 : }
498 : }
499 260 : break;
500 : case SID_ATTR_PAGE_LRSPACE:
501 680 : if ( eState >= SfxItemState::DEFAULT &&
502 680 : pState && pState->ISA(SvxLongLRSpaceItem) )
503 : {
504 340 : mpPageLRMarginItem.reset( static_cast<SvxLongLRSpaceItem*>(pState->Clone()) );
505 340 : ChangeMarginImage();
506 : }
507 340 : break;
508 :
509 : case SID_ATTR_PAGE_ULSPACE:
510 680 : if ( eState >= SfxItemState::DEFAULT &&
511 680 : pState && pState->ISA(SvxLongULSpaceItem) )
512 : {
513 340 : mpPageULMarginItem.reset( static_cast<SvxLongULSpaceItem*>(pState->Clone()) );
514 340 : ChangeMarginImage();
515 : }
516 340 : break;
517 :
518 : case SID_ATTR_PAGE:
519 674 : if ( eState >= SfxItemState::DEFAULT &&
520 674 : pState && pState->ISA(SvxPageItem) )
521 : {
522 337 : const sal_uInt16 nIdOrientation = mpToolBoxOrientation->GetItemId(UNO_ORIENTATION);
523 337 : mpPageItem.reset( static_cast<SvxPageItem*>(pState->Clone()) );
524 337 : if ( mpPageItem->IsLandscape() )
525 : {
526 0 : mpToolBoxOrientation->SetItemImage(nIdOrientation, mImgLandscape);
527 : }
528 : else
529 : {
530 337 : mpToolBoxOrientation->SetItemImage(nIdOrientation, mImgPortrait);
531 : }
532 337 : ChangeMarginImage();
533 337 : ChangeSizeImage();
534 337 : ChangeColumnImage( mpPageColumnTypeItem->GetValue() );
535 : }
536 337 : break;
537 :
538 : case SID_ATTR_PAGE_SIZE:
539 337 : if ( mbInvalidateSIDAttrPageOnSIDAttrPageSizeNotify )
540 : {
541 0 : mpBindings->Invalidate( SID_ATTR_PAGE, true, false );
542 : }
543 674 : if ( eState >= SfxItemState::DEFAULT &&
544 674 : pState && pState->ISA(SvxSizeItem) )
545 : {
546 337 : mpPageSizeItem.reset( static_cast<SvxSizeItem*>(pState->Clone()) );
547 337 : ChangeSizeImage();
548 : }
549 337 : break;
550 : case SID_ATTR_METRIC:
551 259 : MetricState( eState, pState );
552 259 : break;
553 : }
554 : }
555 :
556 259 : void PagePropertyPanel::MetricState( SfxItemState eState, const SfxPoolItem* pState )
557 : {
558 259 : meFUnit = FUNIT_NONE;
559 259 : if ( pState && eState >= SfxItemState::DEFAULT )
560 : {
561 259 : meFUnit = (FieldUnit)static_cast<const SfxUInt16Item*>(pState )->GetValue();
562 : }
563 : else
564 : {
565 0 : SfxViewFrame* pFrame = SfxViewFrame::Current();
566 0 : SfxObjectShell* pSh = NULL;
567 0 : if ( pFrame )
568 0 : pSh = pFrame->GetObjectShell();
569 0 : if ( pSh )
570 : {
571 0 : SfxModule* pModule = pSh->GetModule();
572 0 : if ( pModule )
573 : {
574 0 : const SfxPoolItem* pItem = pModule->GetItem( SID_ATTR_METRIC );
575 0 : if ( pItem )
576 0 : meFUnit = (FieldUnit)static_cast<const SfxUInt16Item*>(pItem )->GetValue();
577 : }
578 : else
579 : {
580 : SAL_WARN("sw.ui", "<PagePropertyPanel::MetricState(..)>: no module found");
581 : }
582 : }
583 : }
584 259 : }
585 :
586 1017 : void PagePropertyPanel::ChangeMarginImage()
587 : {
588 3051 : if ( mpPageLRMarginItem.get() == 0 ||
589 2034 : mpPageULMarginItem.get() == 0 ||
590 1017 : mpPageItem.get() == 0 )
591 : {
592 1017 : return;
593 : }
594 :
595 1017 : const long cTolerance = 5;
596 1017 : const sal_uInt16 nIdMargin = mpToolBoxMargin->GetItemId(UNO_MARGIN);
597 :
598 2034 : if( std::abs(mpPageLRMarginItem->GetLeft() - SWPAGE_NARROW_VALUE) <= cTolerance &&
599 0 : std::abs(mpPageLRMarginItem->GetRight() - SWPAGE_NARROW_VALUE) <= cTolerance &&
600 0 : std::abs(mpPageULMarginItem->GetUpper() - SWPAGE_NARROW_VALUE) <= cTolerance &&
601 1017 : std::abs(mpPageULMarginItem->GetLower() - SWPAGE_NARROW_VALUE) <= cTolerance &&
602 0 : mpPageItem->GetPageUsage() != SVX_PAGE_MIRROR )
603 0 : mpToolBoxMargin->SetItemImage( nIdMargin, mpPageItem->IsLandscape() ? mImgNarrow_L : mImgNarrow );
604 :
605 3048 : else if( std::abs(mpPageLRMarginItem->GetLeft() - SWPAGE_NORMAL_VALUE) <= cTolerance &&
606 2027 : std::abs(mpPageLRMarginItem->GetRight() - SWPAGE_NORMAL_VALUE) <= cTolerance &&
607 1687 : std::abs(mpPageULMarginItem->GetUpper() - SWPAGE_NORMAL_VALUE) <= cTolerance &&
608 2365 : std::abs(mpPageULMarginItem->GetLower() - SWPAGE_NORMAL_VALUE) <= cTolerance &&
609 674 : mpPageItem->GetPageUsage() != SVX_PAGE_MIRROR )
610 674 : mpToolBoxMargin->SetItemImage( nIdMargin, mpPageItem->IsLandscape() ? mImgNormal_L : mImgNormal );
611 :
612 686 : else if( std::abs(mpPageLRMarginItem->GetLeft() - SWPAGE_WIDE_VALUE2) <= cTolerance &&
613 0 : std::abs(mpPageLRMarginItem->GetRight() - SWPAGE_WIDE_VALUE2) <= cTolerance &&
614 0 : std::abs(mpPageULMarginItem->GetUpper() - SWPAGE_WIDE_VALUE1) <= cTolerance &&
615 343 : std::abs(mpPageULMarginItem->GetLower() - SWPAGE_WIDE_VALUE1) <= cTolerance &&
616 0 : mpPageItem->GetPageUsage() != SVX_PAGE_MIRROR )
617 0 : mpToolBoxMargin->SetItemImage( nIdMargin, mpPageItem->IsLandscape() ? mImgWide_L : mImgWide );
618 :
619 689 : else if( std::abs(mpPageLRMarginItem->GetLeft() - SWPAGE_WIDE_VALUE3) <= cTolerance &&
620 3 : std::abs(mpPageLRMarginItem->GetRight() - SWPAGE_WIDE_VALUE1) <= cTolerance &&
621 0 : std::abs(mpPageULMarginItem->GetUpper() - SWPAGE_WIDE_VALUE1) <= cTolerance &&
622 343 : std::abs(mpPageULMarginItem->GetLower() - SWPAGE_WIDE_VALUE1) <= cTolerance &&
623 0 : mpPageItem->GetPageUsage() == SVX_PAGE_MIRROR )
624 0 : mpToolBoxMargin->SetItemImage( nIdMargin, mpPageItem->IsLandscape() ? mImgMirrored_L : mImgMirrored );
625 :
626 : else
627 343 : mpToolBoxMargin->SetItemImage( nIdMargin, mpPageItem->IsLandscape() ? mImgMarginCustom_L : mImgMarginCustom );
628 : }
629 :
630 674 : void PagePropertyPanel::ChangeSizeImage()
631 : {
632 1348 : if ( mpPageSizeItem.get() == 0 ||
633 674 : mpPageItem.get() == 0 )
634 : {
635 674 : return;
636 : }
637 :
638 674 : Size aTmpPaperSize = mpPageSizeItem->GetSize();
639 674 : if ( mpPageItem->IsLandscape() )
640 : {
641 0 : Swap( aTmpPaperSize ); // Swap(..) defined in editeng/paperinf.hxx
642 : }
643 :
644 674 : mePaper = SvxPaperInfo::GetSvxPaper( aTmpPaperSize, static_cast<MapUnit>(meUnit), true );
645 :
646 674 : sal_uInt16 nImageIdx = 0;
647 674 : switch ( mePaper )
648 : {
649 : case PAPER_A3:
650 0 : nImageIdx = 1;
651 0 : break;
652 : case PAPER_A4:
653 336 : nImageIdx = 2;
654 336 : break;
655 : case PAPER_A5:
656 0 : nImageIdx = 3;
657 0 : break;
658 : case PAPER_B4_ISO:
659 0 : nImageIdx = 4;
660 0 : break;
661 : case PAPER_B5_ISO:
662 0 : nImageIdx = 5;
663 0 : break;
664 : case PAPER_ENV_C5:
665 0 : nImageIdx = 6;
666 0 : break;
667 : case PAPER_LETTER:
668 1 : nImageIdx = 7;
669 1 : break;
670 : case PAPER_LEGAL:
671 0 : nImageIdx = 8;
672 0 : break;
673 : default:
674 337 : nImageIdx = 0;
675 337 : mePaper = PAPER_USER;
676 337 : break;
677 : }
678 :
679 674 : const sal_uInt16 nIdSize = mpToolBoxSize->GetItemId(UNO_SIZE);
680 :
681 674 : if ( nImageIdx == 0 )
682 : {
683 : mpToolBoxSize->SetItemImage( nIdSize,
684 337 : ( mpPageItem->IsLandscape() ? mImgSizeNone_L : mImgSizeNone ) );
685 : }
686 : else
687 : {
688 : mpToolBoxSize->SetItemImage( nIdSize,
689 337 : ( mpPageItem->IsLandscape() ? maImgSize_L[nImageIdx-1] : maImgSize[nImageIdx-1] ) );
690 : }
691 : }
692 :
693 597 : void PagePropertyPanel::ChangeColumnImage( const sal_uInt16 nColumnType )
694 : {
695 597 : if ( mpPageItem.get() == 0 )
696 : {
697 597 : return;
698 : }
699 :
700 597 : const sal_uInt16 nIdColumn = mpToolBoxColumn->GetItemId(UNO_COLUMN);
701 597 : if ( !mpPageItem->IsLandscape() )
702 : {
703 597 : switch( nColumnType )
704 : {
705 : case 1:
706 260 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn1);
707 260 : break;
708 : case 2:
709 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn2);
710 0 : break;
711 : case 3:
712 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn3);
713 0 : break;
714 : case 4:
715 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgLeft);
716 0 : break;
717 : case 5:
718 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgRight);
719 0 : break;
720 : default:
721 337 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumnNone);
722 : }
723 : }
724 : else
725 : {
726 0 : switch( nColumnType )
727 : {
728 : case 1:
729 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn1_L);
730 0 : break;
731 : case 2:
732 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn2_L);
733 0 : break;
734 : case 3:
735 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumn3_L);
736 0 : break;
737 : case 4:
738 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgLeft_L);
739 0 : break;
740 : case 5:
741 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgRight_L);
742 0 : break;
743 : default:
744 0 : mpToolBoxColumn->SetItemImage(nIdColumn, mImgColumnNone_L);
745 : }
746 : }
747 : }
748 :
749 0 : void PagePropertyPanel::StartUndo()
750 : {
751 0 : if ( mxUndoManager.is() )
752 : {
753 0 : mxUndoManager->enterUndoContext( OUString("") );
754 : }
755 0 : }
756 :
757 0 : void PagePropertyPanel::EndUndo()
758 : {
759 0 : if ( mxUndoManager.is() )
760 : {
761 0 : mxUndoManager->leaveUndoContext();
762 : }
763 0 : }
764 :
765 177 : } } // end of namespace ::sw::sidebar
766 :
767 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
