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 :
21 : #include "sddll.hxx"
22 :
23 : #include <com/sun/star/beans/XMultiPropertyStates.hpp>
24 : #include <com/sun/star/frame/XController.hpp>
25 : #include <com/sun/star/view/XSelectionSupplier.hpp>
26 : #include <com/sun/star/style/XStyle.hpp>
27 : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
28 :
29 : #include <comphelper/processfactory.hxx>
30 : #include <sfx2/viewfrm.hxx>
31 : #include <vcl/bmpacc.hxx>
32 : #include <svl/style.hxx>
33 : #include <sfx2/bindings.hxx>
34 : #include <sfx2/app.hxx>
35 : #include <sfx2/request.hxx>
36 : #include <sfx2/dispatch.hxx>
37 : #include <svx/svxids.hrc>
38 : #include <svx/svdetc.hxx>
39 : #include <editeng/boxitem.hxx>
40 : #include <editeng/borderline.hxx>
41 : #include <editeng/colritem.hxx>
42 : #include <editeng/eeitem.hxx>
43 : #include <svx/sdr/table/tabledesign.hxx>
44 :
45 : #include "TableDesignPane.hxx"
46 : #include <svtools/valueset.hxx>
47 :
48 : #include "DrawDocShell.hxx"
49 : #include "ViewShellBase.hxx"
50 : #include "DrawViewShell.hxx"
51 : #include "DrawController.hxx"
52 : #include "glob.hrc"
53 : #include "sdresid.hxx"
54 : #include "EventMultiplexer.hxx"
55 :
56 : using ::rtl::OUString;
57 : using namespace ::com::sun::star;
58 : using namespace ::com::sun::star::uno;
59 : using namespace ::com::sun::star::drawing;
60 : using namespace ::com::sun::star::container;
61 : using namespace ::com::sun::star::beans;
62 : using namespace ::com::sun::star::view;
63 : using namespace ::com::sun::star::style;
64 : using namespace ::com::sun::star::frame;
65 : using namespace ::com::sun::star::lang;
66 : using namespace ::com::sun::star::ui;
67 :
68 : namespace sd {
69 :
70 : static const sal_Int32 nPreviewColumns = 5;
71 : static const sal_Int32 nPreviewRows = 5;
72 :
73 : // --------------------------------------------------------------------
74 :
75 0 : static const OUString* getPropertyNames()
76 : {
77 : static const OUString gPropNames[ CB_BANDED_COLUMNS-CB_HEADER_ROW+1 ] =
78 : {
79 : OUString("UseFirstRowStyle") ,
80 : OUString("UseLastRowStyle") ,
81 : OUString("UseBandingRowStyle") ,
82 : OUString("UseFirstColumnStyle") ,
83 : OUString("UseLastColumnStyle") ,
84 : OUString("UseBandingColumnStyle")
85 0 : };
86 0 : return &gPropNames[0];
87 : }
88 : // --------------------------------------------------------------------
89 :
90 0 : TableDesignPane::TableDesignPane( ::Window* pParent, ViewShellBase& rBase, bool bModal )
91 : : Control( pParent, SdResId(DLG_TABLEDESIGNPANE) )
92 : , mrBase( rBase )
93 : , msTableTemplate( "TableTemplate" )
94 : , mbModal( bModal )
95 : , mbStyleSelected( false )
96 0 : , mbOptionsChanged( false )
97 : {
98 0 : Window* pControlParent = mbModal ? pParent : this;
99 :
100 0 : mxControls[FL_TABLE_STYLES].reset( new FixedLine( pControlParent, SdResId( FL_TABLE_STYLES + 1 ) ) );
101 :
102 0 : ValueSet* pValueSet = new ValueSet( pControlParent, SdResId( CT_TABLE_STYLES+1 ) );
103 0 : mxControls[CT_TABLE_STYLES].reset( pValueSet );
104 0 : if( !mbModal )
105 : {
106 0 : pValueSet->SetStyle( (pValueSet->GetStyle() & ~(WB_ITEMBORDER|WB_BORDER)) | WB_NO_DIRECTSELECT | WB_FLATVALUESET | WB_NOBORDER );
107 0 : pValueSet->SetColor();
108 0 : pValueSet->SetExtraSpacing(8);
109 : }
110 : else
111 : {
112 0 : pValueSet->SetColor( Color( COL_WHITE ) );
113 0 : pValueSet->SetBackground( Color( COL_WHITE ) );
114 : }
115 0 : pValueSet->SetSelectHdl (LINK(this, TableDesignPane, implValueSetHdl));
116 :
117 0 : mxControls[FL_STYLE_OPTIONS].reset( new FixedLine( pControlParent, SdResId( FL_STYLE_OPTIONS + 1 ) ) );
118 : sal_uInt16 i;
119 0 : for( i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i )
120 : {
121 0 : CheckBox *pCheckBox = new CheckBox( pControlParent, SdResId( i+1 ) );
122 0 : mxControls[i].reset( pCheckBox );
123 0 : pCheckBox->SetClickHdl( LINK( this, TableDesignPane, implCheckBoxHdl ) );
124 : }
125 :
126 0 : for( i = 0; i < DESIGNPANE_CONTROL_COUNT; i++ )
127 0 : mnOrgOffsetY[i] = mxControls[i]->GetPosPixel().Y();
128 :
129 : // get current controller and initialize listeners
130 : try
131 : {
132 0 : mxView = Reference< XDrawView >::query(mrBase.GetController());
133 0 : addListener();
134 :
135 0 : Reference< XController > xController( mrBase.GetController(), UNO_QUERY_THROW );
136 0 : Reference< XStyleFamiliesSupplier > xFamiliesSupp( xController->getModel(), UNO_QUERY_THROW );
137 0 : Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
138 0 : const OUString sFamilyName( "table" );
139 0 : mxTableFamily = Reference< XIndexAccess >( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW );
140 :
141 : }
142 0 : catch( Exception& )
143 : {
144 : OSL_FAIL( "sd::CustomAnimationPane::CustomAnimationPane(), Exception caught!" );
145 : }
146 :
147 0 : onSelectionChanged();
148 0 : updateControls();
149 :
150 0 : FreeResource();
151 0 : }
152 :
153 : // --------------------------------------------------------------------
154 :
155 0 : TableDesignPane::~TableDesignPane()
156 : {
157 0 : removeListener();
158 0 : }
159 :
160 : // --------------------------------------------------------------------
161 :
162 0 : void TableDesignPane::DataChanged( const DataChangedEvent& /*rDCEvt*/ )
163 : {
164 0 : updateLayout();
165 0 : }
166 :
167 : // --------------------------------------------------------------------
168 :
169 0 : void TableDesignPane::Resize()
170 : {
171 0 : updateLayout();
172 0 : }
173 :
174 : // --------------------------------------------------------------------
175 :
176 0 : static SfxBindings* getBindings( ViewShellBase& rBase )
177 : {
178 0 : if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() )
179 0 : return &rBase.GetMainViewShell()->GetViewFrame()->GetBindings();
180 : else
181 0 : return 0;
182 : }
183 :
184 : // --------------------------------------------------------------------
185 :
186 0 : static SfxDispatcher* getDispatcher( ViewShellBase& rBase )
187 : {
188 0 : if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() )
189 0 : return rBase.GetMainViewShell()->GetViewFrame()->GetDispatcher();
190 : else
191 0 : return 0;
192 : }
193 :
194 : // --------------------------------------------------------------------
195 :
196 0 : IMPL_LINK_NOARG(TableDesignPane, implValueSetHdl)
197 : {
198 0 : mbStyleSelected = true;
199 0 : if( !mbModal )
200 0 : ApplyStyle();
201 0 : return 0;
202 : }
203 :
204 : // --------------------------------------------------------------------
205 :
206 0 : void TableDesignPane::ApplyStyle()
207 : {
208 : try
209 : {
210 0 : OUString sStyleName;
211 0 : ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() );
212 0 : sal_Int32 nIndex = static_cast< sal_Int32 >( pValueSet->GetSelectItemId() ) - 1;
213 :
214 0 : if( (nIndex >= 0) && (nIndex < mxTableFamily->getCount()) )
215 : {
216 0 : Reference< XNameAccess > xNames( mxTableFamily, UNO_QUERY_THROW );
217 0 : sStyleName = xNames->getElementNames()[nIndex];
218 : }
219 :
220 0 : if( sStyleName.isEmpty() )
221 0 : return;
222 :
223 0 : SdrView* pView = mrBase.GetDrawView();
224 0 : if( mxSelectedTable.is() )
225 : {
226 0 : if( pView )
227 : {
228 0 : SfxRequest aReq( SID_TABLE_STYLE, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool() );
229 0 : aReq.AppendItem( SfxStringItem( SID_TABLE_STYLE, sStyleName ) );
230 :
231 0 : rtl::Reference< sdr::SelectionController > xController( pView->getSelectionController() );
232 0 : if( xController.is() )
233 0 : xController->Execute( aReq );
234 :
235 0 : SfxBindings* pBindings = getBindings( mrBase );
236 0 : if( pBindings )
237 : {
238 0 : pBindings->Invalidate( SID_UNDO );
239 0 : pBindings->Invalidate( SID_REDO );
240 0 : }
241 : }
242 : }
243 : else
244 : {
245 0 : SfxDispatcher* pDispatcher = getDispatcher( mrBase );
246 0 : SfxStringItem aArg( SID_TABLE_STYLE, sStyleName );
247 0 : pDispatcher->Execute(SID_INSERT_TABLE, SFX_CALLMODE_ASYNCHRON, &aArg, 0 );
248 0 : }
249 : }
250 0 : catch( Exception& )
251 : {
252 : OSL_FAIL("TableDesignPane::implValueSetHdl(), exception caught!");
253 : }
254 : }
255 :
256 : // --------------------------------------------------------------------
257 :
258 0 : IMPL_LINK_NOARG(TableDesignPane, implCheckBoxHdl)
259 : {
260 0 : mbOptionsChanged = true;
261 :
262 0 : if( !mbModal )
263 0 : ApplyOptions();
264 :
265 0 : FillDesignPreviewControl();
266 0 : return 0;
267 : }
268 :
269 : // --------------------------------------------------------------------
270 :
271 0 : void TableDesignPane::ApplyOptions()
272 : {
273 : static sal_uInt16 gParamIds[CB_BANDED_COLUMNS-CB_HEADER_ROW+1] =
274 : {
275 : ID_VAL_USEFIRSTROWSTYLE, ID_VAL_USELASTROWSTYLE, ID_VAL_USEBANDINGROWSTYLE,
276 : ID_VAL_USEFIRSTCOLUMNSTYLE, ID_VAL_USELASTCOLUMNSTYLE, ID_VAL_USEBANDINGCOLUMNSTYLE
277 : };
278 :
279 0 : if( mxSelectedTable.is() )
280 : {
281 0 : SfxRequest aReq( SID_TABLE_STYLE_SETTINGS, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool() );
282 :
283 0 : for( sal_uInt16 i = 0; i < (CB_BANDED_COLUMNS-CB_HEADER_ROW+1); ++i )
284 : {
285 0 : aReq.AppendItem( SfxBoolItem( gParamIds[i], static_cast< CheckBox* >( mxControls[CB_HEADER_ROW+i].get() )->IsChecked() ) );
286 : }
287 :
288 0 : SdrView* pView = mrBase.GetDrawView();
289 0 : if( pView )
290 : {
291 0 : rtl::Reference< sdr::SelectionController > xController( pView->getSelectionController() );
292 0 : if( xController.is() )
293 : {
294 0 : xController->Execute( aReq );
295 :
296 0 : SfxBindings* pBindings = getBindings( mrBase );
297 0 : if( pBindings )
298 : {
299 0 : pBindings->Invalidate( SID_UNDO );
300 0 : pBindings->Invalidate( SID_REDO );
301 : }
302 0 : }
303 0 : }
304 : }
305 0 : }
306 :
307 : // --------------------------------------------------------------------
308 :
309 0 : void TableDesignPane::onSelectionChanged()
310 : {
311 0 : Reference< XPropertySet > xNewSelection;
312 :
313 0 : if( mxView.is() ) try
314 : {
315 0 : Reference< XSelectionSupplier > xSel( mxView, UNO_QUERY_THROW );
316 0 : if (xSel.is())
317 : {
318 0 : Any aSel( xSel->getSelection() );
319 0 : Sequence< XShape > xShapeSeq;
320 0 : if( aSel >>= xShapeSeq )
321 : {
322 0 : if( xShapeSeq.getLength() == 1 )
323 0 : aSel <<= xShapeSeq[0];
324 : }
325 : else
326 : {
327 0 : Reference< XShapes > xShapes( aSel, UNO_QUERY );
328 0 : if( xShapes.is() && (xShapes->getCount() == 1) )
329 0 : aSel <<= xShapes->getByIndex(0);
330 : }
331 :
332 0 : Reference< XShapeDescriptor > xDesc( aSel, UNO_QUERY );
333 0 : if( xDesc.is() && ( xDesc->getShapeType() == "com.sun.star.drawing.TableShape" || xDesc->getShapeType() == "com.sun.star.presentation.TableShape" ) )
334 : {
335 0 : xNewSelection = Reference< XPropertySet >::query( xDesc );
336 0 : }
337 0 : }
338 : }
339 0 : catch( Exception& )
340 : {
341 : OSL_FAIL( "sd::TableDesignPane::onSelectionChanged(), Exception caught!" );
342 : }
343 :
344 0 : if( mxSelectedTable != xNewSelection )
345 : {
346 0 : mxSelectedTable = xNewSelection;
347 0 : updateControls();
348 0 : }
349 0 : }
350 :
351 : // --------------------------------------------------------------------
352 :
353 0 : void TableDesignPane::updateLayout()
354 : {
355 0 : ::Size aPaneSize( GetSizePixel() );
356 0 : if(IsVisible() && aPaneSize.Width() > 0)
357 : {
358 0 : Point aOffset( LogicToPixel( Point(3,3), MAP_APPFONT ) );
359 :
360 0 : ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() );
361 :
362 0 : Size aValueSetSize;
363 :
364 0 : if( !mbModal )
365 : {
366 0 : const long nOptionsHeight = mnOrgOffsetY[CB_BANDED_COLUMNS] + mxControls[CB_BANDED_COLUMNS]->GetSizePixel().Height() + aOffset.Y();
367 :
368 0 : const long nStylesHeight = aPaneSize.Height() - nOptionsHeight;
369 :
370 : // set with of controls to size of pane
371 0 : for( sal_Int32 nId = 0; nId < DESIGNPANE_CONTROL_COUNT; ++nId )
372 : {
373 0 : Size aSize( mxControls[nId]->GetSizePixel() );
374 0 : aSize.Width() = aPaneSize.Width() - aOffset.X() - mxControls[nId]->GetPosPixel().X();
375 0 : mxControls[nId]->SetSizePixel( aSize );
376 0 : mxControls[nId]->SetPaintTransparent(sal_True);
377 0 : mxControls[nId]->SetBackground();
378 : }
379 0 : aValueSetSize = Size( pValueSet->GetSizePixel().Width(), nStylesHeight - mxControls[FL_TABLE_STYLES]->GetSizePixel().Height() - mnOrgOffsetY[FL_TABLE_STYLES] );
380 : }
381 : else
382 : {
383 0 : aValueSetSize = pValueSet->GetSizePixel();
384 : }
385 :
386 :
387 : // Calculate the number of rows and columns.
388 0 : if( pValueSet->GetItemCount() > 0 )
389 : {
390 0 : Image aImage = pValueSet->GetItemImage(pValueSet->GetItemId(0));
391 0 : Size aItemSize = pValueSet->CalcItemSizePixel(aImage.GetSizePixel());
392 0 : pValueSet->SetItemWidth( aItemSize.Width() );
393 0 : pValueSet->SetItemHeight( aItemSize.Height() );
394 :
395 0 : aItemSize.Width() += 10;
396 0 : aItemSize.Height() += 10;
397 0 : int nColumnCount = (aValueSetSize.Width() - pValueSet->GetScrollWidth()) / aItemSize.Width();
398 0 : if (nColumnCount < 1)
399 0 : nColumnCount = 1;
400 :
401 0 : int nRowCount = (pValueSet->GetItemCount() + nColumnCount - 1) / nColumnCount;
402 0 : if (nRowCount < 1)
403 0 : nRowCount = 1;
404 :
405 0 : int nVisibleRowCount = (aValueSetSize.Height()+2) / aItemSize.Height();
406 :
407 0 : pValueSet->SetLineCount ( (nRowCount < nVisibleRowCount) ? (sal_uInt16)nRowCount : 0 );
408 :
409 0 : pValueSet->SetColCount ((sal_uInt16)nColumnCount);
410 0 : pValueSet->SetLineCount ((sal_uInt16)nRowCount);
411 :
412 0 : if( !mbModal )
413 : {
414 0 : WinBits nStyle = pValueSet->GetStyle() & ~(WB_VSCROLL);
415 0 : if( nRowCount < nVisibleRowCount )
416 : {
417 0 : aValueSetSize.Height() = nRowCount * aItemSize.Height();
418 : }
419 0 : else if( nRowCount > nVisibleRowCount )
420 : {
421 0 : nStyle |= WB_VSCROLL;
422 : }
423 0 : pValueSet->SetStyle( nStyle );
424 0 : }
425 : }
426 :
427 0 : if( !mbModal )
428 : {
429 0 : pValueSet->SetSizePixel( aValueSetSize );
430 0 : pValueSet->SetBackground( GetSettings().GetStyleSettings().GetWindowColor() );
431 0 : pValueSet->SetColor( GetSettings().GetStyleSettings().GetWindowColor() );
432 :
433 0 : Point aPos( pValueSet->GetPosPixel() );
434 :
435 : // The following line may look like a no-op but without it the
436 : // control is placed off-screen when RTL is active.
437 0 : pValueSet->SetPosPixel(pValueSet->GetPosPixel());
438 :
439 : // shift show options section down
440 0 : const long nOptionsPos = aPos.Y() + aValueSetSize.Height();
441 0 : for( sal_Int32 nId = FL_STYLE_OPTIONS; nId <= CB_BANDED_COLUMNS; ++nId )
442 : {
443 0 : Point aCPos( mxControls[nId]->GetPosPixel() );
444 0 : aCPos.X() = ( nId == FL_STYLE_OPTIONS ? 1 : 2 ) * aOffset.X();
445 0 : aCPos.Y() = mnOrgOffsetY[nId] + nOptionsPos;
446 0 : mxControls[nId]->SetPosPixel( aCPos );
447 : }
448 : }
449 : }
450 :
451 0 : if( !mbModal )
452 0 : SetBackground( GetSettings().GetStyleSettings().GetWindowColor() );
453 0 : }
454 :
455 : // --------------------------------------------------------------------
456 :
457 0 : void TableDesignPane::updateControls()
458 : {
459 : static sal_Bool gDefaults[CB_BANDED_COLUMNS-CB_HEADER_ROW+1] = { sal_True, sal_False, sal_True, sal_False, sal_False, sal_False };
460 :
461 0 : const bool bHasTable = mxSelectedTable.is();
462 0 : const OUString* pPropNames = getPropertyNames();
463 :
464 0 : for( sal_uInt16 i = CB_HEADER_ROW; i <= CB_BANDED_COLUMNS; ++i )
465 : {
466 0 : sal_Bool bUse = gDefaults[i-CB_HEADER_ROW];
467 0 : if( bHasTable ) try
468 : {
469 0 : mxSelectedTable->getPropertyValue( *pPropNames++ ) >>= bUse;
470 : }
471 0 : catch( Exception& )
472 : {
473 : OSL_FAIL("sd::TableDesignPane::updateControls(), exception caught!");
474 : }
475 0 : static_cast< CheckBox* >( mxControls[i].get() )->Check( bUse ? sal_True : sal_False );
476 0 : mxControls[i]->Enable(bHasTable ? sal_True : sal_False );
477 : }
478 :
479 0 : FillDesignPreviewControl();
480 0 : updateLayout();
481 :
482 :
483 0 : sal_uInt16 nSelection = 0;
484 0 : if( mxSelectedTable.is() )
485 : {
486 0 : Reference< XNamed > xNamed( mxSelectedTable->getPropertyValue( "TableTemplate" ), UNO_QUERY );
487 0 : if( xNamed.is() )
488 : {
489 0 : const OUString sStyleName( xNamed->getName() );
490 :
491 0 : Reference< XNameAccess > xNames( mxTableFamily, UNO_QUERY );
492 0 : if( xNames.is() )
493 : {
494 0 : Sequence< OUString > aNames( xNames->getElementNames() );
495 0 : for( sal_Int32 nIndex = 0; nIndex < aNames.getLength(); nIndex++ )
496 : {
497 0 : if( aNames[nIndex] == sStyleName )
498 : {
499 0 : nSelection = (sal_uInt16)nIndex+1;
500 0 : break;
501 : }
502 0 : }
503 0 : }
504 0 : }
505 : }
506 0 : ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() );
507 0 : pValueSet->SelectItem( nSelection );
508 0 : }
509 :
510 : // --------------------------------------------------------------------
511 :
512 0 : void TableDesignPane::addListener()
513 : {
514 0 : Link aLink( LINK(this,TableDesignPane,EventMultiplexerListener) );
515 : mrBase.GetEventMultiplexer()->AddEventListener (
516 : aLink,
517 : tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION
518 : | tools::EventMultiplexerEvent::EID_CURRENT_PAGE
519 : | tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED
520 : | tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED
521 0 : | tools::EventMultiplexerEvent::EID_DISPOSING);
522 0 : }
523 :
524 : // --------------------------------------------------------------------
525 :
526 0 : void TableDesignPane::removeListener()
527 : {
528 0 : Link aLink( LINK(this,TableDesignPane,EventMultiplexerListener) );
529 0 : mrBase.GetEventMultiplexer()->RemoveEventListener( aLink );
530 0 : }
531 :
532 : // --------------------------------------------------------------------
533 :
534 0 : IMPL_LINK(TableDesignPane,EventMultiplexerListener,
535 : tools::EventMultiplexerEvent*,pEvent)
536 : {
537 0 : switch (pEvent->meEventId)
538 : {
539 : case tools::EventMultiplexerEvent::EID_CURRENT_PAGE:
540 : case tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION:
541 0 : onSelectionChanged();
542 0 : break;
543 :
544 : case tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED:
545 0 : mxView = Reference<XDrawView>();
546 0 : onSelectionChanged();
547 0 : break;
548 :
549 : case tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED:
550 0 : mxView = Reference<XDrawView>::query( mrBase.GetController() );
551 0 : onSelectionChanged();
552 0 : break;
553 : }
554 0 : return 0;
555 : }
556 :
557 : // --------------------------------------------------------------------
558 :
559 0 : struct CellInfo
560 : {
561 : Color maCellColor;
562 : Color maTextColor;
563 : SvxBoxItem maBorder;
564 :
565 : explicit CellInfo( const Reference< XStyle >& xStyle );
566 : };
567 :
568 0 : CellInfo::CellInfo( const Reference< XStyle >& xStyle )
569 0 : : maBorder(SDRATTR_TABLE_BORDER)
570 : {
571 0 : SfxStyleSheet* pStyleSheet = SfxUnoStyleSheet::getUnoStyleSheet( xStyle );
572 0 : if( pStyleSheet )
573 : {
574 0 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
575 :
576 : // get style fill color
577 0 : if( !GetDraftFillColor(rSet, maCellColor) )
578 0 : maCellColor.SetColor( COL_TRANSPARENT );
579 :
580 : // get style text color
581 0 : const SvxColorItem* pTextColor = dynamic_cast<const SvxColorItem*>( rSet.GetItem(EE_CHAR_COLOR) );
582 0 : if( pTextColor )
583 0 : maTextColor = pTextColor->GetValue();
584 : else
585 0 : maTextColor.SetColor( COL_TRANSPARENT );
586 :
587 : // get border
588 0 : const SvxBoxItem* pBoxItem = dynamic_cast<const SvxBoxItem*>(rSet.GetItem( SDRATTR_TABLE_BORDER ) );
589 0 : if( pBoxItem )
590 0 : maBorder = *pBoxItem;
591 : }
592 0 : }
593 :
594 : // --------------------------------------------------------------------
595 :
596 : typedef std::vector< boost::shared_ptr< CellInfo > > CellInfoVector;
597 : typedef boost::shared_ptr< CellInfo > CellInfoMatrix[nPreviewColumns][nPreviewRows];
598 :
599 : struct TableStyleSettings
600 : {
601 : bool mbUseFirstRow;
602 : bool mbUseLastRow;
603 : bool mbUseFirstColumn;
604 : bool mbUseLastColumn;
605 : bool mbUseRowBanding;
606 : bool mbUseColumnBanding;
607 :
608 0 : TableStyleSettings()
609 : : mbUseFirstRow(true)
610 : , mbUseLastRow(false)
611 : , mbUseFirstColumn(false)
612 : , mbUseLastColumn(false)
613 : , mbUseRowBanding(true)
614 0 : , mbUseColumnBanding(false) {}
615 : };
616 :
617 : // --------------------------------------------------------------------
618 :
619 0 : static void FillCellInfoVector( const Reference< XIndexAccess >& xTableStyle, CellInfoVector& rVector )
620 : {
621 : DBG_ASSERT( xTableStyle.is() && (xTableStyle->getCount() == sdr::table::style_count ), "sd::FillCellInfoVector(), inavlid table style!" );
622 0 : if( xTableStyle.is() ) try
623 : {
624 0 : rVector.resize( sdr::table::style_count );
625 :
626 0 : for( sal_Int32 nStyle = 0; nStyle < sdr::table::style_count; ++nStyle )
627 : {
628 0 : Reference< XStyle > xStyle( xTableStyle->getByIndex( nStyle ), UNO_QUERY );
629 0 : if( xStyle.is() )
630 0 : rVector[nStyle].reset( new CellInfo( xStyle ) );
631 0 : }
632 : }
633 0 : catch(Exception&)
634 : {
635 : OSL_FAIL("sd::FillCellInfoVector(), exception caught!");
636 : }
637 0 : }
638 :
639 0 : static void FillCellInfoMatrix( const CellInfoVector& rStyle, const TableStyleSettings& rSettings, CellInfoMatrix& rMatrix )
640 : {
641 0 : for( sal_Int32 nRow = 0; nRow < nPreviewColumns; ++nRow )
642 : {
643 0 : const bool bFirstRow = rSettings.mbUseFirstRow && (nRow == 0);
644 0 : const bool bLastRow = rSettings.mbUseLastRow && (nRow == nPreviewColumns - 1);
645 :
646 0 : for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol )
647 : {
648 0 : boost::shared_ptr< CellInfo > xCellInfo;
649 :
650 : // first and last row win first, if used and available
651 0 : if( bFirstRow )
652 : {
653 0 : xCellInfo = rStyle[sdr::table::first_row_style];
654 : }
655 0 : else if( bLastRow )
656 : {
657 0 : xCellInfo = rStyle[sdr::table::last_row_style];
658 : }
659 :
660 0 : if( !xCellInfo.get() )
661 : {
662 : // next come first and last column, if used and available
663 0 : if( rSettings.mbUseFirstColumn && (nCol == 0) )
664 : {
665 0 : xCellInfo = rStyle[sdr::table::first_column_style];
666 : }
667 0 : else if( rSettings.mbUseLastColumn && (nCol == nPreviewColumns-1) )
668 : {
669 0 : xCellInfo = rStyle[sdr::table::last_column_style];
670 : }
671 : }
672 :
673 0 : if( !xCellInfo.get() )
674 : {
675 0 : if( rSettings.mbUseRowBanding )
676 : {
677 0 : if( (nRow & 1) == 0 )
678 : {
679 0 : xCellInfo = rStyle[sdr::table::even_rows_style];
680 : }
681 : else
682 : {
683 0 : xCellInfo = rStyle[sdr::table::odd_rows_style];
684 : }
685 : }
686 : }
687 :
688 0 : if( !xCellInfo.get() )
689 : {
690 0 : if( rSettings.mbUseColumnBanding )
691 : {
692 0 : if( (nCol & 1) == 0 )
693 : {
694 0 : xCellInfo = rStyle[sdr::table::even_columns_style];
695 : }
696 : else
697 : {
698 0 : xCellInfo = rStyle[sdr::table::odd_columns_style];
699 : }
700 : }
701 : }
702 :
703 0 : if( !xCellInfo.get() )
704 : {
705 : // use default cell style if non found yet
706 0 : xCellInfo = rStyle[sdr::table::body_style];
707 : }
708 :
709 0 : rMatrix[nCol][nRow] = xCellInfo;
710 0 : }
711 : }
712 0 : }
713 :
714 : // --------------------------------------------------------------------
715 :
716 0 : const Bitmap CreateDesignPreview( const Reference< XIndexAccess >& xTableStyle, const TableStyleSettings& rSettings, bool bIsPageDark )
717 : {
718 0 : CellInfoVector aCellInfoVector(sdr::table::style_count);
719 0 : FillCellInfoVector( xTableStyle, aCellInfoVector );
720 :
721 0 : CellInfoMatrix aMatrix;
722 0 : FillCellInfoMatrix( aCellInfoVector, rSettings, aMatrix );
723 :
724 : // bbbbbbbbbbbb w = 12 pixel
725 : // bccccccccccb h = 7 pixel
726 : // bccccccccccb b = border color
727 : // bcttttttttcb c = cell color
728 : // bccccccccccb t = text color
729 : // bccccccccccb
730 : // bbbbbbbbbbbb
731 :
732 :
733 0 : const sal_Int32 nCellWidth = 12; // one pixel is shared with the next cell!
734 0 : const sal_Int32 nCellHeight = 7; // one pixel is shared with the next cell!
735 :
736 0 : Bitmap aPreviewBmp( Size( (nCellWidth * nPreviewColumns) - (nPreviewColumns - 1), (nCellHeight * nPreviewRows) - (nPreviewRows - 1)), 24, NULL );
737 0 : BitmapWriteAccess* pAccess = aPreviewBmp.AcquireWriteAccess();
738 0 : if( pAccess )
739 : {
740 0 : pAccess->Erase( Color( bIsPageDark ? COL_BLACK : COL_WHITE ) );
741 :
742 : // first draw cell background and text line previews
743 0 : sal_Int32 nY = 0;
744 : sal_Int32 nRow;
745 0 : for( nRow = 0; nRow < nPreviewRows; ++nRow, nY += nCellHeight-1 )
746 : {
747 0 : sal_Int32 nX = 0;
748 0 : for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol, nX += nCellWidth-1 )
749 : {
750 0 : boost::shared_ptr< CellInfo > xCellInfo( aMatrix[nCol][nRow] );
751 :
752 0 : Color aTextColor( COL_AUTO );
753 0 : if( xCellInfo.get() )
754 : {
755 : // fill cell background
756 0 : const Rectangle aRect( nX, nY, nX + nCellWidth - 1, nY + nCellHeight - 1 );
757 :
758 0 : if( xCellInfo->maCellColor.GetColor() != COL_TRANSPARENT )
759 : {
760 0 : pAccess->SetFillColor( xCellInfo->maCellColor );
761 0 : pAccess->FillRect( aRect );
762 : }
763 :
764 0 : aTextColor = xCellInfo->maTextColor;
765 : }
766 :
767 : // draw text preview line
768 0 : if( aTextColor.GetColor() == COL_AUTO )
769 0 : aTextColor.SetColor( bIsPageDark ? COL_WHITE : COL_BLACK );
770 0 : pAccess->SetLineColor( aTextColor );
771 0 : const Point aPnt1( nX + 2, nY + ((nCellHeight - 1 ) >> 1) );
772 0 : const Point aPnt2( nX + nCellWidth - 3, aPnt1.Y() );
773 0 : pAccess->DrawLine( aPnt1, aPnt2 );
774 0 : }
775 : }
776 :
777 : // second draw border lines
778 0 : nY = 0;
779 0 : for( nRow = 0; nRow < nPreviewRows; ++nRow, nY += nCellHeight-1 )
780 : {
781 0 : sal_Int32 nX = 0;
782 0 : for( sal_Int32 nCol = 0; nCol < nPreviewColumns; ++nCol, nX += nCellWidth-1 )
783 : {
784 0 : boost::shared_ptr< CellInfo > xCellInfo( aMatrix[nCol][nRow] );
785 :
786 0 : if( xCellInfo.get() )
787 : {
788 0 : const Point aPntTL( nX, nY );
789 0 : const Point aPntTR( nX + nCellWidth - 1, nY );
790 0 : const Point aPntBL( nX, nY + nCellHeight - 1 );
791 0 : const Point aPntBR( nX + nCellWidth - 1, nY + nCellHeight - 1 );
792 :
793 0 : sal_Int32 border_diffs[8] = { 0,-1, 0,1, -1,0, 1,0 };
794 0 : sal_Int32* pDiff = &border_diffs[0];
795 :
796 : // draw top border
797 0 : for( sal_uInt16 nLine = 0; nLine < 4; ++nLine )
798 : {
799 0 : const ::editeng::SvxBorderLine* pBorderLine = xCellInfo->maBorder.GetLine(nLine);
800 0 : if( !pBorderLine || ((pBorderLine->GetOutWidth() == 0) && (pBorderLine->GetInWidth()==0)) )
801 0 : continue;
802 :
803 0 : sal_Int32 nBorderCol = nCol + *pDiff++;
804 0 : sal_Int32 nBorderRow = nRow + *pDiff++;
805 0 : if( (nBorderCol >= 0) && (nBorderCol < nPreviewColumns) && (nBorderRow >= 0) && (nBorderRow < nPreviewRows) )
806 : {
807 : // check border
808 0 : boost::shared_ptr< CellInfo > xBorderInfo( aMatrix[nBorderCol][nBorderRow] );
809 0 : if( xBorderInfo.get() )
810 : {
811 0 : const sal_uInt16 nOtherLine = nLine ^ 1;
812 0 : const ::editeng::SvxBorderLine* pBorderLine2 = xBorderInfo->maBorder.GetLine(nOtherLine^1);
813 0 : if( pBorderLine2 && pBorderLine2->HasPriority(*pBorderLine) )
814 0 : continue; // other border line wins
815 0 : }
816 : }
817 :
818 0 : pAccess->SetLineColor( pBorderLine->GetColor() );
819 0 : switch( nLine )
820 : {
821 0 : case 0: pAccess->DrawLine( aPntTL, aPntTR ); break;
822 0 : case 1: pAccess->DrawLine( aPntBL, aPntBR ); break;
823 0 : case 2: pAccess->DrawLine( aPntTL, aPntBL ); break;
824 0 : case 3: pAccess->DrawLine( aPntTR, aPntBR ); break;
825 : }
826 : }
827 : }
828 0 : }
829 : }
830 :
831 0 : aPreviewBmp.ReleaseAccess( pAccess );
832 : }
833 :
834 0 : return aPreviewBmp;
835 : }
836 :
837 0 : void TableDesignPane::FillDesignPreviewControl()
838 : {
839 0 : ValueSet* pValueSet = static_cast< ValueSet* >( mxControls[CT_TABLE_STYLES].get() );
840 :
841 0 : sal_uInt16 nSelectedItem = pValueSet->GetSelectItemId();
842 0 : pValueSet->Clear();
843 : try
844 : {
845 0 : TableStyleSettings aSettings;
846 0 : if( mxSelectedTable.is() )
847 : {
848 0 : aSettings.mbUseFirstRow = static_cast< CheckBox* >(mxControls[CB_HEADER_ROW].get())->IsChecked();
849 0 : aSettings.mbUseLastRow = static_cast< CheckBox* >(mxControls[CB_TOTAL_ROW].get())->IsChecked();
850 0 : aSettings.mbUseRowBanding = static_cast< CheckBox* >(mxControls[CB_BANDED_ROWS].get())->IsChecked();
851 0 : aSettings.mbUseFirstColumn = static_cast< CheckBox* >(mxControls[CB_FIRST_COLUMN].get())->IsChecked();
852 0 : aSettings.mbUseLastColumn = static_cast< CheckBox* >(mxControls[CB_LAST_COLUMN].get())->IsChecked();
853 0 : aSettings.mbUseColumnBanding = static_cast< CheckBox* >(mxControls[CB_BANDED_COLUMNS].get())->IsChecked();
854 : }
855 :
856 0 : sal_Bool bIsPageDark = sal_False;
857 0 : if( mxView.is() )
858 : {
859 0 : Reference< XPropertySet > xPageSet( mxView->getCurrentPage(), UNO_QUERY );
860 0 : if( xPageSet.is() )
861 : {
862 0 : const OUString sIsBackgroundDark( "IsBackgroundDark" );
863 0 : xPageSet->getPropertyValue(sIsBackgroundDark) >>= bIsPageDark;
864 0 : }
865 : }
866 :
867 0 : for( sal_Int32 nIndex = 0; nIndex < mxTableFamily->getCount(); nIndex++ ) try
868 : {
869 0 : Reference< XIndexAccess > xTableStyle( mxTableFamily->getByIndex( nIndex ), UNO_QUERY );
870 0 : if( xTableStyle.is() )
871 0 : pValueSet->InsertItem( sal::static_int_cast<sal_uInt16>( nIndex + 1 ), Image( CreateDesignPreview( xTableStyle, aSettings, bIsPageDark ) ) );
872 : }
873 0 : catch( Exception& )
874 : {
875 : OSL_FAIL("sd::TableDesignPane::FillDesignPreviewControl(), exception caught!");
876 : }
877 : }
878 0 : catch( Exception& )
879 : {
880 : OSL_FAIL("sd::TableDesignPane::FillDesignPreviewControl(), exception caught!");
881 : }
882 0 : pValueSet->SelectItem(nSelectedItem);
883 0 : }
884 :
885 : // ====================================================================
886 :
887 0 : TableDesignDialog::TableDesignDialog(::Window* pParent, ViewShellBase& rBase )
888 0 : : ModalDialog( pParent, SdResId( DLG_TABLEDESIGNPANE ))
889 : {
890 0 : mxFlSep1.reset( new FixedLine( this, SdResId( FL_SEP1 ) ) );
891 0 : mxFlSep2.reset( new FixedLine( this, SdResId( FL_SEP2 ) ) );
892 0 : mxHelpButton.reset( new HelpButton( this, SdResId( BTN_HELP ) ) );
893 0 : mxOkButton.reset( new OKButton( this, SdResId( BTN_OK ) ) );
894 0 : mxCancelButton.reset( new CancelButton( this, SdResId( BTN_CANCEL ) ) );
895 0 : FreeResource();
896 :
897 0 : mpDesignPane.reset( new TableDesignPane( this, rBase, true ) );
898 0 : mpDesignPane->Hide();
899 0 : }
900 :
901 : // --------------------------------------------------------------------
902 :
903 0 : short TableDesignDialog::Execute()
904 : {
905 0 : if( ModalDialog::Execute() )
906 : {
907 0 : if( mpDesignPane->isStyleChanged() )
908 0 : mpDesignPane->ApplyStyle();
909 :
910 0 : if( mpDesignPane->isOptionsChanged() )
911 0 : mpDesignPane->ApplyOptions();
912 0 : return sal_True;
913 : }
914 0 : return sal_False;
915 : }
916 :
917 : // ====================================================================
918 :
919 0 : ::Window * createTableDesignPanel( ::Window* pParent, ViewShellBase& rBase )
920 : {
921 0 : return new TableDesignPane( pParent, rBase, false );
922 : }
923 :
924 : // ====================================================================
925 :
926 0 : void showTableDesignDialog( ::Window* pParent, ViewShellBase& rBase )
927 : {
928 0 : boost::scoped_ptr< TableDesignDialog > xDialog( new TableDesignDialog( pParent, rBase ) );
929 0 : xDialog->Execute();
930 0 : }
931 :
932 :
933 : }
934 :
935 :
936 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
