svx/source/xoutdev/xtable.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <svx/XPropertyTable.hxx>
  31 #include "xmlxtexp.hxx"
  32 #include "xmlxtimp.hxx"
  33 #include <tools/urlobj.hxx>
  34 #include <svx/xtable.hxx>
  35 #include <svx/xpool.hxx>
  36
  37 using namespace com::sun::star;
  38
  39 // Helper for other sub-classes to have easy-to-read constructors
  40 Color RGB_Color( ColorData nColorName )
  41 {
  42     Color aColor( nColorName );
  43     Color aRGBColor( aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue() );
  44     return aRGBColor;
  45 }
  46
  47 // static int count = 0;
  48
  49 XPropertyList::XPropertyList(
  50     XPropertyListType type,
  51     const String& rPath,
  52     XOutdevItemPool* pInPool
  53 ) : eType           ( type ),
  54     aName           ( RTL_CONSTASCII_USTRINGPARAM( "standard" ) ),
  55     aPath           ( rPath ),
  56     pXPool          ( pInPool ),
  57     pBmpList        ( NULL ),
  58     bListDirty      ( true ),
  59     bBitmapsDirty   ( true ),
  60     bOwnPool        ( false ),
  61     bEmbedInDocument( false )
  62 {
  63     if( !pXPool )
  64     {
  65         bOwnPool = true;
  66         pXPool = new XOutdevItemPool;
  67         DBG_ASSERT( pXPool, "XOutPool konnte nicht erzeugt werden!" );
  68     }
  69 //    fprintf (stderr, "Create type %d count %d\n", (int)eType, count++);
  70 }
  71
  72 XPropertyList::~XPropertyList()
  73 {
  74 //    fprintf (stderr, "Destroy type %d count %d\n", (int)eType, --count);
  75     for( size_t i = 0, n = aList.size(); i < n; ++i )
  76         delete aList[ i ];
  77
  78     aList.clear();
  79
  80     if( pBmpList )
  81     {
  82         for ( size_t i = 0, n = pBmpList->size(); i < n; ++i ) {
  83             delete (*pBmpList)[ i ];
  84         }
  85         pBmpList->clear();
  86         delete pBmpList;
  87         pBmpList = NULL;
  88     }
  89
  90     if( bOwnPool && pXPool )
  91         SfxItemPool::Free(pXPool);
  92 }
  93
  94 long XPropertyList::Count() const
  95 {
  96     if( bListDirty )
  97     {
  98         if( !( (XPropertyList*) this )->Load() )
  99             ( (XPropertyList*) this )->Create();
 100     }
 101     return( aList.size() );
 102 }
 103
 104 XPropertyEntry* XPropertyList::Get( long nIndex, sal_uInt16 /*nDummy*/) const
 105 {
 106     if( bListDirty )
 107     {
 108         if( !( (XPropertyList*) this )->Load() )
 109             ( (XPropertyList*) this )->Create();
 110     }
 111     return ( (size_t)nIndex < aList.size() ) ? aList[ nIndex ] : NULL;
 112 }
 113
 114 long XPropertyList::Get(const XubString& rName)
 115 {
 116     if( bListDirty )
 117     {
 118         if( !Load() )
 119             Create();
 120     }
 121
 122     for( long i = 0, n = aList.size(); i < n; ++i ) {
 123         if ( aList[ i ]->GetName() == rName ) {
 124             return i;
 125         }
 126     }
 127     return -1;
 128 }
 129
 130 Bitmap* XPropertyList::GetBitmap( long nIndex ) const
 131 {
 132     if( pBmpList )
 133     {
 134         if( bBitmapsDirty )
 135         {
 136             ( (XPropertyList*) this )->bBitmapsDirty = false;
 137             ( (XPropertyList*) this )->CreateBitmapsForUI();
 138         }
 139         if( (size_t)nIndex < pBmpList->size() )
 140             return (*pBmpList)[ nIndex ];
 141     }
 142     return NULL;
 143 }
 144
 145 void XPropertyList::Insert( XPropertyEntry* pEntry, long nIndex )
 146 {
 147     if ( (size_t)nIndex < aList.size() ) {
 148         aList.insert( aList.begin() + nIndex, pEntry );
 149     } else {
 150         aList.push_back( pEntry );
 151     }
 152
 153     if( pBmpList && !bBitmapsDirty )
 154     {
 155         Bitmap* pBmp = CreateBitmapForUI(
 156             (size_t)nIndex < aList.size() ? nIndex : aList.size() - 1
 157         );
 158         if ( (size_t)nIndex < pBmpList->size() ) {
 159             pBmpList->insert( pBmpList->begin() + nIndex, pBmp );
 160         } else {
 161             pBmpList->push_back( pBmp );
 162         }
 163     }
 164 }
 165
 166 XPropertyEntry* XPropertyList::Replace( XPropertyEntry* pEntry, long nIndex )
 167 {
 168     XPropertyEntry* pOldEntry = (size_t)nIndex < aList.size() ? aList[ nIndex ] : NULL;
 169     if ( pOldEntry ) {
 170         aList[ nIndex ] = pEntry;
 171     }
 172
 173     if( pBmpList && !bBitmapsDirty )
 174     {
 175         Bitmap* pBmp = CreateBitmapForUI( (sal_uIntPtr) nIndex );
 176         if ( (size_t)nIndex < pBmpList->size() )
 177         {
 178             delete (*pBmpList)[ nIndex ];
 179             (*pBmpList)[ nIndex ] = pBmp;
 180         }
 181         else {
 182             pBmpList->push_back( pBmp );
 183         }
 184     }
 185     return pOldEntry;
 186 }
 187
 188 XPropertyEntry* XPropertyList::Remove( long nIndex )
 189 {
 190     if( pBmpList && !bBitmapsDirty )
 191     {
 192         if ( (size_t)nIndex < pBmpList->size() )
 193         {
 194             delete (*pBmpList)[ nIndex ];
 195             pBmpList->erase( pBmpList->begin() + nIndex );
 196         }
 197     }
 198
 199     XPropertyEntry* pEntry = NULL;
 200     if ( (size_t)nIndex < aList.size() ) {
 201         pEntry = aList[ nIndex ];
 202         aList.erase( aList.begin() + nIndex );
 203     }
 204     return pEntry;
 205 }
 206
 207 void XPropertyList::SetName( const String& rString )
 208 {
 209     if(rString.Len())
 210     {
 211         aName = rString;
 212     }
 213 }
 214
 215 bool XPropertyList::Load()
 216 {
 217     if( bListDirty )
 218     {
 219         bListDirty = false;
 220
 221         INetURLObject aURL( aPath );
 222
 223         if( INET_PROT_NOT_VALID == aURL.GetProtocol() )
 224         {
 225             DBG_ASSERT( !aPath.Len(), "invalid URL" );
 226             return false;
 227         }
 228
 229         aURL.Append( aName );
 230
 231         if( aURL.getExtension().isEmpty() )
 232             aURL.setExtension( GetDefaultExt() );
 233
 234         return SvxXMLXTableImport::load( aURL.GetMainURL( INetURLObject::NO_DECODE ),
 235                                          uno::Reference < embed::XStorage >(),
 236                                          createInstance(), NULL );
 237
 238     }
 239     return false;
 240 }
 241
 242 bool XPropertyList::LoadFrom( const uno::Reference < embed::XStorage > &xStorage,
 243                                   const rtl::OUString &rURL )
 244 {
 245     if( !bListDirty )
 246         return false;
 247     bListDirty = false;
 248     return SvxXMLXTableImport::load( rURL, xStorage, createInstance(), &bEmbedInDocument );
 249 }
 250
 251 bool XPropertyList::Save()
 252 {
 253     INetURLObject aURL( aPath );
 254
 255     if( INET_PROT_NOT_VALID == aURL.GetProtocol() )
 256     {
 257         DBG_ASSERT( !aPath.Len(), "invalid URL" );
 258         return false;
 259     }
 260
 261     aURL.Append( aName );
 262
 263     if( aURL.getExtension().isEmpty() )
 264         aURL.setExtension( GetDefaultExt() );
 265
 266     return SvxXMLXTableExportComponent::save( aURL.GetMainURL( INetURLObject::NO_DECODE ),
 267                                               createInstance(),
 268                                               uno::Reference< embed::XStorage >(), NULL );
 269 }
 270
 271 bool XPropertyList::SaveTo( const uno::Reference< embed::XStorage > &xStorage,
 272                             const rtl::OUString &rURL, rtl::OUString *pOptName )
 273 {
 274     return SvxXMLXTableExportComponent::save( rURL, createInstance(), xStorage, pOptName );
 275 }
 276
 277 XPropertyListRef XPropertyList::CreatePropertyList( XPropertyListType t,
 278                                                     const String& rPath,
 279                                                     XOutdevItemPool* pXPool )
 280 {
 281     XPropertyListRef pRet;
 282
 283 #define MAP(e,c) \
 284         case e: pRet = XPropertyListRef (new c( rPath, pXPool ) ); break
 285     switch (t) {
 286         MAP( XCOLOR_LIST, XColorList );
 287         MAP( XLINE_END_LIST, XLineEndList );
 288         MAP( XDASH_LIST, XDashList );
 289         MAP( XHATCH_LIST, XHatchList );
 290         MAP( XGRADIENT_LIST, XGradientList );
 291         MAP( XBITMAP_LIST, XBitmapList );
 292     default:
 293         OSL_FAIL("unknown xproperty type");
 294         break;
 295     }
 296 #undef MAP
 297     OSL_ASSERT( !pRet.is() || pRet->eType == t );
 298
 299     return pRet;
 300 }
 301
 302 XPropertyListRef
 303 XPropertyList::CreatePropertyListFromURL( XPropertyListType t,
 304                                           const rtl::OUString & rURLStr,
 305                                           XOutdevItemPool* pXPool )
 306 {
 307     INetURLObject aURL( rURLStr );
 308     INetURLObject aPathURL( aURL );
 309
 310     aPathURL.removeSegment();
 311     aPathURL.removeFinalSlash();
 312
 313     XPropertyListRef pList = XPropertyList::CreatePropertyList(
 314         t, aPathURL.GetMainURL( INetURLObject::NO_DECODE ), pXPool );
 315     pList->SetName( aURL.getName() );
 316
 317     return pList;
 318 }
 319
 320 // catch people being silly with ref counting ...
 321
 322 void* XPropertyList::operator new (size_t nCount)
 323 {
 324     return rtl_allocateMemory( nCount );
 325 }
 326
 327 void XPropertyList::operator delete(void *pPtr)
 328 {
 329     return rtl_freeMemory( pPtr );
 330 }
 331
 332 static struct {
 333     XPropertyListType t;
 334     const char *pExt;
 335 } pExtnMap[] = {
 336     { XCOLOR_LIST,    "soc" },
 337     { XLINE_END_LIST, "soe" },
 338     { XDASH_LIST,     "sod" },
 339     { XHATCH_LIST,    "soh" },
 340     { XGRADIENT_LIST, "sog" },
 341     { XBITMAP_LIST,   "sob" }
 342 };
 343
 344 rtl::OUString XPropertyList::GetDefaultExt( XPropertyListType t )
 345 {
 346     for (size_t i = 0; i < SAL_N_ELEMENTS (pExtnMap); i++)
 347     {
 348         if( pExtnMap[i].t == t )
 349             return rtl::OUString::createFromAscii( pExtnMap[ i ].pExt );
 350     }
 351     return rtl::OUString();
 352 }
 353
 354 rtl::OUString XPropertyList::GetDefaultExtFilter( XPropertyListType t )
 355 {
 356     rtl::OUString aFilter( RTL_CONSTASCII_USTRINGPARAM( "*." ) );
 357     return aFilter + GetDefaultExt( t );
 358 }
 359
 360 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */