svx/source/table/tablecolumn.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
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22
  23 #include "tablecolumn.hxx"
  24 #include "tableundo.hxx"
  25 #include "svx/svdmodel.hxx"
  26 #include "svx/svdotable.hxx"
  27
  28
  29
  30 using namespace ::com::sun::star::uno;
  31 using namespace ::com::sun::star::lang;
  32 using namespace ::com::sun::star::container;
  33 using namespace ::com::sun::star::table;
  34 using namespace ::com::sun::star::beans;
  35
  36
  37
  38 namespace sdr { namespace table {
  39
  40 const sal_Int32 Property_Width = 0;
  41 const sal_Int32 Property_OptimalWidth = 1;
  42 const sal_Int32 Property_IsVisible = 2;
  43 const sal_Int32 Property_IsStartOfNewPage = 3;
  44
  45
  46 // TableRow
  47
  48
  49 TableColumn::TableColumn( const TableModelRef& xTableModel, sal_Int32 nColumn )
  50 : TableColumnBase( getStaticPropertySetInfo() )
  51 , mxTableModel( xTableModel )
  52 , mnColumn( nColumn )
  53 , mnWidth( 0 )
  54 , mbOptimalWidth( true )
  55 , mbIsVisible( true )
  56 , mbIsStartOfNewPage( false )
  57 {
  58 }
  59
  60
  61
  62 TableColumn::~TableColumn()
  63 {
  64 }
  65
  66
  67
  68 void TableColumn::dispose()
  69 {
  70     mxTableModel.clear();
  71 }
  72
  73
  74
  75 void TableColumn::throwIfDisposed() const throw (::com::sun::star::uno::RuntimeException)
  76 {
  77     if( !mxTableModel.is() )
  78         throw DisposedException();
  79 }
  80
  81
  82
  83 TableColumn& TableColumn::operator=( const TableColumn& r )
  84 {
  85     mnWidth = r.mnWidth;
  86     mbOptimalWidth = r.mbOptimalWidth;
  87     mbIsVisible = r.mbIsVisible;
  88     mbIsStartOfNewPage = r.mbIsStartOfNewPage;
  89     maName = r.maName;
  90     mnColumn = r.mnColumn;
  91
  92     return *this;
  93 }
  94
  95
  96 // XCellRange
  97
  98
  99 Reference< XCell > SAL_CALL TableColumn::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 100 {
 101     throwIfDisposed();
 102     if( nColumn != 0 )
 103         throw IndexOutOfBoundsException();
 104
 105     return mxTableModel->getCellByPosition( mnColumn, nRow );
 106 }
 107
 108
 109
 110 Reference< XCellRange > SAL_CALL TableColumn::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 111 {
 112     throwIfDisposed();
 113     if( (nTop >= 0 ) && (nLeft == 0) && (nBottom >= nTop) && (nRight == 0)  )
 114     {
 115         return mxTableModel->getCellRangeByPosition( mnColumn, nTop, mnColumn, nBottom );
 116     }
 117     throw IndexOutOfBoundsException();
 118 }
 119
 120
 121
 122 Reference< XCellRange > SAL_CALL TableColumn::getCellRangeByName( const OUString& /*aRange*/ ) throw (RuntimeException, std::exception)
 123 {
 124     return Reference< XCellRange >();
 125 }
 126
 127
 128 // XNamed
 129
 130
 131 OUString SAL_CALL TableColumn::getName() throw (RuntimeException, std::exception)
 132 {
 133     return maName;
 134 }
 135
 136
 137
 138 void SAL_CALL TableColumn::setName( const OUString& aName ) throw (RuntimeException, std::exception)
 139 {
 140     maName = aName;
 141 }
 142
 143
 144 // XFastPropertySet
 145
 146
 147 void SAL_CALL TableColumn::setFastPropertyValue( sal_Int32 nHandle, const Any& aValue ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, RuntimeException, std::exception)
 148 {
 149     bool bOk = false;
 150     bool bChange = false;
 151
 152     SdrModel* pModel = mxTableModel->getSdrTableObj()->GetModel();
 153
 154     TableColumnUndo* pUndo = 0;
 155     if( mxTableModel.is() && mxTableModel->getSdrTableObj() && mxTableModel->getSdrTableObj()->IsInserted() && pModel && pModel->IsUndoEnabled() )
 156     {
 157         TableColumnRef xThis( this );
 158         pUndo = new TableColumnUndo( xThis );
 159     }
 160
 161     switch( nHandle )
 162     {
 163     case Property_Width:
 164         {
 165             sal_Int32 nWidth = mnWidth;
 166             bOk = aValue >>= nWidth;
 167             if( bOk && (nWidth != mnWidth) )
 168             {
 169                 mnWidth = nWidth;
 170                 mbOptimalWidth = mnWidth == 0;
 171                 bChange = true;
 172             }
 173             break;
 174         }
 175     case Property_OptimalWidth:
 176         {
 177             bool bOptimalWidth = mbOptimalWidth;
 178             bOk = aValue >>= bOptimalWidth;
 179             if( bOk && (mbOptimalWidth != bOptimalWidth) )
 180             {
 181                 mbOptimalWidth = bOptimalWidth;
 182                 if( bOptimalWidth )
 183                     mnWidth = 0;
 184                 bChange = true;
 185             }
 186             break;
 187         }
 188     case Property_IsVisible:
 189         {
 190             bool bIsVisible = mbIsVisible;
 191             bOk = aValue >>= bIsVisible;
 192             if( bOk && (mbIsVisible != bIsVisible) )
 193             {
 194                 mbIsVisible = bIsVisible;
 195                 bChange = true;
 196             }
 197             break;
 198         }
 199
 200     case Property_IsStartOfNewPage:
 201         {
 202             bool bIsStartOfNewPage = mbIsStartOfNewPage;
 203             bOk = aValue >>= bIsStartOfNewPage;
 204             if( bOk && (mbIsStartOfNewPage != bIsStartOfNewPage) )
 205             {
 206                 mbIsStartOfNewPage = bIsStartOfNewPage;
 207                 bChange = true;
 208             }
 209             break;
 210         }
 211     default:
 212         delete pUndo;
 213         throw UnknownPropertyException();
 214     }
 215     if( !bOk )
 216     {
 217         delete pUndo;
 218         throw IllegalArgumentException();
 219     }
 220
 221     if( bChange )
 222     {
 223         if( pUndo )
 224         {
 225             pModel->AddUndo( pUndo );
 226             pUndo = 0;
 227         }
 228         mxTableModel->setModified(sal_True);
 229     }
 230
 231     delete pUndo;
 232 }
 233
 234
 235
 236 Any SAL_CALL TableColumn::getFastPropertyValue( sal_Int32 nHandle ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 237 {
 238     switch( nHandle )
 239     {
 240     case Property_Width:            return Any( mnWidth );
 241     case Property_OptimalWidth:     return Any( mbOptimalWidth );
 242     case Property_IsVisible:        return Any( mbIsVisible );
 243     case Property_IsStartOfNewPage: return Any( mbIsStartOfNewPage );
 244     default:                        throw UnknownPropertyException();
 245     }
 246 }
 247
 248
 249
 250 rtl::Reference< FastPropertySetInfo > TableColumn::getStaticPropertySetInfo()
 251 {
 252     static rtl::Reference< FastPropertySetInfo > xInfo;
 253     if( !xInfo.is() )
 254     {
 255         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 256         if( !xInfo.is() )
 257         {
 258             PropertyVector aProperties(6);
 259
 260             aProperties[0].Name = "Width";
 261             aProperties[0].Handle = Property_Width;
 262             aProperties[0].Type = ::cppu::UnoType<sal_Int32>::get();
 263             aProperties[0].Attributes = 0;
 264
 265             aProperties[1].Name = "OptimalWidth";
 266             aProperties[1].Handle = Property_OptimalWidth;
 267             aProperties[1].Type = cppu::UnoType<bool>::get();
 268             aProperties[1].Attributes = 0;
 269
 270             aProperties[2].Name = "IsVisible";
 271             aProperties[2].Handle = Property_IsVisible;
 272             aProperties[2].Type = cppu::UnoType<bool>::get();
 273             aProperties[2].Attributes = 0;
 274
 275             aProperties[3].Name = "IsStartOfNewPage";
 276             aProperties[3].Handle = Property_IsStartOfNewPage;
 277             aProperties[3].Type = cppu::UnoType<bool>::get();
 278             aProperties[3].Attributes = 0;
 279
 280             aProperties[4].Name = "Size";
 281             aProperties[4].Handle = Property_Width;
 282             aProperties[4].Type = ::cppu::UnoType<sal_Int32>::get();
 283             aProperties[4].Attributes = 0;
 284
 285             aProperties[5].Name = "OptimalSize";
 286             aProperties[5].Handle = Property_OptimalWidth;
 287             aProperties[5].Type = cppu::UnoType<bool>::get();
 288             aProperties[5].Attributes = 0;
 289
 290             xInfo.set( new FastPropertySetInfo(aProperties) );
 291         }
 292     }
 293
 294     return xInfo;
 295 }
 296
 297
 298
 299 } }
 300
 301 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */