svx/source/xoutdev/xtable.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 <memory>
  21 #include <utility>
  22 #include <xmlxtexp.hxx>
  23 #include <xmlxtimp.hxx>
  24 #include <o3tl/safeint.hxx>
  25 #include <osl/diagnose.h>
  26 #include <tools/urlobj.hxx>
  27 #include <svx/xtable.hxx>
  28 #include <tools/debug.hxx>
  29 #include <stack>
  30
  31 using namespace com::sun::star;
  32
  33 XColorEntry::XColorEntry(const Color& rColor, const OUString& rName)
  34 :   XPropertyEntry(rName),
  35     aColor(rColor)
  36 {
  37 }
  38
  39 XLineEndEntry::XLineEndEntry(basegfx::B2DPolyPolygon _aB2DPolyPolygon, const OUString& rName)
  40 :   XPropertyEntry(rName),
  41     aB2DPolyPolygon(std::move(_aB2DPolyPolygon))
  42 {
  43 }
  44
  45 XLineEndEntry::XLineEndEntry(const XLineEndEntry& rOther)
  46 :   XPropertyEntry(rOther),
  47     aB2DPolyPolygon(rOther.aB2DPolyPolygon)
  48 {
  49 }
  50
  51 XDashEntry::XDashEntry(const XDash& rDash, const OUString& rName)
  52 :   XPropertyEntry(rName),
  53     aDash(rDash)
  54 {
  55 }
  56
  57 XDashEntry::XDashEntry(const XDashEntry& rOther)
  58 :   XPropertyEntry(rOther),
  59 aDash(rOther.aDash)
  60 {
  61 }
  62
  63 XHatchEntry::XHatchEntry(const XHatch& rHatch, const OUString& rName)
  64 :   XPropertyEntry(rName),
  65     aHatch(rHatch)
  66 {
  67 }
  68
  69 XHatchEntry::XHatchEntry(const XHatchEntry& rOther)
  70 :   XPropertyEntry(rOther),
  71     aHatch(rOther.aHatch)
  72 {
  73 }
  74
  75 XGradientEntry::XGradientEntry(const basegfx::BGradient& rGradient, const OUString& rName)
  76 :   XPropertyEntry(rName),
  77     aGradient(rGradient)
  78 {
  79 }
  80
  81 XGradientEntry::XGradientEntry(const XGradientEntry& rOther)
  82 :   XPropertyEntry(rOther),
  83     aGradient(rOther.aGradient)
  84 {
  85 }
  86
  87 XBitmapEntry::XBitmapEntry(const GraphicObject& rGraphicObject, const OUString& rName)
  88 :   XPropertyEntry(rName),
  89     maGraphicObject(rGraphicObject)
  90 {
  91 }
  92
  93 XBitmapEntry::XBitmapEntry(const XBitmapEntry& rOther)
  94 :   XPropertyEntry(rOther),
  95     maGraphicObject(rOther.maGraphicObject)
  96 {
  97 }
  98
  99 XPropertyList::XPropertyList(
 100     XPropertyListType type,
 101     OUString aPath, OUString aReferer
 102 ) : meType           ( type ),
 103     maName           ( "standard" ),
 104     maPath           (std::move( aPath )),
 105     maReferer        (std::move( aReferer )),
 106     mbListDirty      ( true ),
 107     mbEmbedInDocument( false )
 108 {
 109 //    fprintf (stderr, "Create type %d count %d\n", (int)meType, count++);
 110 }
 111
 112 bool XPropertyList::isValidIdx(tools::Long nIndex) const
 113 {
 114     return (nIndex >= 0 && o3tl::make_unsigned(nIndex) < maList.size());
 115 }
 116
 117
 118 XPropertyList::~XPropertyList()
 119 {
 120 }
 121
 122 tools::Long XPropertyList::Count() const
 123 {
 124     if( mbListDirty )
 125     {
 126         if( !const_cast<XPropertyList*>(this)->Load() )
 127             const_cast<XPropertyList*>(this)->Create();
 128     }
 129     return maList.size();
 130 }
 131
 132 XPropertyEntry* XPropertyList::Get( tools::Long nIndex ) const
 133 {
 134     if( mbListDirty )
 135     {
 136         if( !const_cast<XPropertyList*>(this)->Load() )
 137             const_cast<XPropertyList*>(this)->Create();
 138     }
 139     if (!isValidIdx(nIndex))
 140         return nullptr;
 141
 142     return maList[nIndex].get();
 143 }
 144
 145 tools::Long XPropertyList::GetIndex(std::u16string_view rName) const
 146 {
 147     if( mbListDirty )
 148     {
 149         if( !const_cast<XPropertyList*>(this)->Load() )
 150             const_cast<XPropertyList*>(this)->Create();
 151     }
 152
 153     for( tools::Long i = 0, n = maList.size(); i < n; ++i ) {
 154         if (rName == maList[ i ]->GetName()) {
 155             return i;
 156         }
 157     }
 158     return -1;
 159 }
 160
 161 BitmapEx XPropertyList::GetUiBitmap( tools::Long nIndex ) const
 162 {
 163     BitmapEx aRetval;
 164     if (!isValidIdx(nIndex))
 165         return aRetval;
 166
 167     XPropertyEntry* pEntry = maList[nIndex].get();
 168     aRetval = pEntry->GetUiBitmap();
 169
 170     if(aRetval.IsEmpty())
 171     {
 172         aRetval = const_cast< XPropertyList* >(this)->CreateBitmapForUI(nIndex);
 173         pEntry->SetUiBitmap(aRetval);
 174     }
 175     return aRetval;
 176 }
 177
 178 void XPropertyList::Insert(std::unique_ptr<XPropertyEntry> pEntry, tools::Long nIndex)
 179 {
 180     if (!pEntry)
 181     {
 182         assert(!"empty XPropertyEntry not allowed in XPropertyList");
 183         return;
 184     }
 185
 186     if (isValidIdx(nIndex)) {
 187         maList.insert( maList.begin()+nIndex, std::move(pEntry) );
 188     } else {
 189         maList.push_back( std::move(pEntry) );
 190     }
 191 }
 192
 193 void XPropertyList::Replace(std::unique_ptr<XPropertyEntry> pEntry, tools::Long nIndex)
 194 {
 195     if (!pEntry)
 196     {
 197         assert(!"empty XPropertyEntry not allowed in XPropertyList");
 198         return;
 199     }
 200     if (!isValidIdx(nIndex))
 201     {
 202         assert(!"trying to replace invalid entry in XPropertyList");
 203         return;
 204     }
 205
 206     maList[nIndex] = std::move(pEntry);
 207 }
 208
 209 void XPropertyList::Remove(tools::Long nIndex)
 210 {
 211     if (!isValidIdx(nIndex))
 212     {
 213         assert(!"trying to remove invalid entry in XPropertyList");
 214         return;
 215     }
 216
 217     maList.erase(maList.begin() + nIndex);
 218 }
 219
 220 void XPropertyList::SetName( const OUString& rString )
 221 {
 222     if(!rString.isEmpty())
 223     {
 224         maName = rString;
 225     }
 226 }
 227
 228 bool XPropertyList::Load()
 229 {
 230     if( mbListDirty )
 231     {
 232         mbListDirty = false;
 233         std::stack<OUString> aDirs;
 234
 235         sal_Int32 nIndex = 0;
 236         do
 237         {
 238             aDirs.push(maPath.getToken(0, ';', nIndex));
 239         }
 240         while (nIndex >= 0);
 241
 242         //try all entries palette path list working back to front until one
 243         //succeeds
 244         while (!aDirs.empty())
 245         {
 246             OUString aPath(aDirs.top());
 247             aDirs.pop();
 248
 249             INetURLObject aURL(aPath);
 250
 251             if( INetProtocol::NotValid == aURL.GetProtocol() )
 252             {
 253                 DBG_ASSERT( aPath.isEmpty(), "invalid URL" );
 254                 return false;
 255             }
 256
 257             aURL.Append( maName );
 258
 259             if( aURL.getExtension().isEmpty() )
 260                 aURL.setExtension( GetDefaultExt() );
 261
 262             bool bRet = SvxXMLXTableImport::load(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),
 263                                              maReferer, uno::Reference < embed::XStorage >(),
 264                                              createInstance(), nullptr );
 265             if (bRet)
 266                 return bRet;
 267         }
 268     }
 269     return false;
 270 }
 271
 272 bool XPropertyList::LoadFrom( const uno::Reference < embed::XStorage > &xStorage,
 273                               const OUString &rURL, const OUString &rReferer )
 274 {
 275     if( !mbListDirty )
 276         return false;
 277     mbListDirty = false;
 278     return SvxXMLXTableImport::load( rURL, rReferer, xStorage, createInstance(), &mbEmbedInDocument );
 279 }
 280
 281 bool XPropertyList::Save()
 282 {
 283     //save to the last path in the palette path list
 284     OUString aLastDir;
 285     sal_Int32 nIndex = 0;
 286     do
 287     {
 288         aLastDir = maPath.getToken(0, ';', nIndex);
 289     }
 290     while (nIndex >= 0);
 291
 292     INetURLObject aURL(aLastDir);
 293
 294     if( INetProtocol::NotValid == aURL.GetProtocol() )
 295     {
 296         DBG_ASSERT( aLastDir.isEmpty(), "invalid URL" );
 297         return false;
 298     }
 299
 300     aURL.Append( maName );
 301
 302     if( aURL.getExtension().isEmpty() )
 303         aURL.setExtension( GetDefaultExt() );
 304
 305     return SvxXMLXTableExportComponent::save( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ),
 306                                               createInstance(),
 307                                               uno::Reference< embed::XStorage >(), nullptr );
 308 }
 309
 310 bool XPropertyList::SaveTo( const uno::Reference< embed::XStorage > &xStorage,
 311                             const OUString &rURL, OUString *pOptName )
 312 {
 313     return SvxXMLXTableExportComponent::save( rURL, createInstance(), xStorage, pOptName );
 314 }
 315
 316 XPropertyListRef XPropertyList::CreatePropertyList( XPropertyListType aType,
 317                                                     const OUString& rPath,
 318                                                     const OUString& rReferer )
 319 {
 320     XPropertyListRef pRet;
 321
 322     switch (aType) {
 323         case XPropertyListType::Color:
 324             pRet = XPropertyListRef(new XColorList(rPath, rReferer));
 325             break;
 326         case XPropertyListType::LineEnd:
 327             pRet = XPropertyListRef(new XLineEndList(rPath, rReferer));
 328             break;
 329         case XPropertyListType::Dash:
 330             pRet = XPropertyListRef(new XDashList(rPath, rReferer));
 331             break;
 332         case XPropertyListType::Hatch:
 333             pRet = XPropertyListRef(new XHatchList(rPath, rReferer));
 334             break;
 335         case XPropertyListType::Gradient:
 336             pRet = XPropertyListRef(new XGradientList(rPath, rReferer));
 337             break;
 338         case XPropertyListType::Bitmap:
 339             pRet = XPropertyListRef(new XBitmapList(rPath, rReferer));
 340             break;
 341         case XPropertyListType::Pattern:
 342             pRet = XPropertyListRef(new XPatternList(rPath, rReferer));
 343             break;
 344     default:
 345         OSL_FAIL("unknown xproperty type");
 346         break;
 347     }
 348     OSL_ASSERT( !pRet.is() || pRet->meType == aType );
 349
 350     return pRet;
 351 }
 352
 353 XPropertyListRef
 354 XPropertyList::CreatePropertyListFromURL( XPropertyListType t,
 355                                           std::u16string_view rURLStr )
 356 {
 357     INetURLObject aURL( rURLStr );
 358     INetURLObject aPathURL( aURL );
 359
 360     aPathURL.removeSegment();
 361     aPathURL.removeFinalSlash();
 362
 363     XPropertyListRef pList = XPropertyList::CreatePropertyList(
 364         t, aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), "" );
 365     pList->SetName( aURL.getName() );
 366
 367     return pList;
 368 }
 369
 370 struct {
 371     XPropertyListType t;
 372     const char *pExt;
 373 } const pExtnMap[] = {
 374     { XPropertyListType::Color,    "soc" },
 375     { XPropertyListType::LineEnd, "soe" },
 376     { XPropertyListType::Dash,     "sod" },
 377     { XPropertyListType::Hatch,    "soh" },
 378     { XPropertyListType::Gradient, "sog" },
 379     { XPropertyListType::Bitmap,   "sob" },
 380     { XPropertyListType::Pattern,  "sop"}
 381 };
 382
 383 OUString XPropertyList::GetDefaultExt( XPropertyListType t )
 384 {
 385     for (const auto & i : pExtnMap)
 386     {
 387         if( i.t == t )
 388             return OUString::createFromAscii( i.pExt );
 389     }
 390     return OUString();
 391 }
 392
 393 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */