svx/source/table/svdotable.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: svdotable.cxx,v $
  10  * $Revision: 1.4.18.1 $
  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_svx.hxx"
  33
  34 #define ITEMID_BOX SDRATTR_TABLE_BORDER
  35 #define ITEMID_BOXINFO SDRATTR_TABLE_BORDER_INNER
  36
  37 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  38 #include <com/sun/star/container/XNamed.hpp>
  39 #include <com/sun/star/container/XNameAccess.hpp>
  40 #include <com/sun/star/container/XIndexAccess.hpp>
  41
  42 #include <vcl/canvastools.hxx>
  43 #include <com/sun/star/style/XStyle.hpp>
  44 #include <com/sun/star/beans/XPropertySet.hpp>
  45 #include <basegfx/polygon/b2dpolygontools.hxx>
  46 #include <basegfx/polygon/b2dpolypolygon.hxx>
  47 #include <basegfx/polygon/b2dpolygon.hxx>
  48 #include <svtools/style.hxx>
  49 #include "editstat.hxx"
  50 #include "svx/outlobj.hxx"
  51 #include "svx/svdview.hxx"
  52 #include "svx/sdr/properties/textproperties.hxx"
  53 #include "svx/svdotable.hxx"
  54 #include "svx/svdhdl.hxx"
  55 #include "viewcontactoftableobj.hxx"
  56 #include "svx/svdoutl.hxx"
  57 #include "svx/svddrag.hxx"
  58 #include "svx/svdpagv.hxx"
  59 #include "tablemodel.hxx"
  60 #include "cell.hxx"
  61 #include "svx/xflclit.hxx"
  62 #include "tablelayouter.hxx"
  63 #include "svx/svdetc.hxx"
  64 #include "tablehandles.hxx"
  65 #include "svx/boxitem.hxx"
  66 #include "svx/framelink.hxx"
  67 #include "svx/sdr/table/tabledesign.hxx"
  68 #include "svx/svdundo.hxx"
  69 #include "svdstr.hrc"
  70 #include "svdglob.hxx"
  71 #include "svx/writingmodeitem.hxx"
  72 #include "svx/frmdiritem.hxx"
  73 #include "svx/xflhtit.hxx"
  74 #include "svx/xflftrit.hxx"
  75 #include "svx/xfltrit.hxx"
  76
  77 // -----------------------------------------------------------------------------
  78
  79 using ::rtl::OUString;
  80 using ::com::sun::star::uno::Any;
  81 using ::com::sun::star::uno::Reference;
  82 using ::com::sun::star::uno::XInterface;
  83 using ::com::sun::star::uno::UNO_QUERY;
  84 using ::com::sun::star::uno::UNO_QUERY_THROW;
  85 using ::com::sun::star::uno::Exception;
  86 using ::com::sun::star::container::XIndexAccess;
  87 using ::com::sun::star::style::XStyle;
  88 using ::com::sun::star::table::XTableRows;
  89 using ::com::sun::star::table::XTableColumns;
  90 using ::com::sun::star::table::XTable;
  91 using ::com::sun::star::beans::XPropertySet;
  92 using ::com::sun::star::util::XModifyBroadcaster;
  93 using sdr::properties::TextProperties;
  94 using sdr::properties::BaseProperties;
  95 using namespace ::com::sun::star::text;
  96 using namespace ::com::sun::star::container;
  97 using namespace ::com::sun::star::style;
  98
  99 namespace sdr { namespace table {
 100
 101 class TableProperties : public TextProperties
 102 {
 103 protected:
 104     // create a new itemset
 105     SfxItemSet& CreateObjectSpecificItemSet(SfxItemPool& rPool);
 106
 107 public:
 108     // basic constructor
 109     TableProperties(SdrObject& rObj );
 110
 111     // constructor for copying, but using new object
 112     TableProperties(const TableProperties& rProps, SdrObject& rObj );
 113
 114     // destructor
 115     ~TableProperties();
 116
 117     // Clone() operator, normally just calls the local copy constructor
 118     BaseProperties& Clone(SdrObject& rObj) const;
 119
 120     virtual void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem);
 121 };
 122
 123 TableProperties::TableProperties(SdrObject& rObj)
 124 : TextProperties(rObj)
 125 {
 126 }
 127
 128 TableProperties::TableProperties(const TableProperties& rProps, SdrObject& rObj)
 129 : TextProperties(rProps, rObj)
 130 {
 131 }
 132
 133 TableProperties::~TableProperties()
 134 {
 135 }
 136
 137 BaseProperties& TableProperties::Clone(SdrObject& rObj) const
 138 {
 139     return *(new TableProperties(*this, rObj));
 140 }
 141
 142 void TableProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
 143 {
 144     if( nWhich == SDRATTR_TEXTDIRECTION )
 145         AttributeProperties::ItemChange( nWhich, pNewItem );
 146     else
 147         TextProperties::ItemChange( nWhich, pNewItem );
 148 }
 149
 150 // create a new itemset
 151 SfxItemSet& TableProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
 152 {
 153     return *(new SfxItemSet(rPool,
 154
 155         // range from SdrAttrObj
 156         SDRATTR_START, SDRATTR_SHADOW_LAST,
 157         SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
 158         SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
 159
 160         // range for SdrTableObj
 161         SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
 162
 163         // range from SdrTextObj
 164         EE_ITEMS_START, EE_ITEMS_END,
 165
 166         // end
 167         0, 0));
 168 }
 169
 170 class TableObjectGeoData : public SdrTextObjGeoData
 171 {
 172 public:
 173     Rectangle   maLogicRect;
 174 };
 175
 176 //------------------------------------------------------------------------
 177 // TableStyleSettings
 178 //------------------------------------------------------------------------
 179
 180 TableStyleSettings::TableStyleSettings()
 181 : mbUseFirstRow(true)
 182 , mbUseLastRow(false)
 183 , mbUseFirstColumn(false)
 184 , mbUseLastColumn(false)
 185 , mbUseRowBanding(true)
 186 , mbUseColumnBanding(false)
 187 {
 188 }
 189
 190 TableStyleSettings::TableStyleSettings( const TableStyleSettings& rStyle )
 191 {
 192     (*this) = rStyle;
 193 }
 194
 195 TableStyleSettings& TableStyleSettings::operator=(const TableStyleSettings& rStyle)
 196 {
 197     mbUseFirstRow = rStyle.mbUseFirstRow;
 198     mbUseLastRow = rStyle.mbUseLastRow;
 199     mbUseFirstColumn = rStyle.mbUseFirstColumn;
 200     mbUseLastColumn = rStyle.mbUseLastColumn;
 201     mbUseRowBanding = rStyle.mbUseRowBanding;
 202     mbUseColumnBanding = rStyle.mbUseColumnBanding;
 203     return *this;
 204 }
 205
 206 bool TableStyleSettings::operator==( const TableStyleSettings& rStyle ) const
 207 {
 208     return
 209         (mbUseFirstRow == rStyle.mbUseFirstRow) &&
 210         (mbUseLastRow == rStyle.mbUseLastRow) &&
 211         (mbUseFirstColumn == rStyle.mbUseFirstColumn) &&
 212         (mbUseLastColumn == rStyle.mbUseLastColumn) &&
 213         (mbUseRowBanding == rStyle.mbUseRowBanding) &&
 214         (mbUseColumnBanding == rStyle.mbUseColumnBanding);
 215 }
 216
 217 // -----------------------------------------------------------------------------
 218
 219 class SdrTableObjImpl : public TableDesignUser, public ::cppu::WeakImplHelper1< ::com::sun::star::util::XModifyListener >
 220 {
 221 public:
 222     CellRef     mxActiveCell;
 223     TableModelRef mxTable;
 224     SdrTableObj* mpTableObj;
 225     TableLayouter* mpLayouter;
 226     CellPos maEditPos;
 227     TableStyleSettings maTableStyle;
 228     Reference< XIndexAccess > mxTableStyle;
 229     bool mbModifyPending;
 230 //      sal_Int32 mnSavedEditRowHeight;
 231
 232     void SetModel(SdrModel* pOldModel, SdrModel* pNewModel);
 233
 234     CellRef getCell( const CellPos& rPos ) const;
 235     void LayoutTable( Rectangle& rArea, bool bFitWidth, bool bFitHeight );
 236
 237     bool ApplyCellStyles();
 238     void UpdateCells( Rectangle& rArea );
 239
 240     SdrTableObjImpl();
 241     virtual ~SdrTableObjImpl();
 242
 243     void init( SdrTableObj* pTable, sal_Int32 nColumns, sal_Int32 nRows );
 244     void dispose();
 245
 246     sal_Int32 getColumnCount() const;
 247     sal_Int32 getRowCount() const;
 248
 249     void DragEdge( bool mbHorizontal, int nEdge, sal_Int32 nOffset );
 250
 251     const SfxPoolItem* GetCellItem( const CellPos& rPos, sal_uInt16 nWhich ) const;
 252 //      void GetBorderLines( const CellPos& rPos, const SvxBorderLine** ppLeft, const SvxBorderLine** ppTop, const SvxBorderLine** ppRight, const SvxBorderLine** ppBottom ) const;
 253
 254     void operator=( const SdrTableObjImpl& rSource );
 255
 256     // XModifyListener
 257     virtual void SAL_CALL modified( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException);
 258
 259     // XEventListener
 260     virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException);
 261
 262     void update();
 263
 264     void connectTableStyle();
 265     void disconnectTableStyle();
 266     virtual bool isInUse();
 267
 268     bool UpdateWritingMode();
 269 };
 270
 271 // -----------------------------------------------------------------------------
 272
 273 SdrTableObjImpl::SdrTableObjImpl()
 274 : mpTableObj( 0 )
 275 , mpLayouter( 0 )
 276 {
 277 }
 278
 279 // -----------------------------------------------------------------------------
 280
 281 SdrTableObjImpl::~SdrTableObjImpl()
 282 {
 283 }
 284
 285 // -----------------------------------------------------------------------------
 286
 287 void SdrTableObjImpl::init( SdrTableObj* pTable, sal_Int32 nColumns, sal_Int32 nRows )
 288 {
 289     mpTableObj = pTable;
 290     mxTable = new TableModel( pTable );
 291     mxTable->init( nColumns, nRows );
 292     mpLayouter = new TableLayouter( mxTable );
 293     Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
 294     mxTable->addModifyListener( xListener );
 295     UpdateWritingMode();
 296     LayoutTable( mpTableObj->aRect, true, true );
 297     mpTableObj->maLogicRect = mpTableObj->aRect;
 298 }
 299
 300 // -----------------------------------------------------------------------------
 301
 302 void SdrTableObjImpl::operator=( const SdrTableObjImpl& rSource )
 303 {
 304     if( mpLayouter )
 305     {
 306         delete mpLayouter;
 307         mpLayouter = 0;
 308     }
 309
 310     if( mxTable.is() )
 311     {
 312         Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
 313         mxTable->removeModifyListener( xListener );
 314         mxTable->dispose();
 315         mxTable.clear();
 316     }
 317
 318     maTableStyle = rSource.maTableStyle;
 319
 320     mxTable = new TableModel( mpTableObj, rSource.mxTable );
 321     mpLayouter = new TableLayouter( mxTable );
 322     Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
 323     mxTable->addModifyListener( xListener );
 324     mxTableStyle = rSource.mxTableStyle;
 325     UpdateWritingMode();
 326     ApplyCellStyles();
 327     mpTableObj->aRect = mpTableObj->maLogicRect;
 328     LayoutTable( mpTableObj->aRect, false, false );
 329 }
 330
 331 // -----------------------------------------------------------------------------
 332
 333 void SdrTableObjImpl::SetModel(SdrModel* /*pOldModel*/, SdrModel* pNewModel)
 334 {
 335     // try to find new table style
 336
 337     Reference< XIndexAccess > xNewTableStyle;
 338     if( mxTableStyle.is() ) try
 339     {
 340         const OUString sStyleName( Reference< XNamed >( mxTableStyle, UNO_QUERY_THROW )->getName() );
 341
 342         Reference< XStyleFamiliesSupplier > xSFS( pNewModel->getUnoModel(), UNO_QUERY_THROW );
 343         Reference< XNameAccess > xFamilyNameAccess( xSFS->getStyleFamilies(), UNO_QUERY_THROW );
 344         const rtl::OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM( "table" ) );
 345         Reference< XNameAccess > xTableFamilyAccess( xFamilyNameAccess->getByName( sFamilyName ), UNO_QUERY_THROW );
 346
 347         if( xTableFamilyAccess->hasByName( sStyleName ) )
 348         {
 349             // found table style with the same name
 350             xTableFamilyAccess->getByName( sStyleName ) >>= xNewTableStyle;
 351         }
 352         else
 353         {
 354             // copy or?
 355             Reference< XIndexAccess > xIndexAccess( xTableFamilyAccess, UNO_QUERY_THROW );
 356             xIndexAccess->getByIndex( 0 ) >>= xNewTableStyle;
 357         }
 358     }
 359     catch( Exception& )
 360     {
 361         DBG_ERROR("svx::SdrTableObjImpl::SetModel(), exception caught!");
 362     }
 363
 364     mxTableStyle = xNewTableStyle;
 365
 366     update();
 367 }
 368
 369 // -----------------------------------------------------------------------------
 370
 371 bool SdrTableObjImpl::ApplyCellStyles()
 372 {
 373     if( !mxTable.is() || !mxTable.is() || !mxTableStyle.is() )
 374         return false;
 375
 376     bool bChanges = false;
 377
 378     const sal_Int32 nColCount = getColumnCount();
 379     const sal_Int32 nRowCount = getRowCount();
 380
 381     const TableStyleSettings& rStyle = maTableStyle;
 382
 383     CellPos aPos;
 384     for( aPos.mnRow = 0; aPos.mnRow < nRowCount; ++aPos.mnRow )
 385     {
 386         const bool bFirstRow = (aPos.mnRow == 0) && rStyle.mbUseFirstRow;
 387         const bool bLastRow = (aPos.mnRow == nRowCount-1) && rStyle.mbUseLastRow;
 388
 389         for( aPos.mnCol = 0; aPos.mnCol < nColCount; ++aPos.mnCol )
 390         {
 391             Reference< XStyle > xStyle;
 392
 393             // first and last row win first, if used and available
 394             if( bFirstRow )
 395             {
 396                 mxTableStyle->getByIndex(first_row_style) >>= xStyle;
 397             }
 398             else if( bLastRow )
 399             {
 400                 mxTableStyle->getByIndex(last_row_style) >>= xStyle;
 401             }
 402
 403             if( !xStyle.is() )
 404             {
 405                 // next come first and last column, if used and available
 406                 if( rStyle.mbUseFirstColumn && (aPos.mnCol == 0)  )
 407                 {
 408                     mxTableStyle->getByIndex(first_column_style) >>= xStyle;
 409                 }
 410                 else if( rStyle.mbUseLastColumn && (aPos.mnCol == nColCount-1) )
 411                 {
 412                     mxTableStyle->getByIndex(last_column_style) >>= xStyle;
 413                 }
 414             }
 415
 416             if( !xStyle.is() && rStyle.mbUseRowBanding )
 417             {
 418                 if( (aPos.mnRow & 1) == 0 )
 419                 {
 420                     mxTableStyle->getByIndex(even_rows_style) >>= xStyle;
 421                 }
 422                 else
 423                 {
 424                     mxTableStyle->getByIndex(odd_rows_style) >>= xStyle;
 425                 }
 426             }
 427
 428             if( !xStyle.is() && rStyle.mbUseColumnBanding )
 429             {
 430                 if( (aPos.mnCol & 1) == 0 )
 431                 {
 432                     mxTableStyle->getByIndex(even_columns_style) >>= xStyle;
 433                 }
 434                 else
 435                 {
 436                     mxTableStyle->getByIndex(odd_columns_style) >>= xStyle;
 437                 }
 438             }
 439
 440             if( !xStyle.is() )
 441             {
 442                 // use default cell style if non found yet
 443                 mxTableStyle->getByIndex(body_style) >>= xStyle;
 444             }
 445
 446
 447             if( xStyle.is() )
 448             {
 449                 SfxUnoStyleSheet* pStyle = SfxUnoStyleSheet::getUnoStyleSheet(xStyle);
 450
 451                 if( pStyle )
 452                 {
 453                     CellRef xCell( getCell( aPos ) );
 454                     if( xCell.is() && ( xCell->GetStyleSheet() != pStyle ) )
 455                     {
 456                         bChanges = true;
 457                         xCell->SetStyleSheet( pStyle, sal_True );
 458                     }
 459                 }
 460             }
 461         }
 462     }
 463
 464     return bChanges;
 465 }
 466
 467 // -----------------------------------------------------------------------------
 468
 469 void SdrTableObjImpl::dispose()
 470 {
 471     if( mxTable.is() )
 472         mxTable->dispose();
 473 }
 474
 475 // -----------------------------------------------------------------------------
 476
 477 void SdrTableObjImpl::DragEdge( bool mbHorizontal, int nEdge, sal_Int32 nOffset )
 478 {
 479     if( (nEdge > 0) && mxTable.is()) try
 480     {
 481         const OUString sSize( RTL_CONSTASCII_USTRINGPARAM( "Size" ) );
 482         nEdge--;
 483         if( mbHorizontal )
 484         {
 485             if( (nEdge >= 0) && (nEdge < getRowCount()) )
 486             {
 487                 sal_Int32 nHeigth = mpLayouter->getRowHeight( nEdge );
 488                 nHeigth += nOffset;
 489                 Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW );
 490                 Reference< XPropertySet > xRowSet( xRows->getByIndex( nEdge ), UNO_QUERY_THROW );
 491                 xRowSet->setPropertyValue( sSize, Any( nHeigth ) );
 492             }
 493         }
 494         else
 495         {
 496             if( (nEdge >= 0) && (nEdge < getColumnCount()) )
 497             {
 498                 sal_Int32 nWidth = mpLayouter->getColumnWidth( nEdge );
 499                 nWidth += nOffset;
 500
 501                 Reference< XIndexAccess > xCols( mxTable->getColumns(), UNO_QUERY_THROW );
 502                 Reference< XPropertySet > xColSet( xCols->getByIndex( nEdge ), UNO_QUERY_THROW );
 503                 xColSet->setPropertyValue( sSize, Any( nWidth ) );
 504
 505                 if( nEdge > 0 && nEdge < mxTable->getColumnCount() )
 506                 {
 507                     const bool bRTL = mpLayouter->GetWritingMode() == WritingMode_RL_TB;
 508
 509                     if( bRTL )
 510                         nEdge--;
 511                     else
 512                         nEdge++;
 513
 514                     if( (bRTL && (nEdge >= 0)) || (!bRTL && (nEdge < mxTable->getColumnCount())) )
 515                     {
 516                         nWidth = mpLayouter->getColumnWidth( nEdge );
 517                         nWidth = std::max( (sal_Int32)(nWidth - nOffset), (sal_Int32)0 );
 518
 519                         xColSet = Reference< XPropertySet >( xCols->getByIndex( nEdge ), UNO_QUERY_THROW );
 520                         xColSet->setPropertyValue( sSize, Any( nWidth ) );
 521                     }
 522                 }
 523             }
 524         }
 525     }
 526     catch( Exception& )
 527     {
 528         DBG_ERROR( "svx::SdrTableObjImpl::DragEdge(), exception caught!" );
 529     }
 530 }
 531
 532 // -----------------------------------------------------------------------------
 533 // XModifyListener
 534 // -----------------------------------------------------------------------------
 535
 536 void SAL_CALL SdrTableObjImpl::modified( const ::com::sun::star::lang::EventObject& /*aEvent*/ ) throw (::com::sun::star::uno::RuntimeException)
 537 {
 538     update();
 539 }
 540
 541 void SdrTableObjImpl::update()
 542 {
 543     // source can be the table model itself or the assigned table template
 544     TableModelNotifyGuard aGuard( mxTable.get() );
 545     if( mpTableObj )
 546     {
 547         if( (maEditPos.mnRow >= getRowCount()) || (maEditPos.mnCol >= getColumnCount()) || (getCell( maEditPos ) != mxActiveCell) )
 548         {
 549             if(maEditPos.mnRow >= getRowCount())
 550                 maEditPos.mnRow = getRowCount()-1;
 551
 552             if(maEditPos.mnCol >= getColumnCount())
 553                 maEditPos.mnCol = getColumnCount()-1;
 554
 555             mpTableObj->setActiveCell( maEditPos );
 556         }
 557
 558         ApplyCellStyles();
 559
 560         mpTableObj->aRect = mpTableObj->maLogicRect;
 561         LayoutTable( mpTableObj->aRect, false, false );
 562
 563         mpTableObj->SetRectsDirty();
 564         mpTableObj->ActionChanged();
 565         mpTableObj->BroadcastObjectChange();
 566     }
 567 }
 568
 569 // -----------------------------------------------------------------------------
 570
 571 void SdrTableObjImpl::connectTableStyle()
 572 {
 573     if( mxTableStyle.is() )
 574     {
 575         Reference< XModifyBroadcaster > xBroadcaster( mxTableStyle, UNO_QUERY );
 576         if( xBroadcaster.is() )
 577         {
 578             Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
 579             xBroadcaster->addModifyListener( xListener );
 580         }
 581     }
 582 }
 583
 584 // -----------------------------------------------------------------------------
 585
 586 void SdrTableObjImpl::disconnectTableStyle()
 587 {
 588     if( mxTableStyle.is() )
 589     {
 590         Reference< XModifyBroadcaster > xBroadcaster( mxTableStyle, UNO_QUERY );
 591         if( xBroadcaster.is() )
 592         {
 593             Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
 594             xBroadcaster->removeModifyListener( xListener );
 595         }
 596     }
 597 }
 598
 599 // -----------------------------------------------------------------------------
 600
 601 bool SdrTableObjImpl::isInUse()
 602 {
 603     return mpTableObj && mpTableObj->IsInserted();
 604 }
 605
 606 // -----------------------------------------------------------------------------
 607 // XEventListener
 608 // -----------------------------------------------------------------------------
 609
 610 void SAL_CALL SdrTableObjImpl::disposing( const ::com::sun::star::lang::EventObject& /*Source*/ ) throw (::com::sun::star::uno::RuntimeException)
 611 {
 612     mxActiveCell.clear();
 613     mxTable.clear();
 614     if( mpLayouter )
 615     {
 616         delete mpLayouter;
 617         mpLayouter = 0;
 618     }
 619     mpTableObj = 0;
 620 }
 621
 622 // -----------------------------------------------------------------------------
 623
 624 CellRef SdrTableObjImpl::getCell(  const CellPos& rPos  ) const
 625 {
 626     CellRef xCell;
 627     if( mxTable.is() ) try
 628     {
 629         xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) );
 630     }
 631     catch( Exception& )
 632     {
 633         DBG_ERROR( "svx::SdrTableObjImpl::getCell(), exception caught!" );
 634     }
 635     return xCell;
 636 }
 637
 638 // -----------------------------------------------------------------------------
 639
 640 sal_Int32 SdrTableObjImpl::getColumnCount() const
 641 {
 642     return mxTable.is() ? mxTable->getColumnCount() : 0;
 643 }
 644
 645 // -----------------------------------------------------------------------------
 646
 647 sal_Int32 SdrTableObjImpl::getRowCount() const
 648 {
 649     return mxTable.is() ? mxTable->getRowCount() : 0;
 650 }
 651
 652 // -----------------------------------------------------------------------------
 653
 654 void SdrTableObjImpl::LayoutTable( Rectangle& rArea, bool bFitWidth, bool bFitHeight )
 655 {
 656     if( mpLayouter && mpTableObj->GetModel() )
 657     {
 658         TableModelNotifyGuard aGuard( mxTable.get() );
 659         mpLayouter->LayoutTable( rArea, bFitWidth, bFitHeight );
 660     }
 661 }
 662
 663 // -----------------------------------------------------------------------------
 664
 665 bool SdrTableObjImpl::UpdateWritingMode()
 666 {
 667     if( mpTableObj && mpLayouter )
 668     {
 669         WritingMode eWritingMode = (WritingMode)static_cast< const SvxWritingModeItem& >( mpTableObj->GetObjectItem( SDRATTR_TEXTDIRECTION ) ).GetValue();
 670
 671         if( eWritingMode != WritingMode_TB_RL )
 672         {
 673             if( static_cast< const SvxFrameDirectionItem& >( mpTableObj->GetObjectItem( EE_PARA_WRITINGDIR ) ).GetValue() == FRMDIR_HORI_LEFT_TOP )
 674                 eWritingMode = WritingMode_LR_TB;
 675             else
 676                 eWritingMode = WritingMode_RL_TB;
 677         }
 678
 679         if( eWritingMode != mpLayouter->GetWritingMode() )
 680         {
 681             mpLayouter->SetWritingMode( eWritingMode );
 682             return true;
 683         }
 684     }
 685     return false;
 686 }
 687
 688 // -----------------------------------------------------------------------------
 689
 690 void SdrTableObjImpl::UpdateCells( Rectangle& rArea )
 691 {
 692     if( mpLayouter && mxTable.is() )
 693     {
 694         TableModelNotifyGuard aGuard( mxTable.get() );
 695         mpLayouter->updateCells( rArea );
 696         mxTable->setModified(sal_True);
 697     }
 698 }
 699
 700 // -----------------------------------------------------------------------------
 701
 702 const SfxPoolItem* SdrTableObjImpl::GetCellItem( const CellPos& rPos, sal_uInt16 nWhich ) const
 703 {
 704     CellRef xCell( getCell( rPos  ) );
 705     if( xCell.is() )
 706         return xCell->GetItemSet().GetItem( nWhich );
 707     else
 708         return 0;
 709 }
 710
 711 // -----------------------------------------------------------------------------
 712 // BaseProperties section
 713 // -----------------------------------------------------------------------------
 714
 715 sdr::properties::BaseProperties* SdrTableObj::CreateObjectSpecificProperties()
 716 {
 717     return new TableProperties(*this);
 718 }
 719
 720 // -----------------------------------------------------------------------------
 721 // DrawContact section
 722 // -----------------------------------------------------------------------------
 723
 724 sdr::contact::ViewContact* SdrTableObj::CreateObjectSpecificViewContact()
 725 {
 726     return new sdr::contact::ViewContactOfTableObj(*this);
 727 }
 728
 729 // --------------------------------------------------------------------
 730
 731 TYPEINIT1(SdrTableObj,SdrTextObj);
 732
 733 // --------------------------------------------------------------------
 734
 735 SdrTableObj::SdrTableObj(SdrModel* _pModel)
 736 {
 737     pModel = _pModel;
 738     init( 1, 1 );
 739 }
 740
 741 // --------------------------------------------------------------------
 742
 743 SdrTableObj::SdrTableObj(SdrModel* _pModel, const ::Rectangle& rNewRect, sal_Int32 nColumns, sal_Int32 nRows)
 744 : SdrTextObj( rNewRect )
 745 , maLogicRect( rNewRect )
 746 {
 747     pModel = _pModel;
 748
 749     if( nColumns <= 0 )
 750         nColumns = 1;
 751
 752     if( nRows <= 0 )
 753         nRows = 1;
 754
 755     init( nColumns, nRows );
 756 }
 757
 758 // --------------------------------------------------------------------
 759
 760 void SdrTableObj::init( sal_Int32 nColumns, sal_Int32 nRows )
 761 {
 762     bClosedObj = TRUE;
 763
 764     mpImpl = new SdrTableObjImpl;
 765     mpImpl->acquire();
 766     mpImpl->init( this, nColumns, nRows );
 767 }
 768
 769 // --------------------------------------------------------------------
 770
 771 SdrTableObj::~SdrTableObj()
 772 {
 773     mpImpl->dispose();
 774     mpImpl->release();
 775 }
 776
 777 // --------------------------------------------------------------------
 778 // table stuff
 779 // --------------------------------------------------------------------
 780
 781 Reference< XTable > SdrTableObj::getTable() const
 782 {
 783     return Reference< XTable >( mpImpl->mxTable.get() );
 784 }
 785
 786 // --------------------------------------------------------------------
 787
 788 bool SdrTableObj::isValid( const CellPos& rPos ) const
 789 {
 790     return (rPos.mnCol >= 0) && (rPos.mnCol < mpImpl->getColumnCount()) && (rPos.mnRow >= 0) && (rPos.mnRow < mpImpl->getRowCount());
 791 }
 792
 793 // --------------------------------------------------------------------
 794
 795 CellPos SdrTableObj::getFirstCell() const
 796 {
 797     return CellPos( 0,0 );
 798 }
 799
 800 // --------------------------------------------------------------------
 801
 802 CellPos SdrTableObj::getLastCell() const
 803 {
 804     CellPos aPos;
 805     if( mpImpl->mxTable.is() )
 806     {
 807         aPos.mnCol = mpImpl->getColumnCount()-1;
 808         aPos.mnRow = mpImpl->getRowCount()-1;
 809     }
 810     return aPos;
 811 }
 812
 813 // --------------------------------------------------------------------
 814
 815 CellPos SdrTableObj::getLeftCell( const CellPos& rPos, bool bEdgeTravel ) const
 816 {
 817     switch( GetWritingMode() )
 818     {
 819     default:
 820     case WritingMode_LR_TB:
 821         return getPreviousCell( rPos, bEdgeTravel );
 822     case WritingMode_RL_TB:
 823         return getNextCell( rPos, bEdgeTravel );
 824     case WritingMode_TB_RL:
 825         return getPreviousRow( rPos, bEdgeTravel );
 826     }
 827 }
 828
 829 // --------------------------------------------------------------------
 830
 831 CellPos SdrTableObj::getRightCell( const CellPos& rPos, bool bEdgeTravel  ) const
 832 {
 833     switch( GetWritingMode() )
 834     {
 835     default:
 836     case WritingMode_LR_TB:
 837         return getNextCell( rPos, bEdgeTravel );
 838     case WritingMode_RL_TB:
 839         return getPreviousCell( rPos, bEdgeTravel );
 840     case WritingMode_TB_RL:
 841         return getNextRow( rPos, bEdgeTravel );
 842     }
 843 }
 844
 845 // --------------------------------------------------------------------
 846
 847 CellPos SdrTableObj::getUpCell( const CellPos& rPos, bool bEdgeTravel ) const
 848 {
 849     switch( GetWritingMode() )
 850     {
 851     default:
 852     case WritingMode_LR_TB:
 853     case WritingMode_RL_TB:
 854         return getPreviousRow( rPos, bEdgeTravel );
 855     case WritingMode_TB_RL:
 856         return getPreviousCell( rPos, bEdgeTravel );
 857     }
 858 }
 859
 860 // --------------------------------------------------------------------
 861
 862 CellPos SdrTableObj::getDownCell( const CellPos& rPos, bool bEdgeTravel ) const
 863 {
 864     switch( GetWritingMode() )
 865     {
 866     default:
 867     case WritingMode_LR_TB:
 868     case WritingMode_RL_TB:
 869         return getNextRow( rPos, bEdgeTravel );
 870     case WritingMode_TB_RL:
 871         return getNextCell( rPos, bEdgeTravel );
 872     }
 873 }
 874
 875 // --------------------------------------------------------------------
 876
 877 CellPos SdrTableObj::getPreviousCell( const CellPos& rPos, bool bEdgeTravel ) const
 878 {
 879     CellPos aPos( rPos );
 880     if( mpImpl )
 881     {
 882         CellRef xCell( mpImpl->getCell( aPos ) );
 883         if( xCell.is() && xCell->isMerged() )
 884         {
 885             sal_Int32 nTemp = 0;
 886             findMergeOrigin( mpImpl->mxTable.get(), aPos.mnCol, aPos.mnRow, aPos.mnCol, nTemp );
 887         }
 888
 889         if( aPos.mnCol > 0 )
 890         {
 891             --aPos.mnCol;
 892         }
 893
 894         else if( bEdgeTravel && (aPos.mnRow > 0) )
 895         {
 896             aPos.mnCol = mpImpl->mxTable->getColumnCount()-1;
 897             --aPos.mnRow;
 898         }
 899     }
 900     return aPos;
 901 }
 902
 903 // --------------------------------------------------------------------
 904
 905 CellPos SdrTableObj::getNextCell( const CellPos& rPos, bool bEdgeTravel ) const
 906 {
 907     CellPos aPos( rPos );
 908     if( mpImpl )
 909     {
 910         CellRef xCell( mpImpl->getCell( aPos ) );
 911         if( xCell.is() )
 912         {
 913             if( xCell->isMerged() )
 914             {
 915                 findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, aPos.mnCol, aPos.mnRow );
 916
 917                 xCell = mpImpl->getCell(aPos);
 918
 919                 if( xCell.is() )
 920                 {
 921                     aPos.mnCol += xCell->getColumnSpan();
 922                     aPos.mnRow = rPos.mnRow;
 923                 }
 924             }
 925             else
 926             {
 927                 aPos.mnCol += xCell->getColumnSpan();
 928             }
 929
 930             if( aPos.mnCol < mpImpl->mxTable->getColumnCount() )
 931                 return aPos;
 932
 933             if( bEdgeTravel && ((aPos.mnRow + 1) < mpImpl->getRowCount()) )
 934             {
 935                 aPos.mnCol = 0;
 936                 aPos.mnRow += 1;
 937                 return aPos;
 938             }
 939         }
 940     }
 941
 942     // last cell reached, no traveling possible
 943     return rPos;
 944 }
 945
 946 // --------------------------------------------------------------------
 947
 948 CellPos SdrTableObj::getPreviousRow( const CellPos& rPos, bool bEdgeTravel ) const
 949 {
 950     CellPos aPos( rPos );
 951     if( mpImpl )
 952     {
 953         CellRef xCell( mpImpl->getCell( aPos ) );
 954         if( xCell.is() )
 955         {
 956             if( xCell->isMerged() )
 957             {
 958                 sal_Int32 nTemp = 0;
 959                 findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, nTemp, aPos.mnRow );
 960             }
 961         }
 962
 963         if( aPos.mnRow > 0 )
 964         {
 965             --aPos.mnRow;
 966         }
 967         else if( bEdgeTravel && (aPos.mnCol > 0) )
 968         {
 969             aPos.mnRow = mpImpl->mxTable->getRowCount()-1;
 970             --aPos.mnCol;
 971         }
 972     }
 973     return aPos;
 974 }
 975
 976 // --------------------------------------------------------------------
 977
 978 CellPos SdrTableObj::getNextRow( const CellPos& rPos, bool bEdgeTravel ) const
 979 {
 980     CellPos aPos( rPos );
 981
 982     if( mpImpl )
 983     {
 984         CellRef xCell( mpImpl->getCell( rPos ) );
 985         if( xCell.is() )
 986         {
 987             if( xCell->isMerged() )
 988             {
 989                 findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, aPos.mnCol, aPos.mnRow );
 990                 xCell = mpImpl->getCell(aPos);
 991                 aPos.mnCol = rPos.mnCol;
 992             }
 993
 994             if( xCell.is() )
 995                 aPos.mnRow += xCell->getRowSpan();
 996
 997             if( aPos.mnRow < mpImpl->mxTable->getRowCount() )
 998                 return aPos;
 999
1000             if( bEdgeTravel && (aPos.mnCol + 1) < mpImpl->mxTable->getColumnCount() )
1001             {
1002                 aPos.mnRow = 0;
1003                 aPos.mnCol += 1;
1004
1005                 while( aPos.mnCol < mpImpl->mxTable->getColumnCount() )
1006                 {
1007                     xCell = mpImpl->getCell( aPos );
1008                     if( xCell.is() && !xCell->isMerged() )
1009                         return aPos;
1010                     aPos.mnCol += 1;
1011                 }
1012             }
1013         }
1014     }
1015
1016     // last position reached, no more traveling possible
1017     return rPos;
1018 }
1019
1020 // --------------------------------------------------------------------
1021
1022 const TableStyleSettings& SdrTableObj::getTableStyleSettings() const
1023 {
1024     if( mpImpl )
1025     {
1026         return mpImpl->maTableStyle;
1027     }
1028     else
1029     {
1030         static TableStyleSettings aTmp;
1031         return aTmp;
1032     }
1033 }
1034
1035 // --------------------------------------------------------------------
1036
1037 void SdrTableObj::setTableStyleSettings( const TableStyleSettings& rStyle )
1038 {
1039     if( mpImpl )
1040     {
1041         mpImpl->maTableStyle = rStyle;
1042         mpImpl->update();
1043     }
1044 }
1045
1046 // --------------------------------------------------------------------
1047
1048 TableHitKind SdrTableObj::CheckTableHit( const Point& rPos, sal_Int32& rnX, sal_Int32& rnY, int nTol ) const
1049 {
1050     if( !mpImpl || !mpImpl->mxTable.is() )
1051         return SDRTABLEHIT_NONE;
1052
1053     rnX = 0;
1054     rnY = 0;
1055
1056     const sal_Int32 nColCount = mpImpl->getColumnCount();
1057     const sal_Int32 nRowCount = mpImpl->getRowCount();
1058
1059     sal_Int32 nX = rPos.X() + nTol - aRect.nLeft;
1060     sal_Int32 nY = rPos.Y() + nTol - aRect.nTop;
1061
1062     if( (nX < 0) || (nX > (aRect.GetWidth() + nTol)) || (nY < 0) || (nY > (aRect.GetHeight() + nTol) ) )
1063         return SDRTABLEHIT_NONE;
1064
1065     // get vertical edge number and check for a hit
1066     const bool bRTL = GetWritingMode() == WritingMode_RL_TB;
1067     bool bVrtHit = false;
1068     if( nX >= 0 )
1069     {
1070         if( !bRTL )
1071         {
1072             while( rnX <= nColCount )
1073             {
1074                 if( nX <= (2*nTol) )
1075                 {
1076                     bVrtHit = true;
1077                     break;
1078                 }
1079
1080                 if( rnX == nColCount )
1081                     break;
1082
1083                 nX -= mpImpl->mpLayouter->getColumnWidth( rnX );
1084                 if( nX < 0 )
1085                     break;
1086                 rnX++;
1087             }
1088         }
1089         else
1090         {
1091             rnX = nColCount;
1092             while( rnX >= 0 )
1093             {
1094                 if( nX <= (2*nTol) )
1095                 {
1096                     bVrtHit = true;
1097                     break;
1098                 }
1099
1100                 if( rnX == 0 )
1101                     break;
1102
1103                 rnX--;
1104                 nX -= mpImpl->mpLayouter->getColumnWidth( rnX );
1105                 if( nX < 0 )
1106                     break;
1107             }
1108         }
1109     }
1110
1111     // rnX is now the edge number left to the pointer, if it was hit bHrzHit is also true
1112
1113     // get vertical edge number and check for a hit
1114     bool bHrzHit = false;
1115     if( nY >= 0 )
1116     {
1117         while( rnY <= nRowCount )
1118         {
1119             if( nY <= (2*nTol) )
1120             {
1121                 bHrzHit = true;
1122                 break;
1123             }
1124
1125             if( rnY == nRowCount )
1126                 break;
1127
1128             nY -= mpImpl->mpLayouter->getRowHeight(rnY);
1129             if( nY < 0 )
1130                 break;
1131             rnY++;
1132         }
1133     }
1134
1135     // rnY is now the edge number above the pointer, if it was hit bVrtHit is also true
1136
1137     if( bVrtHit && mpImpl->mpLayouter->isEdgeVisible( rnX, rnY, false ) )
1138         return SDRTABLEHIT_VERTICAL_BORDER;
1139
1140     if( bHrzHit && mpImpl->mpLayouter->isEdgeVisible( rnX, rnY, true ) )
1141         return SDRTABLEHIT_HORIZONTAL_BORDER;
1142
1143     CellRef xCell( mpImpl->getCell( CellPos( rnX, rnY ) ) );
1144     if( xCell.is() && xCell->isMerged() )
1145         findMergeOrigin( mpImpl->mxTable.get(), rnX, rnY, rnX, rnY );
1146
1147     if( xCell.is() )
1148     {
1149         nX += mpImpl->mpLayouter->getColumnWidth( rnX );
1150         if( nX < xCell->GetTextLeftDistance() )
1151             return SDRTABLEHIT_CELL;
1152     }
1153
1154     return SDRTABLEHIT_CELLTEXTAREA;
1155 }
1156
1157 const SfxItemSet& SdrTableObj::GetActiveCellItemSet() const
1158 {
1159     return getActiveCell()->GetItemSet();
1160 }
1161
1162 // --------------------------------------------------------------------
1163
1164 void SdrTableObj::InsertRows( sal_Int32 nIndex, sal_Int32 nCount /*= 1*/ )
1165 {
1166     if( mpImpl->mxTable.is() ) try
1167     {
1168         Reference< XTableRows > xRows( mpImpl->mxTable->getRows(), UNO_QUERY_THROW );
1169         xRows->insertByIndex( nIndex, nCount );
1170     }
1171     catch( Exception& )
1172     {
1173         DBG_ERROR("SdrTableObj::InsertRows(), exception caught!");
1174     }
1175 }
1176
1177 // --------------------------------------------------------------------
1178
1179 void SdrTableObj::InsertColumns( sal_Int32 nIndex, sal_Int32 nCount /*= 1*/ )
1180 {
1181     if( mpImpl->mxTable.is() ) try
1182     {
1183         Reference< XTableColumns > xColumns( mpImpl->mxTable->getColumns(), UNO_QUERY_THROW );
1184         xColumns->insertByIndex( nIndex, nCount );
1185     }
1186     catch( Exception& )
1187     {
1188         DBG_ERROR("SdrTableObj::InsertColumns(), exception caught!");
1189     }
1190 }
1191
1192 // --------------------------------------------------------------------
1193
1194 void SdrTableObj::DeleteRows( sal_Int32 nIndex, sal_Int32 nCount /*= 1*/ )
1195 {
1196     if( mpImpl->mxTable.is() ) try
1197     {
1198         Reference< XTableRows > xRows( mpImpl->mxTable->getRows(), UNO_QUERY_THROW );
1199         xRows->removeByIndex( nIndex, nCount );
1200     }
1201     catch( Exception& )
1202     {
1203         DBG_ERROR("SdrTableObj::DeleteRows(), exception caught!");
1204     }
1205 }
1206
1207 // --------------------------------------------------------------------
1208
1209 void SdrTableObj::DeleteColumns( sal_Int32 nIndex, sal_Int32 nCount /*= 1*/ )
1210 {
1211     if( mpImpl->mxTable.is() ) try
1212     {
1213         Reference< XTableColumns > xColumns( mpImpl->mxTable->getColumns(), UNO_QUERY_THROW );
1214         xColumns->removeByIndex( nIndex, nCount );
1215     }
1216     catch( Exception& )
1217     {
1218         DBG_ERROR("SdrTableObj::DeleteColumns(), exception caught!");
1219     }
1220 }
1221
1222 // --------------------------------------------------------------------
1223
1224 void SdrTableObj::setTableStyle( const Reference< XIndexAccess >& xTableStyle )
1225 {
1226     if( mpImpl && (mpImpl->mxTableStyle != xTableStyle) )
1227     {
1228         mpImpl->disconnectTableStyle();
1229         mpImpl->mxTableStyle = xTableStyle;
1230         mpImpl->connectTableStyle();
1231         mpImpl->update();
1232     }
1233 }
1234
1235 // --------------------------------------------------------------------
1236
1237 const Reference< XIndexAccess >& SdrTableObj::getTableStyle() const
1238 {
1239     if( mpImpl )
1240     {
1241         return mpImpl->mxTableStyle;
1242     }
1243     else
1244     {
1245         static Reference< XIndexAccess > aTmp;
1246         return aTmp;
1247     }
1248 }
1249
1250 // --------------------------------------------------------------------
1251 // text stuff
1252 // --------------------------------------------------------------------
1253
1254 /** returns the currently active text. */
1255 SdrText* SdrTableObj::getActiveText() const
1256 {
1257     return dynamic_cast< SdrText* >( getActiveCell().get() );
1258 }
1259
1260 // --------------------------------------------------------------------
1261
1262 /** returns the nth available text. */
1263 SdrText* SdrTableObj::getText( sal_Int32 nIndex ) const
1264 {
1265     if( mpImpl->mxTable.is() )
1266     {
1267         const sal_Int32 nColCount = mpImpl->getColumnCount();
1268         if( nColCount )
1269         {
1270             CellPos aPos( nIndex % nColCount, nIndex / nColCount );
1271
1272             CellRef xCell( mpImpl->getCell( aPos ) );
1273             return dynamic_cast< SdrText* >( xCell.get() );
1274         }
1275     }
1276     return 0;
1277 }
1278
1279 // --------------------------------------------------------------------
1280
1281 /** returns the number of texts available for this object. */
1282 sal_Int32 SdrTableObj::getTextCount() const
1283 {
1284     if( mpImpl->mxTable.is() )
1285     {
1286         const sal_Int32 nColCount = mpImpl->getColumnCount();
1287         const sal_Int32 nRowCount = mpImpl->getRowCount();
1288
1289         return nColCount * nRowCount;
1290     }
1291     else
1292     {
1293         return 0;
1294     }
1295 }
1296
1297 // --------------------------------------------------------------------
1298
1299 /** changes the current active text */
1300 void SdrTableObj::setActiveText( sal_Int32 nIndex )
1301 {
1302     if( mpImpl && mpImpl->mxTable.is() )
1303     {
1304         const sal_Int32 nColCount = mpImpl->mxTable->getColumnCount();
1305         if( nColCount )
1306         {
1307             CellPos aPos( nIndex % nColCount, nIndex / nColCount );
1308             if( isValid( aPos ) )
1309                 setActiveCell( aPos );
1310         }
1311     }
1312 }
1313
1314 // --------------------------------------------------------------------
1315
1316 /** returns the index of the text that contains the given point or -1 */
1317 sal_Int32 SdrTableObj::CheckTextHit(const Point& rPnt) const
1318 {
1319     if( mpImpl && mpImpl->mxTable.is() )
1320     {
1321         CellPos aPos;
1322         if( CheckTableHit( rPnt, aPos.mnCol, aPos.mnRow, 0 ) == SDRTABLEHIT_CELLTEXTAREA )
1323             return aPos.mnRow * mpImpl->mxTable->getColumnCount() + aPos.mnCol;
1324     }
1325
1326     return 0;
1327 }
1328
1329 // --------------------------------------------------------------------
1330
1331 SdrOutliner* SdrTableObj::GetCellTextEditOutliner( const Cell& rCell ) const
1332 {
1333     if( mpImpl && (mpImpl->getCell( mpImpl->maEditPos ).get() == &rCell) )
1334         return pEdtOutl;
1335     else
1336         return 0;
1337 }
1338
1339
1340 // --------------------------------------------------------------------
1341
1342 const TableLayouter& SdrTableObj::getTableLayouter() const
1343 {
1344     OSL_ENSURE(mpImpl && mpImpl->mpLayouter, "getTableLayouter() error: no mpImpl or mpLayouter (!)");
1345     return *(mpImpl->mpLayouter);
1346 }
1347
1348 // --------------------------------------------------------------------
1349
1350 void SdrTableObj::FitFrameToTextSize()
1351 {
1352     // todo
1353 }
1354
1355 // --------------------------------------------------------------------
1356
1357 FASTBOOL SdrTableObj::IsAutoGrowHeight() const
1358 {
1359     return TRUE;
1360 }
1361
1362 // --------------------------------------------------------------------
1363
1364 FASTBOOL SdrTableObj::IsAutoGrowWidth() const
1365 {
1366     return TRUE;
1367 }
1368
1369 // --------------------------------------------------------------------
1370
1371 bool SdrTableObj::HasText() const
1372 {
1373     return true;
1374 }
1375
1376 // --------------------------------------------------------------------
1377
1378 bool SdrTableObj::IsTextEditActive( const CellPos& rPos )
1379 {
1380     return pEdtOutl && mpImpl && (rPos == mpImpl->maEditPos);
1381 }
1382
1383 // --------------------------------------------------------------------
1384
1385 void SdrTableObj::onEditOutlinerStatusEvent( EditStatus* pEditStatus )
1386 {
1387     if( (pEditStatus->GetStatusWord() & EE_STAT_TEXTHEIGHTCHANGED) && mpImpl && mpImpl->mpLayouter )
1388     {
1389         Rectangle aRect0( aRect );
1390         aRect = maLogicRect;
1391 //              mpImpl->mpLayouter->setRowHeight( mpImpl->maEditPos.mnRow, mpImpl->mnSavedEditRowHeight );
1392         mpImpl->LayoutTable( aRect, false, false );
1393         SetRectsDirty();
1394         ActionChanged();
1395         BroadcastObjectChange();
1396         if( aRect0 != aRect )
1397             SendUserCall(SDRUSERCALL_RESIZE,aRect0);
1398     }
1399 }
1400
1401 // --------------------------------------------------------------------
1402
1403 void SdrTableObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
1404 {
1405     rInfo.bResizeFreeAllowed=TRUE;
1406     rInfo.bResizePropAllowed=TRUE;
1407     rInfo.bRotateFreeAllowed=FALSE;
1408     rInfo.bRotate90Allowed  =FALSE;
1409     rInfo.bMirrorFreeAllowed=FALSE;
1410     rInfo.bMirror45Allowed  =FALSE;
1411     rInfo.bMirror90Allowed  =FALSE;
1412
1413     // allow transparence
1414     rInfo.bTransparenceAllowed = TRUE;
1415
1416     // gradient depends on fillstyle
1417     XFillStyle eFillStyle = ((XFillStyleItem&)(GetObjectItem(XATTR_FILLSTYLE))).GetValue();
1418     rInfo.bGradientAllowed = (eFillStyle == XFILL_GRADIENT);
1419     rInfo.bShearAllowed     =FALSE;
1420     rInfo.bEdgeRadiusAllowed=FALSE;
1421     rInfo.bCanConvToPath    =FALSE;
1422     rInfo.bCanConvToPoly    =FALSE;
1423     rInfo.bCanConvToPathLineToArea=FALSE;
1424     rInfo.bCanConvToPolyLineToArea=FALSE;
1425     rInfo.bCanConvToContour = FALSE;
1426 }
1427
1428 // --------------------------------------------------------------------
1429
1430 UINT16 SdrTableObj::GetObjIdentifier() const
1431 {
1432     return static_cast<UINT16>(OBJ_TABLE);
1433 }
1434
1435 // --------------------------------------------------------------------
1436
1437 void SdrTableObj::SetPage(SdrPage* pNewPage)
1438 {
1439     SdrTextObj::SetPage(pNewPage);
1440 }
1441
1442 // --------------------------------------------------------------------
1443
1444 void SdrTableObj::SetModel(SdrModel* pNewModel)
1445 {
1446     SdrModel* pOldModel = GetModel();
1447     if( pNewModel != pOldModel )
1448     {
1449         SdrTextObj::SetModel(pNewModel);
1450
1451         if( mpImpl )
1452         {
1453             mpImpl->SetModel( pOldModel, pNewModel );
1454
1455             if( !maLogicRect.IsEmpty() )
1456             {
1457                 aRect = maLogicRect;
1458                 mpImpl->LayoutTable( aRect, false, false );
1459             }
1460         }
1461     }
1462 }
1463
1464 // --------------------------------------------------------------------
1465
1466 void SdrTableObj::TakeTextRect( SdrOutliner& rOutliner, Rectangle& rTextRect, FASTBOOL bNoEditText, Rectangle* pAnchorRect, BOOL bLineWidth ) const
1467 {
1468     if( mpImpl )
1469         TakeTextRect( mpImpl->maEditPos, rOutliner, rTextRect, bNoEditText, pAnchorRect, bLineWidth );
1470 }
1471
1472 // --------------------------------------------------------------------
1473
1474 void SdrTableObj::TakeTextRect( const CellPos& rPos, SdrOutliner& rOutliner, Rectangle& rTextRect, FASTBOOL bNoEditText, Rectangle* pAnchorRect, BOOL /*bLineWidth*/ ) const
1475 {
1476     if( !mpImpl )
1477         return;
1478
1479     CellRef xCell( mpImpl->getCell( rPos ) );
1480     if( !xCell.is() )
1481         return;
1482
1483     Rectangle aAnkRect;
1484     TakeTextAnchorRect( rPos, aAnkRect );
1485
1486     SdrTextVertAdjust eVAdj=xCell->GetTextVerticalAdjust();
1487 //      SdrTextHorzAdjust eHAdj=xCell->GetTextHorizontalAdjust();
1488
1489     ULONG nStat0=rOutliner.GetControlWord();
1490     Size aNullSize;
1491     nStat0 |= EE_CNTRL_AUTOPAGESIZE;
1492     rOutliner.SetControlWord(nStat0);
1493     rOutliner.SetMinAutoPaperSize(aNullSize);
1494     rOutliner.SetMaxAutoPaperSize(aAnkRect.GetSize());
1495     rOutliner.SetPaperSize(aAnkRect.GetSize());
1496
1497     // #103516# New try with _BLOCK for hor and ver after completely
1498     // supporting full width for vertical text.
1499 //      if( SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
1500 //      {
1501         rOutliner.SetMinAutoPaperSize(Size(aAnkRect.GetWidth(), 0));
1502 //      }
1503 //      else if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
1504 //      {
1505 //              rOutliner.SetMinAutoPaperSize(Size(0, aAnkRect.GetHeight()));
1506 //      }
1507
1508     // ---
1509
1510     // set text at outliner, maybe from edit outliner
1511     OutlinerParaObject* pPara= xCell->GetOutlinerParaObject();
1512     if (pEdtOutl && !bNoEditText && mpImpl->mxActiveCell == xCell )
1513         pPara=pEdtOutl->CreateParaObject();
1514
1515     if (pPara)
1516     {
1517         const bool bHitTest = pModel && (&pModel->GetHitTestOutliner() == &rOutliner);
1518
1519         const SdrTextObj* pTestObj = rOutliner.GetTextObj();
1520         if( !pTestObj || !bHitTest || (pTestObj != this) || (pTestObj->GetOutlinerParaObject() != xCell->GetOutlinerParaObject()) )
1521         {
1522             if( bHitTest ) // #i33696# take back fix #i27510#
1523                 rOutliner.SetTextObj( this );
1524
1525             rOutliner.SetUpdateMode(TRUE);
1526             rOutliner.SetText(*pPara);
1527         }
1528     }
1529     else
1530     {
1531         rOutliner.SetTextObj( NULL );
1532     }
1533
1534     if (pEdtOutl && !bNoEditText && pPara && mpImpl->mxActiveCell == xCell )
1535         delete pPara;
1536
1537     rOutliner.SetUpdateMode(TRUE);
1538     rOutliner.SetControlWord(nStat0);
1539
1540     Point aTextPos(aAnkRect.TopLeft());
1541     Size aTextSiz(rOutliner.GetPaperSize());
1542 /*
1543     if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT)
1544     {
1545         long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width();
1546         if (eHAdj==SDRTEXTHORZADJUST_CENTER)
1547             aTextPos.X()+=nFreeWdt/2;
1548         if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
1549             aTextPos.X()+=nFreeWdt;
1550     }
1551 */
1552     if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1553     {
1554         long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
1555         if (eVAdj==SDRTEXTVERTADJUST_CENTER)
1556             aTextPos.Y()+=nFreeHgt/2;
1557         if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1558             aTextPos.Y()+=nFreeHgt;
1559     }
1560
1561     if (pAnchorRect)
1562         *pAnchorRect=aAnkRect;
1563
1564     rTextRect=Rectangle(aTextPos,aTextSiz);
1565 }
1566
1567 // --------------------------------------------------------------------
1568
1569 const CellRef& SdrTableObj::getActiveCell() const
1570 {
1571     if( mpImpl )
1572     {
1573         if( !mpImpl->mxActiveCell.is() )
1574         {
1575             CellPos aPos;
1576             const_cast< SdrTableObj* >(this)->setActiveCell( aPos );
1577         }
1578         return mpImpl->mxActiveCell;
1579     }
1580     else
1581     {
1582         static CellRef xCell;
1583         return xCell;
1584     }
1585 }
1586
1587 // --------------------------------------------------------------------
1588
1589 sal_Int32 SdrTableObj::getRowCount() const
1590 {
1591     return mpImpl ? mpImpl->getRowCount() : 0;
1592 }
1593
1594 // --------------------------------------------------------------------
1595
1596 sal_Int32 SdrTableObj::getColumnCount() const
1597 {
1598     return mpImpl ? mpImpl->getColumnCount() : 0;
1599 }
1600
1601 // --------------------------------------------------------------------
1602
1603 void SdrTableObj::setActiveCell( const CellPos& rPos )
1604 {
1605     if( mpImpl && mpImpl->mxTable.is() ) try
1606     {
1607         mpImpl->mxActiveCell.set( dynamic_cast< Cell* >( mpImpl->mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) );
1608         if( mpImpl->mxActiveCell.is() && mpImpl->mxActiveCell->isMerged() )
1609         {
1610             CellPos aOrigin;
1611             findMergeOrigin( mpImpl->mxTable.get(), rPos.mnCol, rPos.mnRow, aOrigin.mnCol, aOrigin.mnRow );
1612             mpImpl->mxActiveCell.set( dynamic_cast< Cell* >( mpImpl->mxTable->getCellByPosition( aOrigin.mnCol, aOrigin.mnRow ).get() ) );
1613             mpImpl->maEditPos = aOrigin;
1614         }
1615         else
1616         {
1617             mpImpl->maEditPos = rPos;
1618         }
1619     }
1620     catch( Exception& )
1621     {
1622         DBG_ERROR("SdrTableObj::setActiveCell(), exception caught!");
1623     }
1624 }
1625
1626 // --------------------------------------------------------------------
1627
1628 void SdrTableObj::getActiveCellPos( CellPos& rPos ) const
1629 {
1630     rPos = mpImpl->maEditPos;
1631 }
1632
1633 // --------------------------------------------------------------------
1634
1635 void SdrTableObj::getCellBounds( const CellPos& rPos, ::Rectangle& rCellRect )
1636 {
1637     if( mpImpl )
1638     {
1639         CellRef xCell( mpImpl->getCell( rPos ) );
1640         if( xCell.is() )
1641             rCellRect = xCell->getCellRect();
1642     }
1643 }
1644
1645 // --------------------------------------------------------------------
1646
1647 void SdrTableObj::TakeTextAnchorRect(Rectangle& rAnchorRect) const
1648 {
1649     if( mpImpl )
1650         TakeTextAnchorRect( mpImpl->maEditPos, rAnchorRect );
1651 }
1652
1653 // --------------------------------------------------------------------
1654
1655 void SdrTableObj::TakeTextAnchorRect( const CellPos& rPos, Rectangle& rAnchorRect ) const
1656 {
1657     Rectangle aAnkRect(aRect);
1658
1659     if( mpImpl )
1660     {
1661         CellRef xCell( mpImpl->getCell( rPos ) );
1662         if( xCell.is() )
1663             xCell->TakeTextAnchorRect( aAnkRect );
1664     }
1665
1666     ImpJustifyRect(aAnkRect);
1667     rAnchorRect=aAnkRect;
1668 }
1669
1670 // --------------------------------------------------------------------
1671
1672 void SdrTableObj::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin) const
1673 {
1674     if( mpImpl )
1675         TakeTextEditArea( mpImpl->maEditPos, pPaperMin, pPaperMax, pViewInit, pViewMin );
1676 }
1677
1678 // --------------------------------------------------------------------
1679
1680 void SdrTableObj::TakeTextEditArea( const CellPos& rPos, Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin ) const
1681 {
1682     Size aPaperMin,aPaperMax;
1683     Rectangle aViewInit;
1684     TakeTextAnchorRect( rPos, aViewInit );
1685
1686     Size aAnkSiz(aViewInit.GetSize());
1687     aAnkSiz.Width()--; aAnkSiz.Height()--; // weil GetSize() ein draufaddiert
1688
1689     Size aMaxSiz(aAnkSiz.Width(),1000000);
1690     if (pModel!=NULL)
1691     {
1692         Size aTmpSiz(pModel->GetMaxObjSize());
1693         if (aTmpSiz.Height()!=0)
1694             aMaxSiz.Height()=aTmpSiz.Height();
1695     }
1696
1697     CellRef xCell( mpImpl->getCell( rPos ) );
1698     SdrTextVertAdjust eVAdj = xCell.is() ? xCell->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_TOP;
1699 //      SdrTextHorzAdjust eHAdj = xCell.is() ? xCell->GetTextHorizontalAdjust() : SDRTEXTHORZADJUST_LEFT;
1700
1701     aPaperMax=aMaxSiz;
1702
1703 //      if((SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting()) || (SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting()))
1704         aPaperMin.Width() = aAnkSiz.Width();
1705
1706     if (pViewMin!=NULL)
1707     {
1708         *pViewMin=aViewInit;
1709 /*
1710         long nXFree=aAnkSiz.Width()-aPaperMin.Width();
1711
1712         if (eHAdj==SDRTEXTHORZADJUST_LEFT)
1713         {
1714             pViewMin->Right()-=nXFree;
1715         }
1716         else if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
1717         {
1718             pViewMin->Left()+=nXFree;
1719         }
1720         else
1721         {
1722             pViewMin->Left()+=nXFree/2;
1723             pViewMin->Right()=pViewMin->Left()+aPaperMin.Width();
1724         }
1725 */
1726         long nYFree=aAnkSiz.Height()-aPaperMin.Height();
1727
1728         if (eVAdj==SDRTEXTVERTADJUST_TOP)
1729         {
1730             pViewMin->Bottom()-=nYFree;
1731         }
1732         else if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1733         {
1734             pViewMin->Top()+=nYFree;
1735         }
1736         else
1737         {
1738             pViewMin->Top()+=nYFree/2;
1739             pViewMin->Bottom()=pViewMin->Top()+aPaperMin.Height();
1740         }
1741     }
1742
1743
1744     if(IsVerticalWriting())
1745         aPaperMin.Width() = 0;
1746     else
1747         aPaperMin.Height() = 0;
1748
1749     if (pPaperMin!=NULL) *pPaperMin=aPaperMin;
1750     if (pPaperMax!=NULL) *pPaperMax=aPaperMax;
1751     if (pViewInit!=NULL) *pViewInit=aViewInit;
1752 }
1753
1754 // --------------------------------------------------------------------
1755
1756 USHORT SdrTableObj::GetOutlinerViewAnchorMode() const
1757 {
1758     EVAnchorMode eRet=ANCHOR_TOP_LEFT;
1759     CellRef xCell( getActiveCell() );
1760     if( xCell.is() )
1761     {
1762         SdrTextVertAdjust eV=xCell->GetTextVerticalAdjust();
1763 //              SdrTextHorzAdjust eH=xCell->GetTextHorizontalAdjust();
1764
1765 //              if (eH==SDRTEXTHORZADJUST_LEFT)
1766         {
1767             if (eV==SDRTEXTVERTADJUST_TOP)
1768             {
1769                 eRet=ANCHOR_TOP_LEFT;
1770             }
1771             else if (eV==SDRTEXTVERTADJUST_BOTTOM)
1772             {
1773                 eRet=ANCHOR_BOTTOM_LEFT;
1774             }
1775             else
1776             {
1777                 eRet=ANCHOR_VCENTER_LEFT;
1778             }
1779         }
1780 /*
1781         else if (eH==SDRTEXTHORZADJUST_RIGHT)
1782         {
1783             if (eV==SDRTEXTVERTADJUST_TOP)
1784             {
1785                 eRet=ANCHOR_TOP_RIGHT;
1786             }
1787             else if (eV==SDRTEXTVERTADJUST_BOTTOM)
1788             {
1789                 eRet=ANCHOR_BOTTOM_RIGHT;
1790             }
1791             else
1792             {
1793                 eRet=ANCHOR_VCENTER_RIGHT;
1794             }
1795         }
1796         else
1797         {
1798             if (eV==SDRTEXTVERTADJUST_TOP)
1799             {
1800                 eRet=ANCHOR_TOP_HCENTER;
1801             }
1802             else if (eV==SDRTEXTVERTADJUST_BOTTOM)
1803             {
1804                 eRet=ANCHOR_BOTTOM_HCENTER;
1805             }
1806             else
1807             {
1808                 eRet=ANCHOR_VCENTER_HCENTER;
1809             }
1810         }
1811 */
1812     }
1813     return (USHORT)eRet;
1814 }
1815
1816 // --------------------------------------------------------------------
1817
1818 OutlinerParaObject* SdrTableObj::GetEditOutlinerParaObject() const
1819 {
1820     return SdrTextObj::GetEditOutlinerParaObject();
1821 }
1822
1823 // --------------------------------------------------------------------
1824
1825 SdrOutliner* SdrTableObj::GetCellTextEditOutliner( const CellPos& rPos ) const
1826 {
1827     if( pEdtOutl && mpImpl && (mpImpl->maEditPos == rPos) )
1828         return pEdtOutl;
1829     else
1830         return 0;
1831 }
1832
1833 // --------------------------------------------------------------------
1834
1835 struct ImplTableShadowPaintInfo
1836 {
1837     Color maShadowColor;
1838     sal_uInt32 mnXDistance;
1839     sal_uInt32 mnYDistance;
1840     sal_uInt16 mnShadowTransparence;
1841
1842     ImplTableShadowPaintInfo( const SfxItemSet& rSet )
1843     {
1844         const SdrShadowColorItem& rShadColItem = ((const SdrShadowColorItem&)(rSet.Get(SDRATTR_SHADOWCOLOR)));
1845         maShadowColor = rShadColItem.GetColorValue();
1846         mnShadowTransparence = ((const SdrShadowTransparenceItem&)(rSet.Get(SDRATTR_SHADOWTRANSPARENCE))).GetValue();
1847
1848         mnXDistance = ((SdrShadowXDistItem&)(rSet.Get(SDRATTR_SHADOWXDIST))).GetValue();
1849         mnYDistance = ((SdrShadowYDistItem&)(rSet.Get(SDRATTR_SHADOWYDIST))).GetValue();
1850     }
1851 };
1852
1853 // --------------------------------------------------------------------
1854
1855 void lcl_VertLineEnds( OutputDevice& rDev, const Point& rTop, const Point& rBottom,
1856         const Color& rColor, long nXOffs, long nWidth,
1857         const svx::frame::Style& rTopLine, const svx::frame::Style& rBottomLine )
1858 {
1859     rDev.SetLineColor(rColor);              // PEN_NULL ???
1860     rDev.SetFillColor(rColor);
1861
1862     //  Position oben/unten muss unabhaengig von der Liniendicke sein,
1863     //  damit der Winkel stimmt (oder X-Position auch anpassen)
1864     long nTopPos = rTop.Y();
1865     long nBotPos = rBottom.Y();
1866
1867     long nTopLeft = rTop.X() + nXOffs;
1868     long nTopRight = nTopLeft + nWidth - 1;
1869
1870     long nBotLeft = rBottom.X() + nXOffs;
1871     long nBotRight = nBotLeft + nWidth - 1;
1872
1873     //  oben abschliessen
1874
1875     if ( rTopLine.Prim() )
1876     {
1877         long nLineW = rTopLine.GetWidth();
1878         if (nLineW >= 2)
1879         {
1880             Point aTriangle[3];
1881             aTriangle[0] = Point( nTopLeft, nTopPos );          // wie aPoints[0]
1882             aTriangle[1] = Point( nTopRight, nTopPos );         // wie aPoints[1]
1883             aTriangle[2] = Point( rTop.X(), nTopPos - (nLineW - 1) / 2 );
1884             Polygon aTriPoly( 3, aTriangle );
1885             rDev.DrawPolygon( aTriPoly );
1886         }
1887     }
1888
1889     //  unten abschliessen
1890
1891     if ( rBottomLine.Prim() )
1892     {
1893         long nLineW = rBottomLine.GetWidth();
1894         if (nLineW >= 2)
1895         {
1896             Point aTriangle[3];
1897             aTriangle[0] = Point( nBotLeft, nBotPos );          // wie aPoints[3]
1898             aTriangle[1] = Point( nBotRight, nBotPos );         // wie aPoints[2]
1899             aTriangle[2] = Point( rBottom.X(), nBotPos - (nLineW - 1) / 2 + nLineW - 1 );
1900             Polygon aTriPoly( 3, aTriangle );
1901             rDev.DrawPolygon( aTriPoly );
1902         }
1903     }
1904 }
1905
1906 void lcl_VertLine( OutputDevice& rDev, const Point& rTop, const Point& rBottom,
1907                     const svx::frame::Style& rLine,
1908                     const svx::frame::Style& rTopLine, const svx::frame::Style& rBottomLine,
1909                     const Color* pForceColor )
1910 {
1911     if( rLine.Prim() )
1912     {
1913         svx::frame::DrawVerFrameBorderSlanted( rDev, rTop, rBottom, rLine, pForceColor );
1914
1915         svx::frame::Style aScaled( rLine );
1916         aScaled.ScaleSelf( 1.0 / cos( svx::frame::GetVerDiagAngle( rTop, rBottom ) ) );
1917         if( pForceColor )
1918             aScaled.SetColor( *pForceColor );
1919
1920         long nXOffs = (aScaled.GetWidth() - 1) / -2L;
1921
1922         lcl_VertLineEnds( rDev, rTop, rBottom, aScaled.GetColor(),
1923             nXOffs, aScaled.Prim(), rTopLine, rBottomLine );
1924
1925         if( aScaled.Secn() )
1926             lcl_VertLineEnds( rDev, rTop, rBottom, aScaled.GetColor(),
1927                 nXOffs + aScaled.Prim() + aScaled.Dist(), aScaled.Secn(), rTopLine, rBottomLine );
1928     }
1929 }
1930
1931 // --------------------------------------------------------------------
1932
1933 void SdrTableObj::TakeObjNameSingul(XubString& rName) const
1934 {
1935     rName = ImpGetResStr(STR_ObjNameSingulTable);
1936
1937     String aName( GetName() );
1938     if(aName.Len())
1939     {
1940         rName += sal_Unicode(' ');
1941         rName += sal_Unicode('\'');
1942         rName += aName;
1943         rName += sal_Unicode('\'');
1944     }
1945 }
1946
1947 // --------------------------------------------------------------------
1948
1949 void SdrTableObj::TakeObjNamePlural(XubString& rName) const
1950 {
1951     rName = ImpGetResStr(STR_ObjNamePluralTable);
1952 }
1953
1954 // --------------------------------------------------------------------
1955
1956 void SdrTableObj::operator=(const SdrObject& rObj)
1957 {
1958     // call parent
1959     SdrObject::operator=(rObj);
1960
1961     const SdrTableObj* pTableObj = dynamic_cast< const SdrTableObj* >( &rObj );
1962     if (pTableObj!=NULL)
1963     {
1964         TableModelNotifyGuard aGuard( mpImpl ? mpImpl->mxTable.get() : 0 );
1965
1966         maLogicRect = pTableObj->maLogicRect;
1967         aRect = pTableObj->aRect;
1968         aGeo = pTableObj->aGeo;
1969         eTextKind = pTableObj->eTextKind;
1970         bTextFrame = pTableObj->bTextFrame;
1971         aTextSize = pTableObj->aTextSize;
1972         bTextSizeDirty = pTableObj->bTextSizeDirty;
1973         bNoShear = pTableObj->bNoShear;
1974         bNoRotate = pTableObj->bNoRotate;
1975         bNoMirror = pTableObj->bNoMirror;
1976         bDisableAutoWidthOnDragging = pTableObj->bDisableAutoWidthOnDragging;
1977
1978         if( pTableObj->mpImpl )
1979             *mpImpl = *pTableObj->mpImpl;
1980     }
1981 }
1982
1983 // --------------------------------------------------------------------
1984
1985 basegfx::B2DPolyPolygon SdrTableObj::TakeXorPoly() const
1986 {
1987     return SdrTextObj::TakeXorPoly();
1988 }
1989
1990 // --------------------------------------------------------------------
1991
1992 basegfx::B2DPolyPolygon SdrTableObj::TakeContour() const
1993 {
1994     return SdrTextObj::TakeContour();
1995 }
1996
1997 // --------------------------------------------------------------------
1998
1999 const Rectangle& SdrTableObj::GetSnapRect() const
2000 {
2001     return aRect;
2002 }
2003
2004 // --------------------------------------------------------------------
2005
2006 void SdrTableObj::NbcSetSnapRect(const Rectangle& rRect)
2007 {
2008     NbcSetLogicRect( rRect );
2009 }
2010
2011 // --------------------------------------------------------------------
2012
2013 const Rectangle& SdrTableObj::GetLogicRect() const
2014 {
2015     return maLogicRect;
2016 }
2017
2018 // --------------------------------------------------------------------
2019
2020 void SdrTableObj::RecalcSnapRect()
2021 {
2022 }
2023
2024 // --------------------------------------------------------------------
2025
2026 sal_uInt32 SdrTableObj::GetSnapPointCount() const
2027 {
2028     return SdrTextObj::GetSnapPointCount();
2029 }
2030
2031 // --------------------------------------------------------------------
2032
2033
2034 Point SdrTableObj::GetSnapPoint(sal_uInt32 i) const
2035 {
2036     return SdrTextObj::GetSnapPoint(i);
2037 }
2038
2039 // --------------------------------------------------------------------
2040
2041 sal_Bool SdrTableObj::BegTextEdit(SdrOutliner& rOutl)
2042 {
2043     if( pEdtOutl != NULL )
2044         return sal_False;
2045
2046     pEdtOutl=&rOutl;
2047
2048 //      ForceOutlinerParaObject();
2049
2050     mbInEditMode = TRUE;
2051
2052     rOutl.Init( OUTLINERMODE_TEXTOBJECT );
2053     rOutl.SetRefDevice( pModel->GetRefDevice() );
2054
2055 // --
2056         FASTBOOL bUpdMerk=rOutl.GetUpdateMode();
2057         if (bUpdMerk) rOutl.SetUpdateMode(FALSE);
2058         Size aPaperMin;
2059         Size aPaperMax;
2060         Rectangle aEditArea;
2061         TakeTextEditArea(&aPaperMin,&aPaperMax,&aEditArea,NULL);
2062
2063         rOutl.SetMinAutoPaperSize(aPaperMin);
2064         rOutl.SetMaxAutoPaperSize(aPaperMax);
2065         rOutl.SetPaperSize(aPaperMax);
2066
2067         if (bUpdMerk) rOutl.SetUpdateMode(TRUE);
2068 //---
2069
2070     ULONG nStat=rOutl.GetControlWord();
2071 //      nStat   &= ~EE_CNTRL_AUTOPAGESIZE;
2072     nStat       |= EE_CNTRL_AUTOPAGESIZE;
2073     nStat       &=~EE_CNTRL_STRETCHING;
2074     rOutl.SetControlWord(nStat);
2075
2076     OutlinerParaObject* pPara = GetOutlinerParaObject();
2077     if(pPara)
2078         rOutl.SetText(*pPara);
2079
2080     rOutl.UpdateFields();
2081     rOutl.ClearModifyFlag();
2082
2083 //      mpImpl->mnSavedEditRowHeight = mpImpl->mpLayouter->getRowHeight( mpImpl->maEditPos.mnRow );
2084
2085     return sal_True;
2086 }
2087
2088 // --------------------------------------------------------------------
2089
2090 void SdrTableObj::EndTextEdit(SdrOutliner& rOutl)
2091 {
2092     if(rOutl.IsModified())
2093     {
2094         if( GetModel() && GetModel()->IsUndoEnabled() )
2095             GetModel()->AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*this) );
2096
2097         OutlinerParaObject* pNewText = 0;
2098         Paragraph* p1stPara = rOutl.GetParagraph( 0 );
2099         UINT32 nParaAnz = rOutl.GetParagraphCount();
2100
2101         if(p1stPara)
2102         {
2103             if(nParaAnz == 1)
2104             {
2105                 // if its only one paragraph, check if it is empty
2106                 XubString aStr(rOutl.GetText(p1stPara));
2107
2108                 if(!aStr.Len())
2109                 {
2110                     // gotcha!
2111                     nParaAnz = 0;
2112                 }
2113             }
2114
2115             // to remove the grey field background
2116             rOutl.UpdateFields();
2117
2118             if(nParaAnz != 0)
2119             {
2120                 // create new text object
2121                 pNewText = rOutl.CreateParaObject( 0, (sal_uInt16)nParaAnz );
2122             }
2123         }
2124         SetOutlinerParaObject(pNewText);
2125     }
2126
2127     pEdtOutl = 0;
2128     rOutl.Clear();
2129     UINT32 nStat = rOutl.GetControlWord();
2130     nStat &= ~EE_CNTRL_AUTOPAGESIZE;
2131     rOutl.SetControlWord(nStat);
2132
2133     mbInEditMode = FALSE;
2134 }
2135
2136 // --------------------------------------------------------------------
2137
2138 OutlinerParaObject* SdrTableObj::GetOutlinerParaObject() const
2139 {
2140     CellRef xCell( getActiveCell() );
2141     if( xCell.is() )
2142         return xCell->GetOutlinerParaObject();
2143     else
2144         return 0;
2145 }
2146
2147 // --------------------------------------------------------------------
2148
2149 void SdrTableObj::NbcSetOutlinerParaObject( OutlinerParaObject* pTextObject)
2150 {
2151     CellRef xCell( getActiveCell() );
2152     if( xCell.is() )
2153     {
2154         if( pModel )
2155         {
2156             // Update HitTestOutliner
2157             const SdrTextObj* pTestObj = pModel->GetHitTestOutliner().GetTextObj();
2158             if( pTestObj && pTestObj->GetOutlinerParaObject() == xCell->GetOutlinerParaObject() )
2159                 pModel->GetHitTestOutliner().SetTextObj( NULL );
2160         }
2161
2162         xCell->SetOutlinerParaObject( pTextObject );
2163
2164         SetTextSizeDirty();
2165         NbcAdjustTextFrameWidthAndHeight();
2166 //              ImpSetTextStyleSheetListeners();
2167 //              ImpCheckMasterCachable();
2168     }
2169 }
2170
2171 // --------------------------------------------------------------------
2172
2173 void SdrTableObj::NbcSetLogicRect(const Rectangle& rRect)
2174 {
2175     maLogicRect=rRect;
2176     ImpJustifyRect(maLogicRect);
2177     const bool bWidth = maLogicRect.getWidth() != aRect.getWidth();
2178     const bool bHeight = maLogicRect.getHeight() != aRect.getHeight();
2179     aRect=maLogicRect;
2180     NbcAdjustTextFrameWidthAndHeight( !bHeight, !bWidth );
2181     SetRectsDirty();
2182 }
2183
2184 // --------------------------------------------------------------------
2185
2186 void SdrTableObj::NbcMove(const Size& rSiz)
2187 {
2188     MoveRect(maLogicRect,rSiz);
2189     SdrTextObj::NbcMove( rSiz );
2190     if( mpImpl )
2191         mpImpl->UpdateCells( aRect );
2192 }
2193
2194 // --------------------------------------------------------------------
2195
2196 void SdrTableObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
2197 {
2198     Rectangle aOldRect( maLogicRect );
2199     ResizeRect(maLogicRect,rRef,xFact,yFact);
2200
2201     aRect = maLogicRect;
2202     NbcAdjustTextFrameWidthAndHeight( maLogicRect.GetHeight() == aOldRect.GetHeight(), maLogicRect.GetWidth() == aOldRect.GetWidth() );
2203     SetRectsDirty();
2204 }
2205
2206 // --------------------------------------------------------------------
2207
2208 FASTBOOL SdrTableObj::AdjustTextFrameWidthAndHeight(FASTBOOL bHgt, FASTBOOL bWdt)
2209 {
2210     Rectangle aNeuRect(maLogicRect);
2211     FASTBOOL bRet=AdjustTextFrameWidthAndHeight(aNeuRect,bHgt,bWdt);
2212     if (bRet)
2213     {
2214         Rectangle aBoundRect0;
2215         if (pUserCall!=NULL)
2216             aBoundRect0=GetLastBoundRect();
2217         aRect=aNeuRect;
2218         SetRectsDirty();
2219         SetChanged();
2220         BroadcastObjectChange();
2221         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2222     }
2223     return bRet;
2224 }
2225
2226 // --------------------------------------------------------------------
2227
2228 FASTBOOL SdrTableObj::AdjustTextFrameWidthAndHeight(Rectangle& rR, FASTBOOL bHeight, FASTBOOL bWidth) const
2229 {
2230     if((pModel == NULL) || rR.IsEmpty() || !mpImpl || !mpImpl->mxTable.is() )
2231         return FALSE;
2232
2233     Rectangle aRectangle( rR );
2234     mpImpl->LayoutTable( aRectangle, !bWidth, !bHeight );
2235
2236     if( aRectangle != rR )
2237     {
2238         rR = aRectangle;
2239         return TRUE;
2240     }
2241     else
2242     {
2243         return FALSE;
2244     }
2245 }
2246
2247 // --------------------------------------------------------------------
2248
2249 void SdrTableObj::NbcReformatText()
2250 {
2251     NbcAdjustTextFrameWidthAndHeight();
2252 }
2253
2254 // --------------------------------------------------------------------
2255
2256 void SdrTableObj::ReformatText()
2257 {
2258     Rectangle aBoundRect0;
2259     if (pUserCall!=NULL)
2260         aBoundRect0=GetLastBoundRect();
2261     NbcReformatText();
2262     SetChanged();
2263     BroadcastObjectChange();
2264     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2265 }
2266
2267 // --------------------------------------------------------------------
2268
2269 sal_Bool SdrTableObj::IsVerticalWriting() const
2270 {
2271     const SvxWritingModeItem* pModeItem = dynamic_cast< const SvxWritingModeItem* >( &GetObjectItem( SDRATTR_TEXTDIRECTION ) );
2272     return pModeItem && pModeItem->GetValue() == com::sun::star::text::WritingMode_TB_RL;
2273 }
2274
2275 // --------------------------------------------------------------------
2276
2277 void SdrTableObj::SetVerticalWriting(sal_Bool bVertical )
2278 {
2279     if( bVertical != IsVerticalWriting() )
2280     {
2281         SvxWritingModeItem aModeItem( com::sun::star::text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION );
2282         SetObjectItem( aModeItem );
2283     }
2284 }
2285
2286 // --------------------------------------------------------------------
2287
2288 WritingMode SdrTableObj::GetWritingMode() const
2289 {
2290     WritingMode eMode = WritingMode_LR_TB;
2291     if( mpImpl && mpImpl->mpLayouter )
2292         eMode = mpImpl->mpLayouter->GetWritingMode();
2293     return eMode;
2294 }
2295
2296 // --------------------------------------------------------------------
2297
2298 // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
2299 // with the base geometry and returns TRUE. Otherwise it returns FALSE.
2300 sal_Bool SdrTableObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon ) const
2301 {
2302     return SdrTextObj::TRGetBaseGeometry( rMatrix, rPolyPolygon );
2303 }
2304
2305 // --------------------------------------------------------------------
2306
2307 // sets the base geometry of the object using infos contained in the homogen 3x3 matrix.
2308 // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
2309 // to use (0,0) as upper left and will be scaled to the given size in the matrix.
2310 void SdrTableObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon )
2311 {
2312     SdrTextObj::TRSetBaseGeometry( rMatrix, rPolyPolygon );
2313 }
2314
2315 // --------------------------------------------------------------------
2316
2317 bool SdrTableObj::IsRealyEdited() const
2318 {
2319     return pEdtOutl && pEdtOutl->IsModified();
2320 }
2321
2322 // --------------------------------------------------------------------
2323
2324 FASTBOOL SdrTableObj::IsFontwork() const
2325 {
2326     return FALSE;
2327 }
2328
2329 // --------------------------------------------------------------------
2330
2331 sal_uInt32 SdrTableObj::GetHdlCount() const
2332 {
2333     sal_uInt32 nCount = SdrTextObj::GetHdlCount();
2334     const sal_Int32 nRowCount = mpImpl->getRowCount();
2335     const sal_Int32 nColCount = mpImpl->getColumnCount();
2336
2337     if( nRowCount && nColCount )
2338         nCount += nRowCount + nColCount + 2 + 1;
2339
2340     return nCount;
2341 }
2342
2343 // --------------------------------------------------------------------
2344
2345 void SdrTableObj::AddToHdlList(SdrHdlList& rHdlList) const
2346 {
2347     const sal_Int32 nRowCount = mpImpl->getRowCount();
2348     const sal_Int32 nColCount = mpImpl->getColumnCount();
2349
2350     // first add row handles
2351     std::vector< TableEdgeHdl* > aRowEdges( nRowCount + 1 );
2352
2353     for( sal_Int32 nRow = 0; nRow <= nRowCount; nRow++ )
2354     {
2355         sal_Int32 nEdgeMin, nEdgeMax;
2356         const sal_Int32 nEdge = mpImpl->mpLayouter->getHorizontalEdge( nRow, &nEdgeMin, &nEdgeMax );
2357         nEdgeMin -= nEdge;
2358         nEdgeMax -= nEdge;
2359
2360         Point aPoint( aRect.TopLeft() );
2361         aPoint.Y() += nEdge;
2362
2363         TableEdgeHdl* pHdl= new TableEdgeHdl(aPoint,true,nEdgeMin,nEdgeMax,nColCount+1);
2364         pHdl->SetPointNum( nRow );
2365         rHdlList.AddHdl( pHdl );
2366         aRowEdges[nRow] = pHdl;
2367     }
2368
2369     // second add column handles
2370     std::vector< TableEdgeHdl* > aColEdges( nColCount + 1 );
2371
2372     for( sal_Int32 nCol = 0; nCol <= nColCount; nCol++ )
2373     {
2374         sal_Int32 nEdgeMin, nEdgeMax;
2375         const sal_Int32 nEdge = mpImpl->mpLayouter->getVerticalEdge( nCol, &nEdgeMin, &nEdgeMax );
2376         nEdgeMin -= nEdge;
2377         nEdgeMax -= nEdge;
2378
2379         Point aPoint( aRect.TopLeft() );
2380         aPoint.X() += nEdge;
2381
2382         TableEdgeHdl* pHdl = new TableEdgeHdl(aPoint,false,nEdgeMin,nEdgeMax, nRowCount+1);
2383         pHdl->SetPointNum( nCol );
2384         rHdlList.AddHdl( pHdl );
2385         aColEdges[nCol] = pHdl;
2386     }
2387
2388     // now add visible edges to row and column handles
2389     if( mpImpl && mpImpl->mpLayouter )
2390     {
2391         TableLayouter& rLayouter = *mpImpl->mpLayouter;
2392
2393         sal_Int32 nY = 0;
2394
2395         for( sal_Int32 nRow = 0; nRow <= nRowCount; ++nRow )
2396         {
2397             const sal_Int32 nRowHeight = (nRow == nRowCount) ? 0 : rLayouter.getRowHeight(nRow);
2398             sal_Int32 nX = 0;
2399
2400             for( sal_Int32 nCol = 0; nCol <= nColCount; ++nCol )
2401             {
2402                 const sal_Int32 nColWidth = (nCol == nColCount) ? 0 : rLayouter.getColumnWidth(nCol);
2403
2404                 if( nRowHeight > 0 )
2405                 {
2406                     if( rLayouter.isEdgeVisible( nCol, nRow, false ) )
2407                         aColEdges[nCol]->SetEdge( nRow, nY, nY + nRowHeight, (rLayouter.getBorderLine( nCol, nRow, false ) == 0) ? Visible : Invisible);
2408                 }
2409
2410                 if( nColWidth > 0 )
2411                 {
2412                     if( rLayouter.isEdgeVisible( nCol, nRow, true ) )
2413                         aRowEdges[nRow]->SetEdge( nCol, nX, nX + nColWidth, (rLayouter.getBorderLine( nCol, nRow, true ) == 0) ? Visible : Invisible);
2414                 }
2415
2416                 nX += nColWidth;
2417             }
2418
2419             nY += nRowHeight;
2420         }
2421     }
2422
2423     // add remaining handles
2424     SdrHdl* pH=0;
2425     rHdlList.AddHdl( pH = new TableBorderHdl( aRect ) ); pH->SetMoveOutside( true );
2426     rHdlList.AddHdl( pH = new SdrHdl(aRect.TopLeft(),HDL_UPLFT) ); pH->SetMoveOutside( true );
2427     rHdlList.AddHdl( pH = new SdrHdl(aRect.TopCenter(),HDL_UPPER) ); pH->SetMoveOutside( true );
2428     rHdlList.AddHdl( pH = new SdrHdl(aRect.TopRight(),HDL_UPRGT) ); pH->SetMoveOutside( true );
2429     rHdlList.AddHdl( pH = new SdrHdl(aRect.LeftCenter(),HDL_LEFT) ); pH->SetMoveOutside( true );
2430     rHdlList.AddHdl( pH = new SdrHdl(aRect.RightCenter(),HDL_RIGHT) ); pH->SetMoveOutside( true );
2431     rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomLeft(),HDL_LWLFT) ); pH->SetMoveOutside( true );
2432     rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomCenter(),HDL_LOWER) ); pH->SetMoveOutside( true );
2433     rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomRight(),HDL_LWRGT) ); pH->SetMoveOutside( true );
2434
2435     ULONG nHdlCount = rHdlList.GetHdlCount();
2436     for( ULONG nHdl = 0; nHdl < nHdlCount; nHdl++ )
2437         rHdlList.GetHdl(nHdl)->SetObj((SdrObject*)this);
2438 }
2439
2440 // --------------------------------------------------------------------
2441
2442 SdrHdl* SdrTableObj::GetHdl(sal_uInt32 nHdlNum) const
2443 {
2444     // #i73248#
2445     // Warn the user that this is ineffective and show alternatives. Should not be used at all.
2446     OSL_ENSURE(false, "SdrTableObj::GetHdl(): ineffective, use AddToHdlList instead (!)");
2447
2448     // to have an alternative, get single handle using the ineffective way
2449     SdrHdl* pRetval = 0;
2450     SdrHdlList aLocalList(0);
2451     AddToHdlList(aLocalList);
2452     const sal_uInt32 nHdlCount(aLocalList.GetHdlCount());
2453
2454     if(nHdlCount && nHdlNum < nHdlCount)
2455     {
2456         // remove and remember. The other created handles will be deleted again with the
2457         // destruction of the local list
2458         pRetval = aLocalList.RemoveHdl(nHdlNum);
2459     }
2460
2461     return pRetval;
2462 }
2463
2464 ////////////////////////////////////////////////////////////////////////////////////////////////////
2465 // Draging
2466
2467 bool SdrTableObj::hasSpecialDrag() const
2468 {
2469     return true;
2470 }
2471
2472 bool SdrTableObj::beginSpecialDrag(SdrDragStat& rDrag) const
2473 {
2474     const SdrHdl* pHdl = rDrag.GetHdl();
2475     const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());
2476
2477     switch( eHdl )
2478     {
2479         case HDL_UPLFT:
2480         case HDL_UPPER:
2481         case HDL_UPRGT:
2482         case HDL_LEFT:
2483         case HDL_RIGHT:
2484         case HDL_LWLFT:
2485         case HDL_LOWER:
2486         case HDL_LWRGT:
2487         case HDL_MOVE:
2488         {
2489             break;
2490         }
2491
2492         case HDL_USER:
2493         {
2494             rDrag.SetEndDragChangesAttributes(false);
2495             rDrag.SetNoSnap(true);
2496             break;
2497         }
2498
2499         default:
2500         {
2501             return false;
2502         }
2503     }
2504
2505     return true;
2506 }
2507
2508 bool SdrTableObj::applySpecialDrag(SdrDragStat& rDrag)
2509 {
2510     bool bRet(true);
2511     const SdrHdl* pHdl = rDrag.GetHdl();
2512     const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());
2513
2514     switch( eHdl )
2515     {
2516         case HDL_UPLFT:
2517         case HDL_UPPER:
2518         case HDL_UPRGT:
2519         case HDL_LEFT:
2520         case HDL_RIGHT:
2521         case HDL_LWLFT:
2522         case HDL_LOWER:
2523         case HDL_LWRGT:
2524         {
2525             const Rectangle aNewRectangle(ImpDragCalcRect(rDrag));
2526
2527             if(aNewRectangle != aRect)
2528             {
2529                    NbcSetLogicRect(aNewRectangle);
2530             }
2531
2532             break;
2533         }
2534
2535         case HDL_MOVE:
2536         {
2537                NbcMove( Size( rDrag.GetDX(), rDrag.GetDY() ) );
2538             break;
2539         }
2540
2541         case HDL_USER:
2542         {
2543             rDrag.SetEndDragChangesAttributes(false);
2544             rDrag.SetNoSnap(true);
2545             const TableEdgeHdl* pEdgeHdl = dynamic_cast< const TableEdgeHdl* >( pHdl );
2546
2547             if( pEdgeHdl )
2548             {
2549                 if( GetModel() && IsInserted() )
2550                 {
2551                     rDrag.SetEndDragChangesAttributes(true);
2552                 }
2553
2554                 mpImpl->DragEdge( pEdgeHdl->IsHorizontalEdge(), pEdgeHdl->GetPointNum(), pEdgeHdl->GetValidDragOffset( rDrag ) );
2555             }
2556             break;
2557         }
2558
2559         default:
2560         {
2561             bRet = false;
2562         }
2563     }
2564
2565     return bRet;
2566 }
2567
2568 String SdrTableObj::getSpecialDragComment(const SdrDragStat& rDrag) const
2569 {
2570     return SdrTextObj::getSpecialDragComment( rDrag );
2571 }
2572
2573 basegfx::B2DPolyPolygon SdrTableObj::getSpecialDragPoly(const SdrDragStat& rDrag) const
2574 {
2575     basegfx::B2DPolyPolygon aRetval;
2576     const SdrHdl* pHdl = rDrag.GetHdl();
2577
2578     if(HDL_USER == pHdl->GetKind())
2579     {
2580         const TableEdgeHdl* pEdgeHdl = dynamic_cast< const TableEdgeHdl* >( pHdl );
2581
2582         if( pEdgeHdl )
2583         {
2584             aRetval = pEdgeHdl->getSpecialDragPoly( rDrag );
2585         }
2586     }
2587
2588     return aRetval;
2589 }
2590
2591 ////////////////////////////////////////////////////////////////////////////////////////////////////
2592 // Create
2593 // --------------------------------------------------------------------
2594
2595 FASTBOOL SdrTableObj::BegCreate(SdrDragStat& rStat)
2596 {
2597     rStat.SetOrtho4Possible();
2598     Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
2599     aRect1.Justify();
2600     rStat.SetActionRect(aRect1);
2601     aRect = aRect1;
2602     return TRUE;
2603 }
2604
2605 // --------------------------------------------------------------------
2606
2607 FASTBOOL SdrTableObj::MovCreate(SdrDragStat& rStat)
2608 {
2609     Rectangle aRect1;
2610     rStat.TakeCreateRect(aRect1);
2611     ImpJustifyRect(aRect1);
2612     rStat.SetActionRect(aRect1);
2613     aRect=aRect1; // fuer ObjName
2614     SetBoundRectDirty();
2615     bSnapRectDirty=TRUE;
2616     return TRUE;
2617 }
2618
2619 // --------------------------------------------------------------------
2620
2621 FASTBOOL SdrTableObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
2622 {
2623     rStat.TakeCreateRect(aRect);
2624     ImpJustifyRect(aRect);
2625     return (eCmd==SDRCREATE_FORCEEND || rStat.GetPointAnz()>=2);
2626 }
2627
2628 void SdrTableObj::BrkCreate(SdrDragStat& /*rStat*/)
2629 {
2630 }
2631
2632 // --------------------------------------------------------------------
2633
2634 FASTBOOL SdrTableObj::BckCreate(SdrDragStat& /*rStat*/)
2635 {
2636     return TRUE;
2637 }
2638
2639 // --------------------------------------------------------------------
2640
2641 basegfx::B2DPolyPolygon SdrTableObj::TakeCreatePoly(const SdrDragStat& rDrag) const
2642 {
2643     Rectangle aRect1;
2644     rDrag.TakeCreateRect(aRect1);
2645     aRect1.Justify();
2646
2647     basegfx::B2DPolyPolygon aRetval;
2648     const basegfx::B2DRange aRange(aRect1.Left(), aRect1.Top(), aRect1.Right(), aRect1.Bottom());
2649     aRetval.append(basegfx::tools::createPolygonFromRect(aRange));
2650     return aRetval;
2651 }
2652
2653 // --------------------------------------------------------------------
2654
2655 Pointer SdrTableObj::GetCreatePointer() const
2656 {
2657     return Pointer(POINTER_CROSS);
2658 }
2659
2660 // --------------------------------------------------------------------
2661
2662 void SdrTableObj::createCell( CellRef& xNewCell )
2663 {
2664     xNewCell = Cell::create( *this, 0 );
2665 }
2666
2667 // --------------------------------------------------------------------
2668
2669 SdrObjGeoData *SdrTableObj::NewGeoData() const
2670 {
2671     return new TableObjectGeoData;
2672 }
2673
2674 // --------------------------------------------------------------------
2675
2676 void SdrTableObj::SaveGeoData(SdrObjGeoData& rGeo) const
2677 {
2678     DBG_ASSERT( dynamic_cast< TableObjectGeoData* >( &rGeo ), "svx::SdrTableObj::SaveGeoData(), illegal geo data!" );
2679     SdrTextObj::SaveGeoData (rGeo);
2680
2681     ((TableObjectGeoData &) rGeo).maLogicRect = maLogicRect;
2682 }
2683
2684 // --------------------------------------------------------------------
2685
2686 void SdrTableObj::RestGeoData(const SdrObjGeoData& rGeo)
2687 {
2688     DBG_ASSERT( dynamic_cast< const TableObjectGeoData* >( &rGeo ), "svx::SdrTableObj::SaveGeoData(), illegal geo data!" );
2689
2690     maLogicRect = ((TableObjectGeoData &) rGeo).maLogicRect;
2691
2692     SdrTextObj::RestGeoData (rGeo);
2693
2694     if( mpImpl )
2695         mpImpl->LayoutTable( aRect, false, false );
2696     ActionChanged();
2697 }
2698
2699 // --------------------------------------------------------------------
2700
2701 SdrTableObj* SdrTableObj::CloneRange( const CellPos& rStart, const CellPos& rEnd )
2702 {
2703     const sal_Int32 nColumns = rEnd.mnCol - rStart.mnCol + 1;
2704     const sal_Int32 nRows = rEnd.mnRow - rStart.mnRow + 1;
2705
2706     SdrTableObj* pNewTableObj = new SdrTableObj( GetModel(), GetCurrentBoundRect(), nColumns, nRows);
2707     pNewTableObj->setTableStyleSettings( getTableStyleSettings() );
2708     pNewTableObj->setTableStyle( getTableStyle() );
2709
2710     Reference< XTable > xTable( getTable() );
2711     Reference< XTable > xNewTable( pNewTableObj->getTable() );
2712
2713     if( !xTable.is() || !xNewTable.is() )
2714     {
2715         delete pNewTableObj;
2716         return 0;
2717     }
2718
2719     // copy cells
2720     for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
2721     {
2722         for( sal_Int32 nCol = 0; nCol < nColumns; ++nCol ) try
2723         {
2724             CellRef xTargetCell( dynamic_cast< Cell* >( xNewTable->getCellByPosition( nCol, nRow ).get() ) );
2725             if( xTargetCell.is() )
2726                 xTargetCell->cloneFrom( dynamic_cast< Cell* >( xTable->getCellByPosition( rStart.mnCol + nCol, rStart.mnRow + nRow ).get() ) );
2727         }
2728         catch( Exception& )
2729         {
2730             DBG_ERROR( "svx::SvxTableController::GetMarkedObjModel(), exception caught!" );
2731         }
2732     }
2733
2734     // copy row heights
2735     Reference< XTableRows > xNewRows( xNewTable->getRows(), UNO_QUERY_THROW );
2736     const OUString sHeight( RTL_CONSTASCII_USTRINGPARAM( "Height" ) );
2737     for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
2738     {
2739         Reference< XPropertySet > xNewSet( xNewRows->getByIndex( nRow ), UNO_QUERY_THROW );
2740         xNewSet->setPropertyValue( sHeight, Any( mpImpl->mpLayouter->getRowHeight( rStart.mnRow + nRow ) ) );
2741     }
2742
2743     // copy column widths
2744     Reference< XTableColumns > xNewColumns( xNewTable->getColumns(), UNO_QUERY_THROW );
2745     const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM( "Width" ) );
2746     for( sal_Int32 nCol = 0; nCol < nColumns; ++nCol )
2747     {
2748         Reference< XPropertySet > xNewSet( xNewColumns->getByIndex( nCol ), UNO_QUERY_THROW );
2749         xNewSet->setPropertyValue( sWidth, Any( mpImpl->mpLayouter->getColumnWidth( rStart.mnCol + nCol ) ) );
2750     }
2751
2752     pNewTableObj->NbcReformatText();
2753     pNewTableObj->SetLogicRect( pNewTableObj->GetCurrentBoundRect() );
2754
2755     return pNewTableObj;
2756 }
2757
2758 // --------------------------------------------------------------------
2759
2760 void SdrTableObj::DistributeColumns( sal_Int32 nFirstColumn, sal_Int32 nLastColumn )
2761 {
2762     if( mpImpl && mpImpl->mpLayouter )
2763     {
2764         TableModelNotifyGuard aGuard( mpImpl->mxTable.get() );
2765         mpImpl->mpLayouter->DistributeColumns( aRect, nFirstColumn, nLastColumn );
2766     }
2767 }
2768
2769 // --------------------------------------------------------------------
2770
2771 void SdrTableObj::DistributeRows( sal_Int32 nFirstRow, sal_Int32 nLastRow )
2772 {
2773     if( mpImpl && mpImpl->mpLayouter )
2774     {
2775         TableModelNotifyGuard aGuard( mpImpl->mxTable.get() );
2776         mpImpl->mpLayouter->DistributeRows( aRect, nFirstRow, nLastRow );
2777     }
2778 }
2779
2780 // --------------------------------------------------------------------
2781
2782 void SdrTableObj::SetChanged()
2783 {
2784     if( mpImpl )
2785     {
2786         if( mpImpl->UpdateWritingMode() )
2787             mpImpl->LayoutTable( aRect, false, false );
2788     }
2789
2790     ::SdrTextObj::SetChanged();
2791 }
2792
2793 // --------------------------------------------------------------------
2794
2795 void SdrTableObj::uno_lock()
2796 {
2797     if( mpImpl && mpImpl->mxTable.is() )
2798         mpImpl->mxTable->lockBroadcasts();
2799 }
2800
2801 // --------------------------------------------------------------------
2802
2803 void SdrTableObj::uno_unlock()
2804 {
2805     if( mpImpl && mpImpl->mxTable.is() )
2806         mpImpl->mxTable->unlockBroadcasts();
2807 }
2808
2809 // --------------------------------------------------------------------
2810
2811
2812
2813 } }