sdext/source/presenter/PresenterConfigurationAccess.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PresenterConfigurationAccess.cxx,v $
  10  *
  11  * $Revision: 1.5 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sdext.hxx"
  34
  35 #include "PresenterConfigurationAccess.hxx"
  36
  37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  38 #include <com/sun/star/beans/PropertyValue.hpp>
  39 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  40 #include <com/sun/star/util/XChangesBatch.hpp>
  41
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::uno;
  44 using ::rtl::OUString;
  45
  46 #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString)))
  47
  48 namespace sdext { namespace presenter {
  49
  50 const ::rtl::OUString PresenterConfigurationAccess::msPresenterScreenRootName =
  51     A2S("/org.openoffice.Office.extension.PresenterScreen/");
  52
  53 PresenterConfigurationAccess::PresenterConfigurationAccess (
  54     const Reference<XComponentContext>& rxContext,
  55     const OUString& rsRootName,
  56     WriteMode eMode)
  57     : mxRoot(),
  58       maNode()
  59 {
  60     try
  61     {
  62         Reference<lang::XMultiComponentFactory> xFactory (rxContext->getServiceManager());
  63         if (xFactory.is())
  64         {
  65             Sequence<Any> aCreationArguments(3);
  66             aCreationArguments[0] = makeAny(beans::PropertyValue(
  67                 A2S("nodepath"),
  68                 0,
  69                 makeAny(rsRootName),
  70                 beans::PropertyState_DIRECT_VALUE));
  71             aCreationArguments[1] = makeAny(beans::PropertyValue(
  72                 A2S("depth"),
  73                 0,
  74                 makeAny((sal_Int32)-1),
  75                 beans::PropertyState_DIRECT_VALUE));
  76             aCreationArguments[2] = makeAny(beans::PropertyValue(
  77                 A2S("lazywrite"),
  78                 0,
  79                 makeAny(true),
  80                 beans::PropertyState_DIRECT_VALUE));
  81
  82             OUString sAccessService;
  83             if (eMode == READ_ONLY)
  84                 sAccessService = A2S("com.sun.star.configuration.ConfigurationAccess");
  85             else
  86                 sAccessService = A2S("com.sun.star.configuration.ConfigurationUpdateAccess");
  87
  88             Reference<lang::XMultiServiceFactory> xProvider (
  89                 xFactory->createInstanceWithContext(
  90                     A2S("com.sun.star.configuration.ConfigurationProvider"),
  91                     rxContext),
  92                 UNO_QUERY_THROW);
  93             mxRoot = xProvider->createInstanceWithArguments(
  94                 sAccessService, aCreationArguments);
  95             maNode <<= mxRoot;
  96         }
  97     }
  98     catch (Exception& rException)
  99     {
 100         OSL_TRACE ("caught exception while opening configuration: %s",
 101             ::rtl::OUStringToOString(rException.Message,
 102                 RTL_TEXTENCODING_UTF8).getStr());
 103     }
 104 }
 105
 106
 107
 108
 109 PresenterConfigurationAccess::~PresenterConfigurationAccess (void)
 110 {
 111 }
 112
 113
 114
 115
 116 bool PresenterConfigurationAccess::IsValid (void) const
 117 {
 118     return mxRoot.is();
 119 }
 120
 121
 122
 123
 124 Any PresenterConfigurationAccess::GetConfigurationNode (const OUString& sPathToNode)
 125 {
 126     return GetConfigurationNode(
 127         Reference<container::XHierarchicalNameAccess>(mxRoot, UNO_QUERY),
 128         sPathToNode);
 129 }
 130
 131
 132
 133
 134 Reference<beans::XPropertySet> PresenterConfigurationAccess::GetNodeProperties (
 135     const OUString& sPathToNode)
 136 {
 137     return GetNodeProperties(
 138         Reference<container::XHierarchicalNameAccess>(mxRoot, UNO_QUERY),
 139         sPathToNode);
 140 }
 141
 142
 143
 144
 145 bool PresenterConfigurationAccess::GoToChild (const ::rtl::OUString& rsPathToNode)
 146 {
 147     if ( ! IsValid())
 148         return false;
 149
 150     Reference<container::XHierarchicalNameAccess> xNode (maNode, UNO_QUERY);
 151     if (xNode.is())
 152     {
 153         maNode = GetConfigurationNode(
 154             Reference<container::XHierarchicalNameAccess>(maNode, UNO_QUERY),
 155             rsPathToNode);
 156         if (Reference<XInterface>(maNode, UNO_QUERY).is())
 157             return true;
 158     }
 159
 160     mxRoot = NULL;
 161     return false;
 162 }
 163
 164
 165
 166
 167 bool PresenterConfigurationAccess::GoToChild (const Predicate& rPredicate)
 168 {
 169     if ( ! IsValid())
 170         return false;
 171
 172     maNode = Find(Reference<container::XNameAccess>(maNode,UNO_QUERY), rPredicate);
 173     if (Reference<XInterface>(maNode, UNO_QUERY).is())
 174         return true;
 175
 176     mxRoot = NULL;
 177     return false;
 178 }
 179
 180
 181
 182
 183 bool PresenterConfigurationAccess::SetProperty (
 184     const ::rtl::OUString& rsPropertyName,
 185     const Any& rValue)
 186 {
 187     Reference<beans::XPropertySet> xProperties (maNode, UNO_QUERY);
 188     if (xProperties.is())
 189     {
 190         xProperties->setPropertyValue(rsPropertyName, rValue);
 191         return true;
 192     }
 193     else
 194         return false;
 195 }
 196
 197
 198
 199
 200 Any PresenterConfigurationAccess::GetConfigurationNode (
 201     const css::uno::Reference<css::container::XHierarchicalNameAccess>& rxNode,
 202     const OUString& sPathToNode)
 203 {
 204     if (sPathToNode.getLength() == 0)
 205         return Any(rxNode);
 206
 207     try
 208     {
 209         if (rxNode.is())
 210         {
 211             return rxNode->getByHierarchicalName(sPathToNode);
 212         }
 213     }
 214     catch (Exception& rException)
 215     {
 216         OSL_TRACE ("caught exception while getting configuration node %s: %s",
 217             ::rtl::OUStringToOString(sPathToNode, RTL_TEXTENCODING_UTF8).getStr(),
 218             ::rtl::OUStringToOString(rException.Message, RTL_TEXTENCODING_UTF8).getStr());
 219     }
 220
 221     return Any();
 222 }
 223
 224
 225
 226
 227 Reference<beans::XPropertySet> PresenterConfigurationAccess::GetNodeProperties (
 228     const css::uno::Reference<css::container::XHierarchicalNameAccess>& rxNode,
 229     const ::rtl::OUString& rsPathToNode)
 230 {
 231     return Reference<beans::XPropertySet>(GetConfigurationNode(rxNode, rsPathToNode), UNO_QUERY);
 232 }
 233
 234
 235
 236
 237 void PresenterConfigurationAccess::CommitChanges (void)
 238 {
 239     Reference<util::XChangesBatch> xConfiguration (mxRoot, UNO_QUERY);
 240     if (xConfiguration.is())
 241         xConfiguration->commitChanges();
 242 }
 243
 244
 245
 246
 247 Any PresenterConfigurationAccess::GetValue (const rtl::OUString& sKey)
 248 {
 249     Reference<container::XNameAccess> xAccess (GetConfigurationNode(sKey), UNO_QUERY);
 250     if (xAccess.is())
 251     {
 252         return xAccess->getByName(sKey);
 253     }
 254     else
 255     {
 256         return Any();
 257     }
 258 }
 259
 260
 261
 262
 263 void PresenterConfigurationAccess::ForAll (
 264     const Reference<container::XNameAccess>& rxContainer,
 265     const ::std::vector<OUString>& rArguments,
 266     const ItemProcessor& rProcessor)
 267 {
 268     if (rxContainer.is())
 269     {
 270         ::std::vector<Any> aValues(rArguments.size());
 271         Sequence<OUString> aKeys (rxContainer->getElementNames());
 272         for (sal_Int32 nItemIndex=0; nItemIndex<aKeys.getLength(); ++nItemIndex)
 273         {
 274             bool bHasAllValues (true);
 275             const OUString& rsKey (aKeys[nItemIndex]);
 276             Reference<container::XNameAccess> xSetItem (rxContainer->getByName(rsKey), UNO_QUERY);
 277             Reference<beans::XPropertySet> xSet (xSetItem, UNO_QUERY);
 278             OSL_ASSERT(xSet.is());
 279             if (xSetItem.is())
 280             {
 281                 // Get from the current item of the container the children
 282                 // that match the names in the rArguments list.
 283                 for (sal_uInt32 nValueIndex=0; nValueIndex<aValues.size(); ++nValueIndex)
 284                 {
 285                     if ( ! xSetItem->hasByName(rArguments[nValueIndex]))
 286                         bHasAllValues = false;
 287                     else
 288                         aValues[nValueIndex] = xSetItem->getByName(rArguments[nValueIndex]);
 289                 }
 290             }
 291             else
 292                 bHasAllValues = false;
 293             if (bHasAllValues)
 294                 rProcessor(rsKey,aValues);
 295         }
 296     }
 297 }
 298
 299
 300
 301
 302 void PresenterConfigurationAccess::ForAll (
 303     const Reference<container::XNameAccess>& rxContainer,
 304     const PropertySetProcessor& rProcessor)
 305 {
 306     if (rxContainer.is())
 307     {
 308         Sequence<OUString> aKeys (rxContainer->getElementNames());
 309         for (sal_Int32 nItemIndex=0; nItemIndex<aKeys.getLength(); ++nItemIndex)
 310         {
 311             const OUString& rsKey (aKeys[nItemIndex]);
 312             Reference<beans::XPropertySet> xSet (rxContainer->getByName(rsKey), UNO_QUERY);
 313             if (xSet.is())
 314                 rProcessor(rsKey, xSet);
 315         }
 316     }
 317 }
 318
 319
 320
 321
 322 void PresenterConfigurationAccess::FillList(
 323     const Reference<container::XNameAccess>& rxContainer,
 324     const ::rtl::OUString& rsArgument,
 325     ::std::vector<OUString>& rList)
 326 {
 327     try
 328     {
 329         if (rxContainer.is())
 330         {
 331             Sequence<OUString> aKeys (rxContainer->getElementNames());
 332             rList.resize(aKeys.getLength());
 333             for (sal_Int32 nItemIndex=0; nItemIndex<aKeys.getLength(); ++nItemIndex)
 334             {
 335                 Reference<container::XNameAccess> xSetItem (
 336                     rxContainer->getByName(aKeys[nItemIndex]), UNO_QUERY);
 337                 if (xSetItem.is())
 338                 {
 339                     xSetItem->getByName(rsArgument) >>= rList[nItemIndex];
 340                 }
 341             }
 342         }
 343     }
 344     catch (RuntimeException&)
 345     {}
 346 }
 347
 348
 349
 350
 351 Any PresenterConfigurationAccess::Find (
 352     const Reference<container::XNameAccess>& rxContainer,
 353     const Predicate& rPredicate)
 354 {
 355     if (rxContainer.is())
 356     {
 357         Sequence<OUString> aKeys (rxContainer->getElementNames());
 358         for (sal_Int32 nItemIndex=0; nItemIndex<aKeys.getLength(); ++nItemIndex)
 359         {
 360             Reference<beans::XPropertySet> xProperties (
 361                 rxContainer->getByName(aKeys[nItemIndex]),
 362                 UNO_QUERY);
 363             if (xProperties.is())
 364                 if (rPredicate(aKeys[nItemIndex], xProperties))
 365                     return Any(xProperties);
 366         }
 367     }
 368     return Any();
 369 }
 370
 371
 372
 373
 374 bool PresenterConfigurationAccess::IsStringPropertyEqual (
 375     const ::rtl::OUString& rsValue,
 376     const ::rtl::OUString& rsPropertyName,
 377     const css::uno::Reference<css::beans::XPropertySet>& rxNode)
 378 {
 379     OUString sValue;
 380     if (GetProperty(rxNode, rsPropertyName) >>= sValue)
 381         return sValue == rsValue;
 382     else
 383         return false;
 384 }
 385
 386
 387
 388
 389 Any PresenterConfigurationAccess::GetProperty (
 390     const Reference<beans::XPropertySet>& rxProperties,
 391     const OUString& rsKey)
 392 {
 393     OSL_ASSERT(rxProperties.is());
 394     if ( ! rxProperties.is())
 395         return Any();
 396     try
 397     {
 398         Reference<beans::XPropertySetInfo> xInfo (rxProperties->getPropertySetInfo());
 399         if (xInfo.is())
 400             if ( ! xInfo->hasPropertyByName(rsKey))
 401                 return Any();
 402         return rxProperties->getPropertyValue(rsKey);
 403     }
 404     catch (beans::UnknownPropertyException&)
 405     {
 406     }
 407     return Any();
 408 }
 409
 410
 411
 412
 413 } } // end of namespace sdext::tools
 414