sd/source/ui/table/TableDesignPane.cxx

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