configmgr/workben/apitest/cfgapi_timetest.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: cfgapi_timetest.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33 #define _PRIVATE_TEST_
  34
  35 #include <iostream>
  36 using namespace std;
  37
  38 #include <vector>
  39
  40 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  41 #include <com/sun/star/uno/Type.hxx>
  42 #include <com/sun/star/uno/TypeClass.hpp>
  43
  44 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  45 #include <com/sun/star/container/XNameAccess.hpp>
  46 #include <com/sun/star/container/XHierarchicalName.hpp>
  47 #include <com/sun/star/container/XNamed.hpp>
  48 #include <com/sun/star/container/XNameReplace.hpp>
  49 #include <com/sun/star/container/XChild.hpp>
  50 #include <com/sun/star/beans/XExactName.hpp>
  51 #include <com/sun/star/util/XChangesBatch.hpp>
  52
  53
  54 #include <rtl/ustring.hxx>
  55 #include <rtl/string.hxx>
  56 #include <cppuhelper/servicefactory.hxx>
  57 #include <com/sun/star/uno/Sequence.h>
  58 #include <com/sun/star/uno/Any.h>
  59 #include <osl/profile.hxx>
  60 #include <osl/process.h>
  61 #include <osl/file.h>
  62
  63 #include "createpropertyvalue.hxx"
  64
  65 #include "typeconverter.hxx"
  66
  67 // #include <com/sun/star/configuration/XConfigurationSync.hpp>
  68
  69 using namespace ::com::sun::star::uno;
  70 using namespace ::com::sun::star::lang;
  71 using namespace ::com::sun::star::container;
  72 using namespace ::com::sun::star::beans;
  73 //using namespace ::com::sun::star::util;
  74 using namespace ::com::sun::star::util;
  75
  76 using ::rtl::OUString;
  77 using ::rtl::OString;
  78 //using namespace ::configmgr;
  79
  80 using namespace ::cppu;
  81
  82 #define ASCII(x) ::rtl::OUString::createFromAscii(x)
  83
  84 bool m_bInteractive = false;
  85
  86 #define COUT if(m_bInteractive) cout
  87
  88 ostream& operator << (ostream& out, rtl::OUString const& aStr)
  89 {
  90     sal_Unicode const* const pStr = aStr.getStr();
  91     sal_Unicode const* const pEnd = pStr + aStr.getLength();
  92     for (sal_Unicode const* p = pStr; p < pEnd; ++p)
  93         if (0 < *p && *p < 127) // ASCII
  94             out << char(*p);
  95         else
  96             out << "[\\u" << hex << *p << "]";
  97     return out;
  98 }
  99
 100 void showSequence(const Sequence<OUString> &aSeq)
 101 {
 102     OUString aArray;
 103     const OUString *pStr = aSeq.getConstArray();
 104     for (int i=0;i<aSeq.getLength();i++)
 105     {
 106         OUString aStr = pStr[i];
 107         // aArray += aStr + ASCII(", ");
 108         COUT << aStr << endl;
 109     }
 110     volatile int dummy = 0;
 111 }
 112
 113 //=============================================================================
 114
 115 inline void operator <<= (::rtl::OUString& _rUnicodeString, const sal_Char* _pAsciiString)
 116 {
 117     _rUnicodeString = ::rtl::OUString::createFromAscii(_pAsciiString);
 118 }
 119
 120 inline void operator <<= (::rtl::OUString& _rUnicodeString, const ::rtl::OString& _rAsciiString)
 121 {
 122     _rUnicodeString <<= _rAsciiString.getStr();
 123 }
 124
 125 inline void operator <<= (Any& _rUnoValue, const sal_Char* _pAsciiString)
 126 {
 127     _rUnoValue <<= ::rtl::OUString::createFromAscii(_pAsciiString);
 128 }
 129
 130 inline void operator <<= (Any& _rUnoValue, const ::rtl::OString& _rAsciiString)
 131 {
 132     _rUnoValue <<= _rAsciiString.getStr();
 133 }
 134
 135 //=============================================================================
 136 void test_read_access(Reference< XInterface >& xIface, const Reference< XMultiServiceFactory > &xMSF);
 137 //=============================================================================
 138
 139 // -----------------------------------------------------------------------------
 140 struct prompt_and_wait
 141 {
 142     char const* myText;
 143     prompt_and_wait(char const* text = "") : myText(text) {}
 144     ~prompt_and_wait()
 145     {
 146         if (m_bInteractive)
 147         {
 148             COUT << myText << ">" << endl;
 149             int const mx = int( (+0u - +1u) >> 1);
 150
 151             char c=0;
 152             if (cin.get(c) && c != '\n')
 153                 cin.ignore(mx,'\n');
 154         }
 155     }
 156 };
 157 static prompt_and_wait exit_prompt("Quitting\nQ");
 158
 159
 160 Reference< XChangesBatch > xChangesBatch = NULL;
 161 void commit()
 162 {
 163     if (xChangesBatch.is())
 164     {
 165         xChangesBatch->commitChanges();
 166     }
 167 }
 168
 169 // -----------------------------------------------------------------------------
 170 static sal_Bool                         s_bInitialized  =       sal_False;
 171 static const sal_Char*          s_pSourcePath   =       "f:/office60_623/share/config/registry";
 172 static const sal_Char*          s_pUpdatePath   =       "f:/office60_623/user/config/registry";
 173 static const sal_Char*          s_pRootNode             =       "org.openoffice.Office.Common";
 174 static const sal_Char*          s_pServerType   =       "local";
 175 static const sal_Char*          s_pLocale               =       "de-DE";
 176 static const sal_Char*          s_pServer               =       "lautrec-3108:19205";
 177 static const sal_Char*          s_pUser                 =       "lars";
 178 static const sal_Char*          s_pPassword             =       "";
 179
 180 std::vector<rtl::OString> m_sNodes;
 181
 182 // -----------------------------------------------------------------------------
 183 static void loadDefaults()
 184 {
 185     if (s_bInitialized)
 186         return;
 187
 188     s_bInitialized = sal_True;
 189
 190     try
 191     {
 192         // the executable file name
 193         ::rtl::OUString sExecutable;
 194         osl_getExecutableFile(&sExecutable.pData);
 195         // cut the name, add a cfgapi.ini to the path
 196         sal_Int32 nLastSep = sExecutable.lastIndexOf('/');
 197         if (-1 != nLastSep)
 198             sExecutable = sExecutable.copy(0, nLastSep + 1);
 199 #ifdef UNX
 200         sExecutable += ::rtl::OUString::createFromAscii("cfgapirc");
 201 #else
 202         sExecutable += ::rtl::OUString::createFromAscii("cfgapi.ini");
 203 #endif
 204         ::rtl::OUString sSystem;
 205         if (osl_File_E_None == osl_getSystemPathFromFileURL(sExecutable.pData, &sSystem.pData))
 206         {
 207             ::osl::Profile aProfile(sExecutable);
 208
 209             static ::rtl::OString       sSection("defaults");
 210             static ::rtl::OString       sSourcePath("sourcepath");
 211             static ::rtl::OString       sUpdatePath("updatepath");
 212             static ::rtl::OString       sRootNode("rootnode");
 213             static ::rtl::OString       sServerType("servertype");
 214             static ::rtl::OString       sLocale("Locale");
 215             static ::rtl::OString       sServer("Server");
 216             static ::rtl::OString       sUser("User");
 217             static ::rtl::OString       sPassword("Password");
 218
 219             // read some strings.
 220             // Do this static because we want to redirect the global static character pointers to the buffers.
 221             static ::rtl::OString s_sSourcePath = aProfile.readString(sSection, sSourcePath, s_pSourcePath);
 222             static ::rtl::OString s_sUpdatePath = aProfile.readString(sSection, sUpdatePath, s_pUpdatePath);
 223             static ::rtl::OString s_sRootNode   = aProfile.readString(sSection, sRootNode, s_pRootNode);
 224             static ::rtl::OString s_sServerType = aProfile.readString(sSection, sServerType, s_pServerType);
 225             static ::rtl::OString s_sLocale             = aProfile.readString(sSection, sLocale, s_pLocale);
 226             static ::rtl::OString s_sServer             = aProfile.readString(sSection, sServer, s_pServer);
 227             static ::rtl::OString s_sUser               = aProfile.readString(sSection, sUser, s_pUser);
 228             static ::rtl::OString s_sPassword   = aProfile.readString(sSection, sPassword, s_pPassword);
 229
 230             // do this redirection
 231             s_pSourcePath       =       s_sSourcePath.getStr();
 232             s_pUpdatePath       =       s_sUpdatePath.getStr();
 233             s_pRootNode         =       s_sRootNode.getStr();
 234             s_pServerType       =       s_sServerType.getStr();
 235             s_pLocale           =       s_sLocale.getStr();
 236             s_pServer           =       s_sServer.getStr();
 237             s_pUser                     =       s_sUser.getStr();
 238             s_pPassword         =       s_sPassword.getStr();
 239
 240             static ::rtl::OString       sNodeSection("nodes");
 241             static ::rtl::OString       sCount("count");
 242             rtl::OUString sCountValue;
 243             sCountValue <<= aProfile.readString(sNodeSection, sCount, "0");
 244             sal_Int32 nCount = sCountValue.toInt32();
 245             for (sal_Int32 i=0;i<nCount;i++)
 246             {
 247                 ::rtl::OString sNodeName("node");
 248                 sNodeName += OString::valueOf(i);
 249                 ::rtl::OString sNode = aProfile.readString(sNodeSection, sNodeName, "");
 250                 m_sNodes.push_back(sNode);
 251             }
 252         }
 253     }
 254     catch(std::exception& e)
 255     {
 256         e.what();       // silence warnings
 257     }
 258 }
 259
 260 // -----------------------------------------------------------------------------
 261 Sequence<Any> createSequence(const OUString &sUser, const OUString &sPasswd)
 262 {
 263     Sequence< Any > aCPArgs;
 264
 265     if (sUser.getLength() > 0)
 266     {
 267         aCPArgs.realloc(1);
 268         aCPArgs[0] <<= configmgr::createPropertyValue(ASCII("user"), sUser);
 269     }
 270     if (sPasswd.getLength() > 0)
 271     {
 272         aCPArgs.realloc(2);
 273         aCPArgs[1] <<= configmgr::createPropertyValue(ASCII("password"), sPasswd);
 274     }
 275     return aCPArgs;
 276 }
 277
 278 //=============================================================================
 279 #include <string.h>
 280 #if (defined UNX) || (defined OS2)
 281 #else
 282 #include <conio.h>
 283 #endif
 284
 285 OString input(const char* pDefaultText, char cEcho)
 286 {
 287     // PRE: a Default Text would be shown, cEcho is a Value which will show if a key is pressed.
 288     const int MAX_INPUT_LEN = 500;
 289     char aBuffer[MAX_INPUT_LEN];
 290
 291     strcpy(aBuffer, pDefaultText);
 292     int nLen = strlen(aBuffer);
 293
 294 #ifdef WNT
 295     char ch = '\0';
 296
 297     COUT << aBuffer;
 298     cout.flush();
 299
 300     while(ch != 13)
 301     {
 302         ch = getch();
 303         if (ch == 8)
 304         {
 305             if (nLen > 0)
 306             {
 307                 COUT << "\b \b";
 308                 cout.flush();
 309                 --nLen;
 310                 aBuffer[nLen] = '\0';
 311             }
 312             else
 313             {
 314                 COUT << "\a";
 315                 cout.flush();
 316             }
 317         }
 318         else if (ch != 13)
 319         {
 320             if (nLen < MAX_INPUT_LEN)
 321             {
 322                 if (cEcho == 0)
 323                 {
 324                     COUT << ch;
 325                 }
 326                 else
 327                 {
 328                     COUT << cEcho;
 329                 }
 330                 cout.flush();
 331                 aBuffer[nLen++] = ch;
 332                 aBuffer[nLen] = '\0';
 333             }
 334             else
 335             {
 336                 COUT << "\a";
 337                 cout.flush();
 338             }
 339         }
 340     }
 341 #else
 342     if (!cin.getline(aBuffer,sizeof aBuffer))
 343         return OString();
 344 #endif
 345     return OString(aBuffer);
 346 }
 347
 348
 349 // -----------------------------------------------------------------------------
 350 rtl::OUString enterValue(const char* _aStr, const char* _aDefault, bool _bIsAPassword)
 351 {
 352     COUT << _aStr;
 353     cout.flush();
 354
 355     OUString sValue;
 356     if (m_bInteractive)
 357     {
 358         sValue <<= input(_aDefault, _bIsAPassword ? '*' : 0);
 359     }
 360     else
 361     {
 362         sValue <<= _aDefault;
 363     }
 364     return sValue;
 365 }
 366
 367
 368
 369 void ask_for_a_node_and_test_it(const Reference< XMultiServiceFactory > &xCfgProvider,
 370                                 const OUString& sUser, const OUString &sPasswd,
 371                                 const OUString& sPath, bool bLocal, const OUString &sLocale);
 372
 373 // -----------------------------------------------------------------------------
 374 // ---------------------------------- M A I N ----------------------------------
 375 // -----------------------------------------------------------------------------
 376
 377 #if (defined UNX) || (defined OS2)
 378 int main( int argc, char * argv[] )
 379 #else
 380 int _cdecl main( int argc, char * argv[] )
 381 #endif
 382 {
 383     TimeValue aTimeout;
 384     aTimeout.Seconds = 5;
 385     aTimeout.Nanosec = 0;
 386
 387     // COUT << "    Please insert Text: ";
 388     // cout.flush();
 389     // OString aTxt = input("Der Text", 0);
 390     // COUT << endl << "You inserted: " << aTxt.getStr() << endl;
 391     //
 392     // COUT << "Please insert Password: ";
 393     // cout.flush();
 394     // OString aPasswd = input("", '*');
 395     // COUT << endl << "You inserted: " << aPasswd.getStr() << endl;
 396
 397     loadDefaults();
 398
 399     m_bInteractive = false;
 400     //if (argc > 1)
 401     //{
 402     //  OString aParam(argv[1]);
 403     //  if (aParam.equals("ask"))
 404     //  {
 405     //          m_bInteractive = true;
 406     //  }
 407     //}
 408
 409     try
 410     {
 411         OUString const sServiceRegistry = OUString::createFromAscii( argc > 1 ? argv[1] : "applicat.rdb" );
 412         Reference< XMultiServiceFactory > xORB = createRegistryServiceFactory(
 413             sServiceRegistry,
 414             ::rtl::OUString()
 415             );
 416         if (!xORB.is())
 417         {
 418             ::flush(cout);
 419             cerr << "Could not create the service factory !\n\n";
 420             return 1;
 421         }
 422         COUT << "Service factory created !\n---------------------------------------------------------------" << endl;
 423
 424         Sequence< Any > aCPArgs;
 425
 426         OUString sServerType = enterValue("servertype: ", s_pServerType, false);
 427         COUT << endl;
 428
 429
 430         rtl::OUString sUser, sPasswd;
 431
 432         bool bLocal = sServerType.equalsIgnoreAsciiCase(ASCII("local")) || sServerType.equalsIgnoreAsciiCase(ASCII("setup"));
 433         if (!bLocal)
 434         {
 435             rtl::OUString sServer;
 436             sServer =                   enterValue("server  : ", s_pServer,false);
 437             COUT << endl;
 438
 439             sUser =                             enterValue("user    : ", s_pUser, false);
 440             COUT << endl;
 441
 442             sPasswd = enterValue("password: ", s_pPassword, true);
 443             COUT << endl;
 444
 445             aCPArgs = createSequence(sUser, sPasswd);
 446
 447             aCPArgs.realloc(aCPArgs.getLength() + 1);
 448             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("server"), sServer);
 449
 450             long nTimeout = 10000;
 451             aCPArgs.realloc(aCPArgs.getLength() + 1);
 452             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("timeout"), nTimeout);
 453
 454             long nPort = 9205;
 455             aCPArgs.realloc(aCPArgs.getLength() + 1);
 456             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("port"), nPort);
 457         }
 458         else
 459         {
 460             rtl::OUString sSharePath, sUserPath;
 461             sSharePath =                enterValue("share path: ", s_pSourcePath, false);
 462             COUT << endl;
 463             sUserPath =                 enterValue("user path : ", s_pUpdatePath, false);
 464             COUT << endl;
 465
 466             aCPArgs.realloc(aCPArgs.getLength() + 1);
 467             Any* pAny;
 468             pAny = &aCPArgs[aCPArgs.getLength() - 1];
 469             *pAny <<= configmgr::createPropertyValue(ASCII("sourcepath"), sSharePath);
 470             aCPArgs.realloc(aCPArgs.getLength() + 1);
 471             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("updatepath"), sUserPath);
 472         }
 473
 474         aCPArgs.realloc(aCPArgs.getLength() + 1);
 475         aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("servertype"), sServerType);
 476
 477         Reference< XMultiServiceFactory > xCfgProvider(
 478             xORB->createInstanceWithArguments(
 479                 ::rtl::OUString::createFromAscii("com.sun.star.configuration.ConfigurationProvider"),
 480                 aCPArgs),
 481             UNO_QUERY);
 482         if (!xCfgProvider.is())
 483         {
 484             ::flush(cout);
 485             cerr << "Could not create the configuration provider !\n\n";
 486             return 3;
 487         }
 488
 489         cout << "---------------------------------------------------------------\n Configuration Provider created !\n---------------------------------------------------------------" << endl;
 490
 491         OUString sPath;
 492         sPath <<= s_pRootNode;
 493         OUString sLocale;
 494         sLocale <<= s_pLocale;
 495
 496         if (m_bInteractive)
 497         {
 498             sPath = enterValue("nodepath: ", s_pRootNode, false);
 499             COUT << endl;
 500             if (bLocal)
 501             {
 502                 sLocale = enterValue("locale  : ", s_pLocale, false);
 503                 COUT << endl;
 504             }
 505             ask_for_a_node_and_test_it(xCfgProvider, sUser, sPasswd, sPath, bLocal, sLocale);
 506         }
 507         else
 508         {
 509             sUser <<= "";
 510             for(std::vector<OString>::const_iterator it = m_sNodes.begin();
 511                 it != m_sNodes.end();
 512                 ++it)
 513             {
 514                 OUString sPath;
 515                 sPath <<= *it;
 516                 if (sPath.getLength() > 0)
 517                     ask_for_a_node_and_test_it(xCfgProvider, sUser, sPasswd, sPath, bLocal, sLocale);
 518             }
 519         }
 520     }
 521     catch (Exception& e)
 522     {
 523         ::flush(cout);
 524         cerr << "Caught exception: " << e.Message << endl;
 525         return 1;
 526     }
 527     return 0;
 528 }
 529
 530 // -----------------------------------------------------------------------------
 531 void ask_for_a_node_and_test_it(const Reference< XMultiServiceFactory > &xCfgProvider,
 532                                 const OUString& sUser, const OUString &sPasswd,
 533                                 const OUString& sPath, bool bLocal, const OUString &sLocale)
 534 {
 535     try
 536     {
 537         Sequence< Any > aArgs;
 538         aArgs = createSequence(sUser, sPasswd);
 539
 540         aArgs.realloc(aArgs.getLength() + 1);
 541         aArgs[aArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("nodepath"), sPath);
 542
 543         if (!bLocal)
 544         {
 545             aArgs.realloc(aArgs.getLength() + 1);
 546             aArgs[aArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("locale"), sLocale);
 547         }
 548
 549         Reference< XInterface > xIFace = xCfgProvider->createInstanceWithArguments(
 550             OUString::createFromAscii("com.sun.star.configuration.ConfigurationUpdateAccess"),
 551             aArgs);
 552         cout << "Configuration Read/Write Access created for :" << sPath << endl;
 553
 554         xChangesBatch = Reference< XChangesBatch >(xIFace, UNO_QUERY);
 555
 556         Sequence<OUString> aSeq = xCfgProvider->getAvailableServiceNames();
 557         showSequence(aSeq);
 558
 559         test_read_access(xIFace, xCfgProvider);
 560     }
 561     catch (Exception& e)
 562     {
 563         ::flush(cout);
 564         cerr << "Caught exception: " << e.Message << endl;
 565     }
 566 }
 567
 568 ///////////////////////////////////////////////////////////////////////////////////////////
 569 void test(Reference< XHierarchicalName >& xAccessName)
 570 {
 571         if (xAccessName.is())
 572         {
 573             COUT << "Accessing Node: " << xAccessName->getHierarchicalName() << endl;
 574         }
 575         else
 576         {
 577             cerr << "BUG: XHierarchicalName not available" << endl;
 578         }
 579 }
 580 // -----------------------------------------------------------------------------
 581 void test(Reference< XNamed >& xAccess)
 582 {
 583         if (xAccess.is())
 584         {
 585             COUT << "Node is named: " << xAccess->getName() << endl;
 586         }
 587         else
 588             cerr << "BUG: XNamed not available" << endl;
 589 }
 590
 591 ///////////////////////////////////////////////////////////////////////////////////////////
 592 void write(Reference<XNameAccess  >& xAccess)
 593 {
 594         if (xAccess.is())
 595         {
 596             Sequence<OUString> aNames( xAccess->getElementNames() );
 597
 598             COUT << "Element Names: (" << aNames.getLength() << ")";
 599             for (int i = 0; i < aNames.getLength(); ++i)
 600             {
 601                 COUT << "\n[" << i << "] -\t" << aNames[i];
 602             }
 603             COUT << endl;
 604         }
 605         else
 606             cerr << "BUG: XNameAccess not available" << endl;
 607 }
 608 // -----------------------------------------------------------------------------
 609 void write(Reference< XChild >& xChild)
 610 {
 611         if (xChild.is())
 612         {
 613             COUT << "\n[ P ] -\tParent" << endl;
 614         }
 615         else
 616             cerr << "BUG: Parent not available (no XChild)" << endl;
 617 }
 618 ///////////////////////////////////////////////////////////////////////////////////////////
 619
 620 bool ask(Reference< XInterface >& xIface, const Reference<XMultiServiceFactory> &);
 621
 622 void test_read_access(Reference< XInterface >& xIface, const Reference< XMultiServiceFactory > &xMSF)
 623 {
 624     using com::sun::star::uno::UNO_QUERY;
 625     do
 626     {
 627         COUT << "\n\n---------------------------------------------------------------" << endl;
 628         Reference< XNameAccess > xAccess(xIface, UNO_QUERY);
 629         Reference< XChild > xChild(xIface, UNO_QUERY);
 630         Reference< XHierarchicalName > xAccessPath(xIface,UNO_QUERY);
 631         Reference< XNamed > xAccessName(xIface,UNO_QUERY);
 632 //              Reference< XHierarchicalNameAccess >& xAccess(xIface, UNO_QUERY);
 633
 634         test(xAccessPath);
 635         test(xAccessName);
 636         write(xAccess);
 637         write(xChild);
 638
 639         if (!m_bInteractive) break;
 640     }
 641     while (ask(xIface, xMSF));
 642 }
 643
 644 bool ask(Reference< XInterface >& xIface, const Reference< XMultiServiceFactory > &xMSF)
 645 {
 646     COUT << "\n[ Q ] -> <Quit>";
 647     COUT << "\n[ S ] -> <SetValue> ";
 648     COUT << endl;
 649
 650     COUT << "\n:> " << flush;
 651     char buf[200] = {0};
 652     try
 653     {
 654         bool bHandled = false;
 655         bool bInserted = false;
 656
 657         if (cin.getline(buf,sizeof buf))
 658         {
 659             Reference< XInterface > xNext;
 660             if ((buf[0] == 'q' || buf[0] == 'Q') && (0 == buf[1]))
 661             {
 662                 return false;
 663             }
 664             else if (buf[0] == 0)
 665             {
 666                 return true;
 667             }
 668             else if((buf[0] == 0 || buf[0] == 'o' || buf[0] == 'O') && (0 == buf[1]))
 669             {
 670 /*
 671                 COUT << "work Offline" << endl;
 672                 Reference<com::sun::star::configuration::XConfigurationSync> xSync(xMSF, UNO_QUERY);
 673
 674                 Sequence< Any > aArgs2(5);
 675                 sal_Int32 n=0;
 676                 aArgs2[n++] <<= configmgr::createPropertyValue(ASCII("path"), ASCII("org.openoffice.Setup"));
 677                 // aArgs2[n++] <<= configmgr::createPropertyValue(ASCII("path"), ASCII("org.openoffice.Office.Common"));
 678                 // aArgs2[n++] <<= configmgr::createPropertyValue(ASCII("path"), ASCII("org.openoffice.Office.Java"));
 679                 // aArgs2[n++] <<= configmgr::createPropertyValue(ASCII("path"), ASCII("org.openoffice.Office.Writer"));
 680                 // aArgs2[n++] <<= configmgr::createPropertyValue(ASCII("path"), ASCII("org.openoffice.Office.ucb.Hierarchy"));
 681                 xSync->offline(aArgs2);
 682                 bHandled = true;
 683 */
 684             }
 685             else if((buf[0] == 0 || buf[0] == 's' || buf[0] == 'S') && (0 == buf[1]))
 686             {
 687                 // Replace a Value
 688                 Reference< XNameAccess > xAccess(xIface, UNO_QUERY);
 689
 690                 COUT << "SetMode, insert a Number" << endl;
 691                 cin.getline(buf,sizeof buf);
 692                 bInserted = true;
 693             }
 694
 695             else if ((buf[0] == 'p' || buf[0] == 'P') && (0 == buf[1]))
 696             {
 697                 Reference< XChild > xChild(xIface, UNO_QUERY);
 698                 if (xChild.is())
 699                     xNext = xChild->getParent();
 700                 bHandled = true;
 701             }
 702
 703             if (bHandled == false)
 704             {
 705                 Reference< XNameAccess > xAccess(xIface, UNO_QUERY);
 706                 Reference< XHierarchicalNameAccess > xDeepAccess(xIface, UNO_QUERY);
 707                 Reference< XExactName > xExactName(xIface, UNO_QUERY);
 708
 709                 if (xAccess.is() || xDeepAccess.is())
 710                 {
 711                     OUString aName;
 712                     OUString aInput = OUString::createFromAscii(buf);
 713
 714                     if (xExactName.is())
 715                     {
 716                         ::rtl::OUString sTemp = xExactName->getExactName(aInput);
 717                         if (sTemp.getLength())
 718                             aInput = sTemp;
 719                     }
 720
 721                     if (xAccess.is() && xAccess->hasByName(aInput))
 722                     {
 723                         aName = aInput;
 724                     }
 725                     else if (xDeepAccess.is() && xDeepAccess->hasByHierarchicalName(aInput))
 726                     {
 727                         aName = aInput;
 728                     }
 729                     else if ('0' <= buf[0] && buf[0] <= '9' && xAccess.is())
 730                     {
 731                         unsigned int n = unsigned(atoi(buf));
 732                         Sequence<OUString> aNames = xAccess->getElementNames();
 733                         if (n < aNames.getLength())
 734                             aName = aNames[n];
 735                     }
 736
 737                     if (aName.getLength())
 738                     {
 739                         bool bNest = aInput.indexOf(sal_Unicode('/')) >= 0;
 740
 741                         Any aElement = bNest    ? ( xDeepAccess.is() ? xDeepAccess->getByHierarchicalName(aName) : Any())
 742                                                 : ( xAccess.    is() ? xAccess->    getByName(aName)             : Any() );
 743
 744                         while (aElement.getValueTypeClass() == TypeClass_ANY)
 745                         {
 746                             Any aWrap(aElement);
 747                             aWrap >>= aElement;
 748                         }
 749                         sal_Bool bValue = true;
 750                         sal_Bool bValueOk = false;
 751
 752                         switch (aElement.getValueTypeClass() )
 753                         {
 754                         case TypeClass_INTERFACE: bValue = false; break;
 755                         case TypeClass_BOOLEAN:
 756                             {
 757                                 sal_Bool* pVal = (sal_Bool*)aElement.getValue();
 758                                 bValueOk = (pVal != 0);
 759
 760                                 COUT << "VALUE '" << aName << "' is a BOOLEAN = ";
 761                                 if (!bValueOk)
 762                                 {
 763                                     COUT << "NULL (error!!)";
 764                                 }
 765                                 else if (*pVal)
 766                                 {
 767                                     COUT << "'TRUE'";
 768                                 }
 769                                 else
 770                                 {
 771                                     COUT << "'FALSE'";
 772                                 }
 773                                 COUT << endl;
 774                             }
 775                             break;
 776                         case TypeClass_SHORT:
 777                             {
 778                                 sal_Int16 aValue;
 779                                 COUT << "VALUE '" << aName << "' is a SHORT (16 bit) = ";
 780                                 if (bValueOk = (aElement >>= aValue))
 781                                 {
 782                                     COUT << aValue;
 783                                 }
 784                                 else
 785                                     cerr << "ERROR RETRIEVING VALUE";
 786                                 COUT << endl;
 787                             }
 788                             break;
 789                         case TypeClass_LONG:
 790                             {
 791
 792                                 sal_Int32 aValue;
 793                                 COUT << "VALUE '" << aName << "' is a INT (32 bit) = ";
 794                                 if (bValueOk = (aElement >>= aValue))
 795                                 {
 796                                     COUT << aValue;
 797                                 }
 798                                 else
 799                                     cerr << "ERROR RETRIEVING VALUE";
 800                                 COUT << endl;
 801                             }
 802                             break;
 803                         case TypeClass_HYPER:
 804                             {
 805                                 sal_Int64 aValue;
 806                                 COUT << "VALUE '" << aName << "' is a LONG (64 bit) = ";
 807                                 if (bValueOk = (aElement >>= aValue))
 808                                 {
 809                                     COUT << double(aValue);
 810                                 }
 811                                 else
 812                                     cerr << "ERROR RETRIEVING VALUE";
 813                                 COUT << endl;
 814                             }
 815                             break;
 816                         case TypeClass_DOUBLE:
 817                             {
 818                                 double aValue;
 819                                 COUT << "VALUE '" << aName << "' is a DOUBLE = ";
 820                                 if (bValueOk = (aElement >>= aValue))
 821                                 {
 822                                     COUT << aValue;
 823                                 }
 824                                 else
 825                                     cerr << "ERROR RETRIEVING VALUE";
 826                                 COUT << endl;
 827                             }
 828                             break;
 829                         case TypeClass_STRING:
 830                             {
 831                                 OUString aValue;
 832                                 COUT << "VALUE '" << aName << "' is a STRING = ";
 833                                 if (bValueOk = (aElement >>= aValue))
 834                                 {
 835                                     COUT << "\"" << aValue << "\"";
 836                                 }
 837                                 else
 838                                     cerr << "ERROR RETRIEVING VALUE";
 839                                 COUT << endl;
 840                             }
 841                             break;
 842                         case TypeClass_SEQUENCE:
 843                             {
 844                                 COUT << "VALUE '" << aName << "' is a SEQUENCE or BINARY" << endl;
 845
 846                                 Type aTypeS = configmgr::getSequenceElementType(aElement.getValueType());
 847                                 OUString sType = configmgr::toTypeName(aTypeS.getTypeClass());
 848                                 COUT << "Real type is Sequence<" << sType << ">" << endl;
 849                                 bValueOk = true;
 850                             }
 851                             break;
 852                         case TypeClass_VOID:
 853                             COUT << "ELEMENT '" << aName << "' is NULL and VOID " << endl;
 854                             bValueOk = true;
 855                             break;
 856                         default:
 857                                 cerr << "Error: ELEMENT '" << aName << "' is of unknown or unrecognized type" << endl;
 858                             break;
 859                         }
 860                         if (bValue)
 861                         {
 862                             if (bInserted)
 863                             {
 864                                 if (aElement.getValueTypeClass() == TypeClass_BOOLEAN ||
 865                                     aElement.getValueTypeClass() == TypeClass_VOID)
 866                                 {
 867                                     COUT << "Set Value (Type=BOOL) to :";
 868                                     cout.flush();
 869                                     cin.getline(buf,sizeof buf);
 870                                     OUString aInput = OUString::createFromAscii(buf);
 871                                     sal_Bool bValue = false;
 872
 873                                     Any aValueAny;
 874                                     if (aInput.equalsIgnoreAsciiCase(ASCII("true")))
 875                                     {
 876                                         bValue = true;
 877                                         aValueAny <<= bValue;
 878                                     }
 879                                     else if (aInput.equalsIgnoreAsciiCase(ASCII("false")))
 880                                     {
 881                                         bValue = false;
 882                                         aValueAny <<= bValue;
 883                                     }
 884                                     else if (aInput.equalsIgnoreAsciiCase(ASCII("null")))
 885                                     {
 886                                     }
 887
 888                                     Reference< XNameReplace > xNameReplace(xAccess, UNO_QUERY);
 889                                     if (xNameReplace.is())
 890                                     {
 891                                         xNameReplace->replaceByName(aName, aValueAny);
 892                                         commit();
 893                                     }
 894                                     bInserted = false;
 895                                 }
 896                                 else if (aElement.getValueTypeClass() == TypeClass_STRING)
 897                                 {
 898                                     COUT << "set value (type = string) to : ";
 899                                     cout.flush();
 900                                     cin.getline(buf,sizeof buf);
 901                                     Any aValue;
 902                                     aValue <<= buf;
 903
 904                                     Reference< XNameReplace > xNameReplace(xAccess, UNO_QUERY);
 905                                     if (xNameReplace.is())
 906                                     {
 907                                         xNameReplace->replaceByName(aName, aValue);
 908                                         commit();
 909                                     }
 910                                     bInserted = false;
 911                                 }
 912                                 else
 913                                 {
 914                                     cerr << "Sorry, only BOOLEAN Values can changed today." << endl;
 915                                 }
 916                             }
 917                             prompt_and_wait();
 918                             return bValueOk ? true : false;
 919                         }
 920
 921                         if (aElement >>= xNext)
 922                         {
 923                             COUT << "Got an Interface for '" << aName << "'" << endl;
 924                         }
 925                         else
 926                             cerr << "Error: Cannot get an Interface for '" << aName << "'" << endl;
 927                     }
 928                     else
 929                     {
 930                         cerr << "Error: No element \"" << aInput << "\" found." <<endl;
 931                     }
 932                 }
 933
 934             }
 935             if (xNext.is())
 936             {
 937                 xIface = xNext;
 938                 return true;
 939             }
 940             cerr << "Error: could not obtain the requested Object " << endl;
 941         }
 942         else
 943         {
 944             COUT << "Input Error " << endl;
 945             return true;
 946         }
 947     }
 948     catch (Exception& e)
 949     {
 950         cerr << "An Exception occurred: " << e.Message << endl;
 951
 952     }
 953     catch (...)
 954     {
 955         cerr << "An UNKNOWN Exception occurred !" << endl;
 956     }
 957
 958     prompt_and_wait();
 959     return true;
 960 }