LCOV - code coverage report
Current view: top level - svx/source/xoutdev - xtable.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 153 0.0 %
Date: 2014-04-14 Functions: 0 34 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <svx/XPropertyTable.hxx>
      21             : #include "xmlxtexp.hxx"
      22             : #include "xmlxtimp.hxx"
      23             : #include <tools/urlobj.hxx>
      24             : #include <svx/xtable.hxx>
      25             : #include <svx/xpool.hxx>
      26             : #include <svx/svdobj.hxx>
      27             : #include <svx/svdpool.hxx>
      28             : 
      29             : using namespace com::sun::star;
      30             : 
      31             : // Helper for other sub-classes to have easy-to-read constructors
      32           0 : Color RGB_Color( ColorData nColorName )
      33             : {
      34           0 :     Color aColor( nColorName );
      35           0 :     Color aRGBColor( aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue() );
      36           0 :     return aRGBColor;
      37             : }
      38             : 
      39             : // class XColorEntry
      40             : 
      41           0 : XColorEntry::XColorEntry(const Color& rColor, const OUString& rName)
      42             : :   XPropertyEntry(rName),
      43           0 :     aColor(rColor)
      44             : {
      45           0 : }
      46             : 
      47           0 : XColorEntry::XColorEntry(const XColorEntry& rOther)
      48             : :   XPropertyEntry(rOther),
      49           0 : aColor(rOther.aColor)
      50             : {
      51           0 : }
      52             : 
      53             : // class XLineEndEntry
      54             : 
      55           0 : XLineEndEntry::XLineEndEntry(const basegfx::B2DPolyPolygon& rB2DPolyPolygon, const OUString& rName)
      56             : :   XPropertyEntry(rName),
      57           0 :     aB2DPolyPolygon(rB2DPolyPolygon)
      58             : {
      59           0 : }
      60             : 
      61           0 : XLineEndEntry::XLineEndEntry(const XLineEndEntry& rOther)
      62             : :   XPropertyEntry(rOther),
      63           0 :     aB2DPolyPolygon(rOther.aB2DPolyPolygon)
      64             : {
      65           0 : }
      66             : 
      67             : // class XDashEntry
      68             : 
      69           0 : XDashEntry::XDashEntry(const XDash& rDash, const OUString& rName)
      70             : :   XPropertyEntry(rName),
      71           0 :     aDash(rDash)
      72             : {
      73           0 : }
      74             : 
      75           0 : XDashEntry::XDashEntry(const XDashEntry& rOther)
      76             : :   XPropertyEntry(rOther),
      77           0 : aDash(rOther.aDash)
      78             : {
      79           0 : }
      80             : 
      81             : // class XHatchEntry
      82             : 
      83           0 : XHatchEntry::XHatchEntry(const XHatch& rHatch, const OUString& rName)
      84             : :   XPropertyEntry(rName),
      85           0 :     aHatch(rHatch)
      86             : {
      87           0 : }
      88             : 
      89           0 : XHatchEntry::XHatchEntry(const XHatchEntry& rOther)
      90             : :   XPropertyEntry(rOther),
      91           0 :     aHatch(rOther.aHatch)
      92             : {
      93           0 : }
      94             : 
      95             : // class XGradientEntry
      96             : 
      97           0 : XGradientEntry::XGradientEntry(const XGradient& rGradient, const OUString& rName)
      98             : :   XPropertyEntry(rName),
      99           0 :     aGradient(rGradient)
     100             : {
     101           0 : }
     102             : 
     103           0 : XGradientEntry::XGradientEntry(const XGradientEntry& rOther)
     104             : :   XPropertyEntry(rOther),
     105           0 :     aGradient(rOther.aGradient)
     106             : {
     107           0 : }
     108             : 
     109             : // class XBitmapEntry
     110             : 
     111           0 : XBitmapEntry::XBitmapEntry(const GraphicObject& rGraphicObject, const OUString& rName)
     112             : :   XPropertyEntry(rName),
     113           0 :     maGraphicObject(rGraphicObject)
     114             : {
     115           0 : }
     116             : 
     117           0 : XBitmapEntry::XBitmapEntry(const XBitmapEntry& rOther)
     118             : :   XPropertyEntry(rOther),
     119           0 :     maGraphicObject(rOther.maGraphicObject)
     120             : {
     121           0 : }
     122             : 
     123           0 : XPropertyList::XPropertyList(
     124             :     XPropertyListType type,
     125             :     const OUString& rPath, const OUString& rReferer
     126             : ) : meType           ( type ),
     127             :     maName           ( "standard" ),
     128             :     maPath           ( rPath ),
     129             :     maReferer        ( rReferer ),
     130             :     mbListDirty      ( true ),
     131           0 :     mbEmbedInDocument( false )
     132             : {
     133             : //    fprintf (stderr, "Create type %d count %d\n", (int)meType, count++);
     134           0 : }
     135             : 
     136           0 : XPropertyList::~XPropertyList()
     137             : {
     138             : //    fprintf (stderr, "Destroy type %d count %d\n", (int)meType, --count);
     139           0 :     for( size_t i = 0, n = maList.size(); i < n; ++i )
     140           0 :         delete maList[ i ];
     141             : 
     142           0 :     maList.clear();
     143           0 : }
     144             : 
     145           0 : long XPropertyList::Count() const
     146             : {
     147           0 :     if( mbListDirty )
     148             :     {
     149           0 :         if( !( (XPropertyList*) this )->Load() )
     150           0 :             ( (XPropertyList*) this )->Create();
     151             :     }
     152           0 :     return maList.size();
     153             : }
     154             : 
     155           0 : XPropertyEntry* XPropertyList::Get( long nIndex ) const
     156             : {
     157           0 :     if( mbListDirty )
     158             :     {
     159           0 :         if( !( (XPropertyList*) this )->Load() )
     160           0 :             ( (XPropertyList*) this )->Create();
     161             :     }
     162           0 :     return ( (size_t)nIndex < maList.size() ) ? maList[ nIndex ] : NULL;
     163             : }
     164             : 
     165           0 : long XPropertyList::GetIndex(const OUString& rName) const
     166             : {
     167           0 :     if( mbListDirty )
     168             :     {
     169           0 :         if( !( (XPropertyList*) this )->Load() )
     170           0 :             ( (XPropertyList*) this )->Create();
     171             :     }
     172             : 
     173           0 :     for( long i = 0, n = maList.size(); i < n; ++i ) {
     174           0 :         if (rName.equals(maList[ i ]->GetName())) {
     175           0 :             return i;
     176             :         }
     177             :     }
     178           0 :     return -1;
     179             : }
     180             : 
     181           0 : Bitmap XPropertyList::GetUiBitmap( long nIndex ) const
     182             : {
     183           0 :     Bitmap aRetval;
     184           0 :     XPropertyEntry* pEntry = ( (size_t)nIndex < maList.size() ) ? maList[ nIndex ] : NULL;
     185           0 :     if(pEntry)
     186             :     {
     187           0 :         aRetval = pEntry->GetUiBitmap();
     188             : 
     189           0 :         if(aRetval.IsEmpty())
     190             :         {
     191           0 :             aRetval = const_cast< XPropertyList* >(this)->CreateBitmapForUI(nIndex);
     192           0 :             pEntry->SetUiBitmap(aRetval);
     193             :         }
     194             :     }
     195           0 :     return aRetval;
     196             : }
     197             : 
     198           0 : void XPropertyList::Insert( XPropertyEntry* pEntry, long nIndex )
     199             : {
     200           0 :     if ( (size_t)nIndex < maList.size() ) {
     201           0 :         maList.insert( maList.begin() + nIndex, pEntry );
     202             :     } else {
     203           0 :         maList.push_back( pEntry );
     204             :     }
     205           0 : }
     206             : 
     207           0 : XPropertyEntry* XPropertyList::Replace( XPropertyEntry* pEntry, long nIndex )
     208             : {
     209           0 :     XPropertyEntry* pOldEntry = (size_t)nIndex < maList.size() ? maList[ nIndex ] : NULL;
     210           0 :     if ( pOldEntry ) {
     211           0 :         maList[ nIndex ] = pEntry;
     212             :     }
     213           0 :     return pOldEntry;
     214             : }
     215             : 
     216           0 : XPropertyEntry* XPropertyList::Remove( long nIndex )
     217             : {
     218           0 :     XPropertyEntry* pEntry = NULL;
     219           0 :     if ( (size_t)nIndex < maList.size() ) {
     220           0 :         pEntry = maList[ nIndex ];
     221           0 :         maList.erase( maList.begin() + nIndex );
     222             :     }
     223           0 :     return pEntry;
     224             : }
     225             : 
     226           0 : void XPropertyList::SetName( const OUString& rString )
     227             : {
     228           0 :     if(!rString.isEmpty())
     229             :     {
     230           0 :         maName = rString;
     231             :     }
     232           0 : }
     233             : 
     234           0 : bool XPropertyList::Load()
     235             : {
     236           0 :     if( mbListDirty )
     237             :     {
     238           0 :         mbListDirty = false;
     239             : 
     240           0 :         INetURLObject aURL( maPath );
     241             : 
     242           0 :         if( INET_PROT_NOT_VALID == aURL.GetProtocol() )
     243             :         {
     244             :             DBG_ASSERT( maPath.isEmpty(), "invalid URL" );
     245           0 :             return false;
     246             :         }
     247             : 
     248           0 :         aURL.Append( maName );
     249             : 
     250           0 :         if( aURL.getExtension().isEmpty() )
     251           0 :             aURL.setExtension( GetDefaultExt() );
     252             : 
     253             :         return SvxXMLXTableImport::load( aURL.GetMainURL( INetURLObject::NO_DECODE ), maReferer,
     254             :                                          uno::Reference < embed::XStorage >(),
     255           0 :                                          createInstance(), NULL );
     256             :     }
     257           0 :     return false;
     258             : }
     259             : 
     260           0 : bool XPropertyList::LoadFrom( const uno::Reference < embed::XStorage > &xStorage,
     261             :                               const OUString &rURL, const OUString &rReferer )
     262             : {
     263           0 :     if( !mbListDirty )
     264           0 :         return false;
     265           0 :     mbListDirty = false;
     266           0 :     return SvxXMLXTableImport::load( rURL, rReferer, xStorage, createInstance(), &mbEmbedInDocument );
     267             : }
     268             : 
     269           0 : bool XPropertyList::Save()
     270             : {
     271           0 :     INetURLObject aURL( maPath );
     272             : 
     273           0 :     if( INET_PROT_NOT_VALID == aURL.GetProtocol() )
     274             :     {
     275             :         DBG_ASSERT( maPath.isEmpty(), "invalid URL" );
     276           0 :         return false;
     277             :     }
     278             : 
     279           0 :     aURL.Append( maName );
     280             : 
     281           0 :     if( aURL.getExtension().isEmpty() )
     282           0 :         aURL.setExtension( GetDefaultExt() );
     283             : 
     284             :     return SvxXMLXTableExportComponent::save( aURL.GetMainURL( INetURLObject::NO_DECODE ),
     285           0 :                                               createInstance(),
     286           0 :                                               uno::Reference< embed::XStorage >(), NULL );
     287             : }
     288             : 
     289           0 : bool XPropertyList::SaveTo( const uno::Reference< embed::XStorage > &xStorage,
     290             :                             const OUString &rURL, OUString *pOptName )
     291             : {
     292           0 :     return SvxXMLXTableExportComponent::save( rURL, createInstance(), xStorage, pOptName );
     293             : }
     294             : 
     295           0 : XPropertyListRef XPropertyList::CreatePropertyList( XPropertyListType t,
     296             :                                                     const OUString& rPath,
     297             :                                                     const OUString& rReferer )
     298             : {
     299           0 :     XPropertyListRef pRet;
     300             : 
     301             : #define MAP(e,c) \
     302             :         case e: pRet = XPropertyListRef (new c( rPath, rReferer ) ); break
     303           0 :     switch (t) {
     304           0 :         MAP( XCOLOR_LIST, XColorList );
     305           0 :         MAP( XLINE_END_LIST, XLineEndList );
     306           0 :         MAP( XDASH_LIST, XDashList );
     307           0 :         MAP( XHATCH_LIST, XHatchList );
     308           0 :         MAP( XGRADIENT_LIST, XGradientList );
     309           0 :         MAP( XBITMAP_LIST, XBitmapList );
     310             :     default:
     311             :         OSL_FAIL("unknown xproperty type");
     312           0 :         break;
     313             :     }
     314             : #undef MAP
     315             :     OSL_ASSERT( !pRet.is() || pRet->meType == t );
     316             : 
     317           0 :     return pRet;
     318             : }
     319             : 
     320             : XPropertyListRef
     321           0 : XPropertyList::CreatePropertyListFromURL( XPropertyListType t,
     322             :                                           const OUString & rURLStr )
     323             : {
     324           0 :     INetURLObject aURL( rURLStr );
     325           0 :     INetURLObject aPathURL( aURL );
     326             : 
     327           0 :     aPathURL.removeSegment();
     328           0 :     aPathURL.removeFinalSlash();
     329             : 
     330             :     XPropertyListRef pList = XPropertyList::CreatePropertyList(
     331           0 :         t, aPathURL.GetMainURL( INetURLObject::NO_DECODE ), "" );
     332           0 :     pList->SetName( aURL.getName() );
     333             : 
     334           0 :     return pList;
     335             : }
     336             : 
     337             : // catch people being silly with ref counting ...
     338             : 
     339           0 : void* XPropertyList::operator new (size_t nCount)
     340             : {
     341           0 :     return rtl_allocateMemory( nCount );
     342             : }
     343             : 
     344           0 : void XPropertyList::operator delete(void *pPtr)
     345             : {
     346           0 :     return rtl_freeMemory( pPtr );
     347             : }
     348             : 
     349             : static struct {
     350             :     XPropertyListType t;
     351             :     const char *pExt;
     352             : } pExtnMap[] = {
     353             :     { XCOLOR_LIST,    "soc" },
     354             :     { XLINE_END_LIST, "soe" },
     355             :     { XDASH_LIST,     "sod" },
     356             :     { XHATCH_LIST,    "soh" },
     357             :     { XGRADIENT_LIST, "sog" },
     358             :     { XBITMAP_LIST,   "sob" }
     359             : };
     360             : 
     361           0 : OUString XPropertyList::GetDefaultExt( XPropertyListType t )
     362             : {
     363           0 :     for (size_t i = 0; i < SAL_N_ELEMENTS (pExtnMap); i++)
     364             :     {
     365           0 :         if( pExtnMap[i].t == t )
     366           0 :             return OUString::createFromAscii( pExtnMap[ i ].pExt );
     367             :     }
     368           0 :     return OUString();
     369             : }
     370             : 
     371           0 : OUString XPropertyList::GetDefaultExtFilter( XPropertyListType t )
     372             : {
     373           0 :     OUString aFilter( "*." );
     374           0 :     return aFilter + GetDefaultExt( t );
     375             : }
     376             : 
     377             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10