svx/source/table/svdotable.cxx

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