Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / ucb / workben / ucb / ucbdemo.cxx
blob: 06e5b057f62a6c88b70e4d47e6f089a8df434c77 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_ucb.hxx"
#include <stack>
#include <rtl/ustrbuf.hxx>
#include <vos/mutex.hxx>
#include <vos/process.hxx>
#include <cppuhelper/weak.hxx>
#include <cppuhelper/bootstrap.hxx>
#include <com/sun/star/ucb/ContentAction.hpp>
#include <com/sun/star/ucb/OpenCommandArgument2.hpp>
#include <com/sun/star/ucb/ContentResultSetCapability.hpp>
#include <com/sun/star/ucb/SearchCommandArgument.hpp>
#include <com/sun/star/ucb/NameClash.hpp>
#include <com/sun/star/ucb/TransferInfo.hpp>
#include <com/sun/star/ucb/GlobalTransferCommandArgument.hpp>
#include <com/sun/star/ucb/XContentIdentifierFactory.hpp>
#include <com/sun/star/ucb/CommandInfo.hpp>
#include <com/sun/star/ucb/XContentProviderManager.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/Property.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/ucb/CHAOSProgressStart.hpp>
#include <com/sun/star/ucb/OpenMode.hpp>
#include <com/sun/star/ucb/ResultSetException.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/XPropertyContainer.hpp>
#include <com/sun/star/ucb/XProgressHandler.hpp>
#include <com/sun/star/ucb/XCommandEnvironment.hpp>
#include <com/sun/star/beans/XPropertiesChangeListener.hpp>
#include <com/sun/star/beans/XPropertiesChangeNotifier.hpp>
#include <com/sun/star/ucb/XCommandProcessor.hpp>
#include <com/sun/star/ucb/XDynamicResultSet.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/ucb/XContentAccess.hpp>
#include <com/sun/star/ucb/XCommandInfo.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/ucb/XSortedDynamicResultSetFactory.hpp>
#include <com/sun/star/bridge/XUnoUrlResolver.hpp>
#include <comphelper/processfactory.hxx>
#include <ucbhelper/configurationkeys.hxx>
#include <ucbhelper/fileidentifierconverter.hxx>
#include <ucbhelper/contentbroker.hxx>
#include <tools/debug.hxx>
#include "tools/time.hxx"
#include <vcl/wrkwin.hxx>
#include <vcl/toolbox.hxx>
#include <vcl/edit.hxx>
#include <vcl/lstbox.hxx>
#include <vcl/svapp.hxx>
#include <vcl/help.hxx>
#include <srcharg.hxx>
using ucbhelper::getLocalFileURL;
using ucbhelper::getSystemPathFromFileURL;
using ucbhelper::getFileURLFromSystemPath;
using namespace com::sun::star;
/*========================================================================
*
* MyOutWindow.
*
*======================================================================*/
#define MYOUTWINDOW_MAXLINES 4096
class MyOutWindow : public ListBox
{
public:
MyOutWindow( Window *pParent, WinBits nWinStyle )
: ListBox ( pParent, nWinStyle | WB_AUTOHSCROLL ) {}
~MyOutWindow() {}
void Append( const String &rLine );
};
//-------------------------------------------------------------------------
void MyOutWindow::Append( const String &rLine )
{
String aLine( rLine );
xub_StrLen nPos = aLine.Search( '\n' );
while ( nPos != STRING_NOTFOUND )
{
if ( GetEntryCount() >= MYOUTWINDOW_MAXLINES )
RemoveEntry( 0 );
InsertEntry( aLine.Copy( 0, nPos ) );
aLine.Erase( 0, nPos + 1 );
nPos = aLine.Search( '\n' );
}
if ( GetEntryCount() >= MYOUTWINDOW_MAXLINES )
RemoveEntry( 0 );
InsertEntry( aLine );
SetTopEntry( MYOUTWINDOW_MAXLINES - 1 );
}
/*========================================================================
*
* MessagePrinter.
*
*=======================================================================*/
class MessagePrinter
{
protected:
MyOutWindow* m_pOutEdit;
public:
MessagePrinter( MyOutWindow* pOutEdit = NULL )
: m_pOutEdit( pOutEdit ) {}
void setOutEdit( MyOutWindow* pOutEdit )
{ m_pOutEdit = pOutEdit; }
void print( const sal_Char* pText );
void print( const UniString& rText );
};
//-------------------------------------------------------------------------
void MessagePrinter::print( const sal_Char* pText )
{
print( UniString::CreateFromAscii( pText ) );
}
//-------------------------------------------------------------------------
void MessagePrinter::print( const UniString& rText )
{
vos::OGuard aGuard( Application::GetSolarMutex() );
if ( m_pOutEdit )
{
m_pOutEdit->Append( rText );
m_pOutEdit->Update();
}
}
//============================================================================
//
// TestOutputStream
//
//============================================================================
class TestOutputStream:
public cppu::OWeakObject,
public io::XOutputStream
{
rtl::OUString m_sStart;
bool m_bMore;
public:
TestOutputStream(): m_bMore(false) {}
virtual uno::Any SAL_CALL queryInterface(const uno::Type & rType)
throw(uno::RuntimeException);
virtual void SAL_CALL acquire() throw ()
{ OWeakObject::acquire(); }
virtual void SAL_CALL release() throw ()
{ OWeakObject::release(); }
virtual void SAL_CALL writeBytes(const uno::Sequence< sal_Int8 > & rData)
throw(uno::RuntimeException);
virtual void SAL_CALL flush() throw() {}
virtual void SAL_CALL closeOutput() throw() {};
rtl::OUString getStart() const;
};
//============================================================================
// virtual
uno::Any SAL_CALL
TestOutputStream::queryInterface(const uno::Type & rType)
throw(uno::RuntimeException)
{
uno::Any aRet = cppu::queryInterface(rType,
static_cast< io::XOutputStream * >(this));
return aRet.hasValue() ? aRet : OWeakObject::queryInterface(rType);
}
//============================================================================
// virtual
void SAL_CALL TestOutputStream::writeBytes(
const uno::Sequence< sal_Int8 > & rData)
throw(uno::RuntimeException)
{
sal_Int32 nLen = rData.getLength();
if (m_sStart.getLength() + nLen > 500)
{
nLen = 500 - m_sStart.getLength();
m_bMore = true;
}
m_sStart
+= rtl::OUString(reinterpret_cast< const sal_Char * >(rData.
getConstArray()),
nLen, RTL_TEXTENCODING_ISO_8859_1);
}
//============================================================================
rtl::OUString TestOutputStream::getStart() const
{
rtl::OUString sResult = m_sStart;
if (m_bMore)
sResult += rtl::OUString::createFromAscii("...");
return sResult;
}
/*========================================================================
*
* ProgressHandler.
*
*=======================================================================*/
class ProgressHandler:
public cppu::OWeakObject,
public ucb::XProgressHandler
{
MessagePrinter & m_rPrinter;
rtl::OUString toString(const uno::Any & rStatus);
public:
ProgressHandler(MessagePrinter & rThePrinter): m_rPrinter(rThePrinter) {}
virtual uno::Any SAL_CALL queryInterface(
const uno::Type & rType)
throw(uno::RuntimeException);
virtual void SAL_CALL acquire() throw ()
{ OWeakObject::acquire(); }
virtual void SAL_CALL release() throw ()
{ OWeakObject::release(); }
virtual void SAL_CALL push(const uno::Any & rStatus)
throw (uno::RuntimeException);
virtual void SAL_CALL update(const uno::Any & rStatus)
throw (uno::RuntimeException);
virtual void SAL_CALL pop() throw (uno::RuntimeException);
};
rtl::OUString ProgressHandler::toString(const uno::Any & rStatus)
{
ucb::CHAOSProgressStart aStart;
if (rStatus >>= aStart)
{
rtl::OUString sResult;
if (aStart.Text.getLength() > 0)
{
sResult = aStart.Text;
sResult += rtl::OUString::createFromAscii(" ");
}
sResult += rtl::OUString::createFromAscii("[");
sResult += rtl::OUString::valueOf(aStart.Minimum);
sResult += rtl::OUString::createFromAscii("..");
sResult += rtl::OUString::valueOf(aStart.Maximum);
sResult += rtl::OUString::createFromAscii("]");
return sResult;
}
rtl::OUString sText;
if (rStatus >>= sText)
return sText;
sal_Int32 nValue;
if (rStatus >>= nValue)
{
rtl::OUString sResult = rtl::OUString::createFromAscii("..");
sResult += rtl::OUString::valueOf(nValue);
sResult += rtl::OUString::createFromAscii("..");
return rtl::OUString(sResult);
}
return rtl::OUString::createFromAscii("(Unknown object)");
}
//============================================================================
// virtual
uno::Any SAL_CALL
ProgressHandler::queryInterface( const uno::Type & rType )
throw(uno::RuntimeException)
{
uno::Any aRet = cppu::queryInterface(
rType,
static_cast< ucb::XProgressHandler* >(this));
return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
}
//============================================================================
// virtual
void SAL_CALL ProgressHandler::push(const uno::Any & rStatus)
throw (uno::RuntimeException)
{
rtl::OUString sMessage = rtl::OUString::createFromAscii("Status push: ");
sMessage += toString(rStatus);
m_rPrinter.print(sMessage);
}
//============================================================================
// virtual
void SAL_CALL ProgressHandler::update(const uno::Any & rStatus)
throw (uno::RuntimeException)
{
rtl::OUString sMessage = rtl::OUString::createFromAscii("Status update: ");
sMessage += toString(rStatus);
m_rPrinter.print(sMessage);
}
//============================================================================
// virtual
void SAL_CALL ProgressHandler::pop() throw (uno::RuntimeException)
{
m_rPrinter.print("Status pop");
}
/*========================================================================
*
* Ucb.
*
*=======================================================================*/
#define UCB_MODULE_NAME "ucb1"
class Ucb : public MessagePrinter
{
private:
uno::Reference< lang::XMultiServiceFactory > m_xFac;
uno::Reference< ucb::XContentProvider > m_xProv;
uno::Reference< ucb::XContentIdentifierFactory > m_xIdFac;
rtl::OUString m_aConfigurationKey1;
rtl::OUString m_aConfigurationKey2;
sal_Bool m_bInited : 1;
static rtl::OUString getUnoURL();
public:
Ucb( uno::Reference< lang::XMultiServiceFactory >& rxFactory,
rtl::OUString const & rConfigurationKey1,
rtl::OUString const & rConfigurationKey2 );
~Ucb();
sal_Bool init();
uno::Reference< lang::XMultiServiceFactory > getServiceFactory() const
{ return m_xFac; }
uno::Reference< ucb::XContentIdentifierFactory >
getContentIdentifierFactory();
uno::Reference< ucb::XContentProvider >
getContentProvider();
static rtl::OUString m_aProtocol;
};
// static
rtl::OUString Ucb::m_aProtocol;
//-------------------------------------------------------------------------
// static
rtl::OUString Ucb::getUnoURL()
{
rtl::OUString aUnoURL(rtl::OUString::createFromAscii(
"uno:socket,host=localhost,port=8121;"));
if (m_aProtocol.getLength() == 0)
aUnoURL += rtl::OUString::createFromAscii("urp");
else
aUnoURL += m_aProtocol;
aUnoURL += rtl::OUString::createFromAscii(";UCB.Factory");
return aUnoURL;
}
//-------------------------------------------------------------------------
Ucb::Ucb( uno::Reference< lang::XMultiServiceFactory >& rxFactory,
rtl::OUString const & rConfigurationKey1,
rtl::OUString const & rConfigurationKey2 )
: m_xFac( rxFactory ),
m_aConfigurationKey1( rConfigurationKey1 ),
m_aConfigurationKey2( rConfigurationKey2 ),
m_bInited( sal_False )
{
}
//-------------------------------------------------------------------------
Ucb::~Ucb()
{
}
//-------------------------------------------------------------------------
sal_Bool Ucb::init()
{
if ( m_bInited )
return sal_True;
// Create auto configured UCB:
if (m_xFac.is())
try
{
rtl::OUString aPipe;
vos::OSecurity().getUserIdent(aPipe);
uno::Sequence< uno::Any > aArgs(4);
aArgs[0] <<= m_aConfigurationKey1;
aArgs[1] <<= m_aConfigurationKey2;
aArgs[2] <<= rtl::OUString::createFromAscii("PIPE");
aArgs[3] <<= aPipe;
#if 0
m_xProv
= uno::Reference< XContentProvider >(
m_xFac->
createInstanceWithArguments(
rtl::OUString::createFromAscii(
"com.sun.star.ucb."
"UniversalContentBroker"),
aArgs),
uno::UNO_QUERY);
#else
::ucbhelper::ContentBroker::initialize( m_xFac, aArgs );
m_xProv
= ::ucbhelper::ContentBroker::get()->getContentProviderInterface();
#endif
}
catch (uno::Exception const &) {}
if (m_xProv.is())
{
print("UCB initialized");
uno::Reference< ucb::XContentProviderManager > xProvMgr(
m_xProv, uno::UNO_QUERY);
if (xProvMgr.is())
{
print("Registered schemes:");
uno::Sequence< ucb::ContentProviderInfo >
aInfos(xProvMgr->queryContentProviders());
for (sal_Int32 i = 0; i < aInfos.getLength(); ++i)
{
String aText(RTL_CONSTASCII_USTRINGPARAM(" "));
aText += UniString(aInfos[i].Scheme);
print(aText);
}
}
}
else
print("Error initializing UCB");
m_bInited = m_xProv.is();
return m_bInited;
}
//-------------------------------------------------------------------------
uno::Reference< ucb::XContentIdentifierFactory >
Ucb::getContentIdentifierFactory()
{
if ( !m_xIdFac.is() )
{
if ( init() )
m_xIdFac = uno::Reference< ucb::XContentIdentifierFactory >(
m_xProv, uno::UNO_QUERY );
}
return m_xIdFac;
}
//-------------------------------------------------------------------------
uno::Reference< ucb::XContentProvider > Ucb::getContentProvider()
{
if ( !m_xProv.is() )
init();
return m_xProv;
}
/*========================================================================
*
* UcbTaskEnvironment.
*
*=======================================================================*/
class UcbTaskEnvironment : public cppu::OWeakObject,
public ucb::XCommandEnvironment
{
uno::Reference< task::XInteractionHandler > m_xInteractionHandler;
uno::Reference< ucb::XProgressHandler > m_xProgressHandler;
public:
UcbTaskEnvironment( const uno::Reference< task::XInteractionHandler>&
rxInteractionHandler,
const uno::Reference< ucb::XProgressHandler>&
rxProgressHandler );
virtual ~UcbTaskEnvironment();
// Interface implementations...
// XInterface
virtual uno::Any SAL_CALL queryInterface( const uno::Type & rType )
throw( uno::RuntimeException );
virtual void SAL_CALL acquire()
throw();
virtual void SAL_CALL release()
throw();
// XCommandEnvironemnt
virtual uno::Reference<task::XInteractionHandler> SAL_CALL
getInteractionHandler()
throw (uno::RuntimeException)
{ return m_xInteractionHandler; }
virtual uno::Reference<ucb::XProgressHandler> SAL_CALL
getProgressHandler()
throw (uno::RuntimeException)
{ return m_xProgressHandler; }
};
//-------------------------------------------------------------------------
UcbTaskEnvironment::UcbTaskEnvironment(
const uno::Reference< task::XInteractionHandler >&
rxInteractionHandler,
const uno::Reference< ucb::XProgressHandler >&
rxProgressHandler )
: m_xInteractionHandler( rxInteractionHandler ),
m_xProgressHandler( rxProgressHandler )
{
}
//-------------------------------------------------------------------------
// virtual
UcbTaskEnvironment::~UcbTaskEnvironment()
{
}
//----------------------------------------------------------------------------
//
// XInterface methods
//
//----------------------------------------------------------------------------
// virtual
uno::Any SAL_CALL
UcbTaskEnvironment::queryInterface( const uno::Type & rType )
throw( uno::RuntimeException )
{
uno::Any aRet = cppu::queryInterface(
rType, static_cast< ucb::XCommandEnvironment* >( this ) );
return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
}
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbTaskEnvironment::acquire()
throw()
{
OWeakObject::acquire();
}
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbTaskEnvironment::release()
throw()
{
OWeakObject::release();
}
/*========================================================================
*
* UcbCommandProcessor.
*
*=======================================================================*/
class UcbCommandProcessor : public MessagePrinter
{
protected:
Ucb& m_rUCB;
private:
uno::Reference< ucb::XCommandProcessor > m_xProcessor;
sal_Int32 m_aCommandId;
public:
UcbCommandProcessor( Ucb& rUCB,
const uno::Reference<
ucb::XCommandProcessor >& rxProcessor,
MyOutWindow* pOutEdit );
virtual ~UcbCommandProcessor();
uno::Any executeCommand( const rtl::OUString& rName,
const uno::Any& rArgument,
bool bPrint = true );
};
//-------------------------------------------------------------------------
UcbCommandProcessor::UcbCommandProcessor( Ucb& rUCB,
const uno::Reference<
ucb::XCommandProcessor >&
rxProcessor,
MyOutWindow* pOutEdit)
: MessagePrinter( pOutEdit ),
m_rUCB( rUCB ),
m_xProcessor( rxProcessor ),
m_aCommandId( 0 )
{
if ( m_xProcessor.is() )
{
// Generally, one command identifier per thread is enough. It
// can be used for all commands executed by the processor which
// created this id.
m_aCommandId = m_xProcessor->createCommandIdentifier();
}
}
//----------------------------------------------------------------------------
// virtual
UcbCommandProcessor::~UcbCommandProcessor()
{
}
//----------------------------------------------------------------------------
uno::Any UcbCommandProcessor::executeCommand( const rtl::OUString& rName,
const uno::Any& rArgument,
bool bPrint )
{
if ( m_xProcessor.is() )
{
ucb::Command aCommand;
aCommand.Name = rName;
aCommand.Handle = -1; /* unknown */
aCommand.Argument = rArgument;
uno::Reference< task::XInteractionHandler > xInteractionHandler;
if (m_rUCB.getServiceFactory().is())
xInteractionHandler
= uno::Reference< task::XInteractionHandler >(
m_rUCB.getServiceFactory()->
createInstance(
rtl::OUString::createFromAscii(
"com.sun.star.task.InteractionHandler")),
uno::UNO_QUERY);
uno::Reference< ucb::XProgressHandler >
xProgressHandler(new ProgressHandler(m_rUCB));
uno::Reference< ucb::XCommandEnvironment > xEnv(
new UcbTaskEnvironment( xInteractionHandler, xProgressHandler ) );
if ( bPrint )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Executing command: " ) ) );
aText += UniString( rName );
print( aText );
}
// Execute command
uno::Any aResult;
bool bException = false;
bool bAborted = false;
try
{
aResult = m_xProcessor->execute( aCommand, m_aCommandId, xEnv );
}
catch ( ucb::CommandAbortedException const & )
{
bAborted = true;
}
catch ( uno::Exception const & )
{
bException = true;
}
if ( bPrint )
{
if ( bException )
print( "execute(...) threw an exception!" );
if ( bAborted )
print( "execute(...) aborted!" );
if ( !bException && !bAborted )
print( "execute() finished." );
}
return aResult;
}
print( "executeCommand failed!" );
return uno::Any();
}
/*========================================================================
*
* UcbContent.
*
*=======================================================================*/
class UcbContent : public UcbCommandProcessor,
public cppu::OWeakObject,
public ucb::XContentEventListener,
public beans::XPropertiesChangeListener
{
uno::Reference< ucb::XContent > m_xContent;
struct OpenStackEntry
{
uno::Reference< ucb::XContentIdentifier > m_xIdentifier;
uno::Reference< ucb::XContent > m_xContent;
sal_uInt32 m_nLevel;
bool m_bUseIdentifier;
OpenStackEntry(uno::Reference< ucb::XContentIdentifier > const &
rTheIdentifier,
sal_uInt32 nTheLevel):
m_xIdentifier(rTheIdentifier), m_nLevel(nTheLevel),
m_bUseIdentifier(true) {}
OpenStackEntry(uno::Reference< ucb::XContent > const & rTheContent,
sal_uInt32 nTheLevel):
m_xContent(rTheContent), m_nLevel(nTheLevel),
m_bUseIdentifier(false) {}
};
typedef std::stack< OpenStackEntry > OpenStack;
private:
UcbContent( Ucb& rUCB,
uno::Reference< ucb::XContent >& rxContent,
MyOutWindow* pOutEdit );
protected:
virtual ~UcbContent();
public:
static UcbContent* create(
Ucb& rUCB, const UniString& rURL, MyOutWindow* pOutEdit );
void dispose();
const UniString getURL() const;
const UniString getType() const;
uno::Sequence< ucb::CommandInfo > getCommands();
uno::Sequence< beans::Property > getProperties();
uno::Any getPropertyValue( const rtl::OUString& rName );
void setPropertyValue( const rtl::OUString& rName, const uno::Any& rValue );
void addProperty ( const rtl::OUString& rName, const uno::Any& rValue );
void removeProperty ( const rtl::OUString& rName );
rtl::OUString getStringPropertyValue( const rtl::OUString& rName );
void setStringPropertyValue( const rtl::OUString& rName,
const rtl::OUString& rValue );
void addStringProperty( const rtl::OUString& rName,
const rtl::OUString& rValue );
void open( const rtl::OUString & rName, const UniString& rInput,
bool bPrint, bool bTiming, bool bSort,
OpenStack * pStack = 0, sal_uInt32 nLevel = 0,
sal_Int32 nFetchSize = 0 );
void openAll( Ucb& rUCB, bool bPrint, bool bTiming, bool bSort,
sal_Int32 nFetchSize );
void transfer( const rtl::OUString& rSourceURL, sal_Bool bMove );
void destroy();
// XInterface
virtual uno::Any SAL_CALL queryInterface( const uno::Type & rType )
throw( uno::RuntimeException );
virtual void SAL_CALL
acquire()
throw();
virtual void SAL_CALL
release()
throw();
// XEventListener
// ( base interface of XContentEventListener, XPropertiesChangeListener )
virtual void SAL_CALL
disposing( const lang::EventObject& Source )
throw( uno::RuntimeException );
// XContentEventListener
virtual void SAL_CALL
contentEvent( const ucb::ContentEvent& evt )
throw( uno::RuntimeException );
// XPropertiesChangeListener
virtual void SAL_CALL
propertiesChange( const uno::Sequence< beans::PropertyChangeEvent >& evt )
throw( uno::RuntimeException );
};
//-------------------------------------------------------------------------
UcbContent::UcbContent( Ucb& rUCB,
uno::Reference< ucb::XContent >& rxContent,
MyOutWindow* pOutEdit)
: UcbCommandProcessor( rUCB,
uno::Reference< ucb::XCommandProcessor >(
rxContent, uno::UNO_QUERY ),
pOutEdit ),
m_xContent( rxContent )
{
}
//----------------------------------------------------------------------------
// virtual
UcbContent::~UcbContent()
{
}
//-------------------------------------------------------------------------
// static
UcbContent* UcbContent::create(
Ucb& rUCB, const UniString& rURL, MyOutWindow* pOutEdit )
{
if ( !rURL.Len() )
return NULL;
//////////////////////////////////////////////////////////////////////
// Get XContentIdentifier interface from UCB and let it create an
// identifer for the given URL.
//////////////////////////////////////////////////////////////////////
uno::Reference< ucb::XContentIdentifierFactory > xIdFac =
rUCB.getContentIdentifierFactory();
if ( !xIdFac.is() )
return NULL;
uno::Reference< ucb::XContentIdentifier > xId =
xIdFac->createContentIdentifier( rURL );
if ( !xId.is() )
return NULL;
//////////////////////////////////////////////////////////////////////
// Get XContentProvider interface from UCB and let it create a
// content for the given identifier.
//////////////////////////////////////////////////////////////////////
uno::Reference< ucb::XContentProvider > xProv
= rUCB.getContentProvider();
if ( !xProv.is() )
return NULL;
uno::Reference< ucb::XContent > xContent;
try
{
xContent = xProv->queryContent( xId );
}
catch (ucb::IllegalIdentifierException const &) {}
if ( !xContent.is() )
return NULL;
UcbContent* pNew = new UcbContent( rUCB, xContent, pOutEdit );
pNew->acquire();
// Register listener(s).
xContent->addContentEventListener( pNew );
uno::Reference< beans::XPropertiesChangeNotifier > xNotifier(
xContent, uno::UNO_QUERY );
if ( xNotifier.is() )
{
// Empty sequence -> interested in any property changes.
xNotifier->addPropertiesChangeListener(
uno::Sequence< rtl::OUString >(), pNew );
}
return pNew;
}
//-------------------------------------------------------------------------
const UniString UcbContent::getURL() const
{
uno::Reference< ucb::XContentIdentifier > xId(
m_xContent->getIdentifier() );
if ( xId.is() )
return UniString( xId->getContentIdentifier() );
return UniString();
}
//-------------------------------------------------------------------------
const UniString UcbContent::getType() const
{
const UniString aType( m_xContent->getContentType() );
return aType;
}
//-------------------------------------------------------------------------
void UcbContent::dispose()
{
uno::Reference< lang::XComponent > xComponent( m_xContent, uno::UNO_QUERY );
if ( xComponent.is() )
xComponent->dispose();
}
//----------------------------------------------------------------------------
void UcbContent::open( const rtl::OUString & rName, const UniString& rInput,
bool bPrint, bool bTiming, bool bSort,
OpenStack * pStack, sal_uInt32 nLevel,
sal_Int32 nFetchSize )
{
uno::Any aArg;
bool bDoSort = false;
ucb::OpenCommandArgument2 aOpenArg;
if (rName.compareToAscii("search") == 0)
{
ucb::SearchCommandArgument aArgument;
if (!parseSearchArgument(rInput, aArgument.Info))
{
print("Can't parse search argument");
return;
}
aArgument.Properties.realloc(5);
aArgument.Properties[0].Name = rtl::OUString::createFromAscii("Title");
aArgument.Properties[0].Handle = -1;
aArgument.Properties[1].Name
= rtl::OUString::createFromAscii("DateCreated");
aArgument.Properties[1].Handle = -1;
aArgument.Properties[2].Name = rtl::OUString::createFromAscii("Size");
aArgument.Properties[2].Handle = -1;
aArgument.Properties[3].Name
= rtl::OUString::createFromAscii("IsFolder");
aArgument.Properties[3].Handle = -1;
aArgument.Properties[4].Name
= rtl::OUString::createFromAscii("IsDocument");
aArgument.Properties[4].Handle = -1;
aArg <<= aArgument;
}
else
{
aOpenArg.Mode = ucb::OpenMode::ALL;
aOpenArg.Priority = 32768;
// if ( bFolder )
{
// Property values which shall be in the result set...
uno::Sequence< beans::Property > aProps( 5 );
beans::Property* pProps = aProps.getArray();
pProps[ 0 ].Name = rtl::OUString::createFromAscii( "Title" );
pProps[ 0 ].Handle = -1; // Important!
/**/ pProps[ 0 ].Type = getCppuType(static_cast< rtl::OUString * >(0));
// HACK for sorting...
pProps[ 1 ].Name = rtl::OUString::createFromAscii( "DateCreated" );
pProps[ 1 ].Handle = -1; // Important!
pProps[ 2 ].Name = rtl::OUString::createFromAscii( "Size" );
pProps[ 2 ].Handle = -1; // Important!
pProps[ 3 ].Name = rtl::OUString::createFromAscii( "IsFolder" );
pProps[ 3 ].Handle = -1; // Important!
/**/ pProps[ 3 ].Type = getCppuType(static_cast< sal_Bool * >(0));
// HACK for sorting...
pProps[ 4 ].Name = rtl::OUString::createFromAscii( "IsDocument" );
pProps[ 4 ].Handle = -1; // Important!
aOpenArg.Properties = aProps;
bDoSort = bSort;
if (bDoSort)
{
// Sort criteria... Note that column numbering starts with 1!
aOpenArg.SortingInfo.realloc(2);
// primary sort criterium: column 4 --> IsFolder
aOpenArg.SortingInfo[ 0 ].ColumnIndex = 4;
aOpenArg.SortingInfo[ 0 ].Ascending = sal_False;
// secondary sort criterium: column 1 --> Title
aOpenArg.SortingInfo[ 1 ].ColumnIndex = 1;
aOpenArg.SortingInfo[ 1 ].Ascending = sal_True;
}
}
// else
aOpenArg.Sink
= static_cast< cppu::OWeakObject * >(new TestOutputStream);
aArg <<= aOpenArg;
}
// putenv("PROT_REMOTE_ACTIVATE=1"); // to log remote uno traffic
ULONG nTime = 0;
if ( bTiming )
nTime = Time::GetSystemTicks();
uno::Any aResult = executeCommand( rName, aArg, bPrint );
uno::Reference< ucb::XDynamicResultSet > xDynamicResultSet;
if ( ( aResult >>= xDynamicResultSet ) && xDynamicResultSet.is() )
{
if (bDoSort)
{
sal_Int16 nCaps = xDynamicResultSet->getCapabilities();
if (!(nCaps & ucb::ContentResultSetCapability::SORTED))
{
if (bPrint)
print("Result set rows are not sorted"
"---using sorting cursor");
uno::Reference< ucb::XSortedDynamicResultSetFactory >
xSortedFactory;
if (m_rUCB.getServiceFactory().is())
xSortedFactory
= uno::Reference<
ucb::XSortedDynamicResultSetFactory >(
m_rUCB.
getServiceFactory()->
createInstance(
rtl::OUString::createFromAscii(
"com.sun.star.ucb.SortedDynamic"
"ResultSetFactory")),
uno::UNO_QUERY);
uno::Reference< ucb::XDynamicResultSet > xSorted;
if (xSortedFactory.is())
xSorted
= xSortedFactory->
createSortedDynamicResultSet(xDynamicResultSet,
aOpenArg.
SortingInfo,
0);
if (xSorted.is())
xDynamicResultSet = xSorted;
else
print("Sorting cursor not available!");
}
}
uno::Reference< sdbc::XResultSet > xResultSet(
xDynamicResultSet->getStaticResultSet() );
if ( xResultSet.is() )
{
if ( bPrint )
{
print( "Folder object opened - iterating:" );
print( UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM(
"Content-ID : Title : Size : IsFolder : IsDocument\n"
"-------------------------------------------------" ) ) );
}
if (nFetchSize > 0)
{
bool bSet = false;
uno::Reference< beans::XPropertySet > xProperties(
xResultSet, uno::UNO_QUERY);
if (xProperties.is())
try
{
xProperties->
setPropertyValue(rtl::OUString::createFromAscii(
"FetchSize"),
uno::makeAny(nFetchSize));
bSet = true;
}
catch (beans::UnknownPropertyException const &) {}
catch (beans::PropertyVetoException const &) {}
catch (lang::IllegalArgumentException const &) {}
catch (lang::WrappedTargetException const &) {}
if (!bSet)
print("Fetch size not set!");
}
try
{
ULONG n = 0;
uno::Reference< ucb::XContentAccess > xContentAccess(
xResultSet, uno::UNO_QUERY );
uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
while ( xResultSet->next() )
{
UniString aText;
if ( bPrint )
{
rtl::OUString aId( xContentAccess->
queryContentIdentifierString() );
aText += UniString::CreateFromInt32( ++n );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
") " ) );
aText += UniString( aId );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
" : " ) );
}
// Title:
UniString aTitle( xRow->getString( 1 ) );
if ( bPrint )
{
if ( aTitle.Len() == 0 && xRow->wasNull() )
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
"<null>" ) );
else
aText += aTitle;
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
" : " ) );
}
// Size:
sal_Int32 nSize = xRow->getInt( 3 );
if ( bPrint )
{
if ( nSize == 0 && xRow->wasNull() )
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
"<null>" ) );
else
aText += UniString::CreateFromInt32( nSize );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
" : " ) );
}
// IsFolder:
sal_Bool bFolder = xRow->getBoolean( 4 );
if ( bPrint )
{
if ( !bFolder && xRow->wasNull() )
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
"<null>" ) );
else
aText
+= bFolder ?
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"true" ) ) :
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"false" ) );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
" : " ) );
}
// IsDocument:
sal_Bool bDocument = xRow->getBoolean( 5 );
if ( bPrint )
{
if ( !bFolder && xRow->wasNull() )
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
"<null>" ) );
else
aText
+= bDocument ?
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"true" ) ) :
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"false" ) ); // IsDocument
}
if ( bPrint )
print( aText );
if ( pStack && bFolder )
pStack->push( OpenStackEntry(
#if 1
xContentAccess->
queryContentIdentifier(),
#else
xContentAccess->queryContent(),
#endif
nLevel + 1 ) );
}
}
catch ( ucb::ResultSetException )
{
print( "ResultSetException caught!" );
}
if ( bPrint )
print( "Iteration done." );
}
}
uno::Reference< lang::XComponent > xComponent(
xDynamicResultSet, uno::UNO_QUERY);
if (xComponent.is())
xComponent->dispose();
// putenv("PROT_REMOTE_ACTIVATE="); // to log remote uno traffic
if ( bTiming )
{
nTime = Time::GetSystemTicks() - nTime;
UniString
aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "Operation took " ) ) );
aText += UniString::CreateFromInt64( nTime );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " ms." ) );
print( aText );
}
}
//----------------------------------------------------------------------------
void UcbContent::openAll( Ucb& rUCB, bool bPrint, bool bTiming, bool bSort,
sal_Int32 nFetchSize )
{
ULONG nTime = 0;
if ( bTiming )
nTime = Time::GetSystemTicks();
OpenStack aStack;
aStack.push( OpenStackEntry( m_xContent, 0 ) );
while ( !aStack.empty() )
{
OpenStackEntry aEntry( aStack.top() );
aStack.pop();
if ( bPrint )
{
UniString aText;
for ( sal_uInt32 i = aEntry.m_nLevel; i != 0; --i )
aText += '=';
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "LEVEL " ) );
aText += UniString::CreateFromInt64( aEntry.m_nLevel );
uno::Reference< ucb::XContentIdentifier > xID;
if ( aEntry.m_bUseIdentifier )
xID = aEntry.m_xIdentifier;
else if ( aEntry.m_xContent.is() )
xID = aEntry.m_xContent->getIdentifier();
if ( xID.is() )
{
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
aText += UniString( xID->getContentIdentifier() );
}
print( aText );
}
uno::Reference< ucb::XContent > xChild;
if ( aEntry.m_bUseIdentifier )
{
uno::Reference< ucb::XContentProvider > xProv
= rUCB.getContentProvider();
if ( !xProv.is() )
{
print( "No content provider" );
return;
}
try
{
xChild = xProv->queryContent( aEntry.m_xIdentifier );
}
catch (ucb::IllegalIdentifierException const &) {}
}
else
xChild = aEntry.m_xContent;
if ( !xChild.is() )
{
print( "No content" );
return;
}
UcbContent( m_rUCB, xChild, m_pOutEdit ).
open( UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM(
"open" ) ),
UniString(), bPrint, false, bSort, &aStack,
aEntry.m_nLevel, nFetchSize );
}
if ( bTiming )
{
nTime = Time::GetSystemTicks() - nTime;
UniString
aText( UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM(
"Operation took " ) ) );
aText += UniString::CreateFromInt64( nTime );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " ms." ) );
print( aText );
}
}
//----------------------------------------------------------------------------
void UcbContent::transfer( const rtl::OUString& rSourceURL, sal_Bool bMove )
{
if ( bMove )
print( "Moving content..." );
else
print( "Copying content..." );
#if 1 /* globalTransfer */
uno::Reference< ucb::XCommandProcessor > xCommandProcessor(
m_rUCB.getContentProvider(), uno::UNO_QUERY );
if ( xCommandProcessor.is() )
{
#if 0
ucb::Command aCommand(
rtl::OUString::createFromAscii( "getCommandInfo" ), -1, Any() );
uno::Reference< ucb::XCommandInfo > xInfo;
xCommandProcessor->execute(
aCommand, 0, uno::Reference< ucb::XCommandEnvironment >() )
>>= xInfo;
if ( xInfo.is() )
{
ucb::CommandInfo aInfo
= xInfo->getCommandInfoByName(
rtl::OUString::createFromAscii( "globalTransfer" ) );
uno::Sequence< ucb::CommandInfo > aCommands
= xInfo->getCommands();
const ucb::CommandInfo* pCommands = aCommands.getConstArray();
String aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "Commands:\n" ) ) );
sal_uInt32 nCount = aCommands.getLength();
for ( sal_uInt32 n = 0; n < nCount; ++n )
{
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " " ) );
aText += String( pCommands[ n ].Name );
aText += '\n';
}
print( aText );
}
#endif
ucb::GlobalTransferCommandArgument aArg(
bMove ? ucb::TransferCommandOperation_MOVE
: ucb::TransferCommandOperation_COPY,
rSourceURL,
getURL(),
rtl::OUString(),
//rtl::OUString::createFromAscii( "NewTitle" ),
ucb::NameClash::ERROR );
ucb::Command aTransferCommand( rtl::OUString::createFromAscii(
"globalTransfer" ),
-1,
uno::makeAny( aArg ) );
uno::Reference< task::XInteractionHandler > xInteractionHandler;
if (m_rUCB.getServiceFactory().is())
xInteractionHandler
= uno::Reference< task::XInteractionHandler >(
m_rUCB.getServiceFactory()->
createInstance(
rtl::OUString::createFromAscii(
"com.sun.star.task.InteractionHandler")),
uno::UNO_QUERY);
uno::Reference< ucb::XProgressHandler > xProgressHandler(
new ProgressHandler(m_rUCB));
uno::Reference< ucb::XCommandEnvironment > xEnv(
new UcbTaskEnvironment( xInteractionHandler, xProgressHandler ) );
try
{
xCommandProcessor->execute( aTransferCommand, 0, xEnv );
}
catch ( uno::Exception const & )
{
print( "globalTransfer threw exception!" );
return;
}
print( "globalTransfer finished successfully" );
}
#else /* transfer */
uno::Any aArg;
aArg <<= ucb::TransferInfo(
bMove, rSourceURL, rtl::OUString(), ucb::NameClash::ERROR );
executeCommand( rtl::OUString::createFromAscii( "transfer" ), aArg );
// executeCommand( rtl::OUString::createFromAscii( "flush" ), Any() );
#endif
}
//----------------------------------------------------------------------------
void UcbContent::destroy()
{
print( "Deleting content..." );
uno::Any aArg;
aArg <<= sal_Bool( sal_True ); // delete physically, not only to trash.
executeCommand( rtl::OUString::createFromAscii( "delete" ), aArg );
// executeCommand( rtl::OUString::createFromAscii( "flush" ), Any() );
}
//-------------------------------------------------------------------------
uno::Sequence< ucb::CommandInfo > UcbContent::getCommands()
{
uno::Any aResult = executeCommand(
rtl::OUString::createFromAscii( "getCommandInfo" ), uno::Any() );
uno::Reference< ucb::XCommandInfo > xInfo;
if ( aResult >>= xInfo )
{
uno::Sequence< ucb::CommandInfo > aCommands(
xInfo->getCommands() );
const ucb::CommandInfo* pCommands = aCommands.getConstArray();
String aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "Commands:\n" ) ) );
sal_uInt32 nCount = aCommands.getLength();
for ( sal_uInt32 n = 0; n < nCount; ++n )
{
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " " ) );
aText += String( pCommands[ n ].Name );
aText += '\n';
}
print( aText );
return aCommands;
}
print( "getCommands failed!" );
return uno::Sequence< ucb::CommandInfo >();
}
//-------------------------------------------------------------------------
uno::Sequence< beans::Property > UcbContent::getProperties()
{
uno::Any aResult = executeCommand(
rtl::OUString::createFromAscii( "getPropertySetInfo" ), uno::Any() );
uno::Reference< beans::XPropertySetInfo > xInfo;
if ( aResult >>= xInfo )
{
uno::Sequence< beans::Property > aProps( xInfo->getProperties() );
const beans::Property* pProps = aProps.getConstArray();
String aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "Properties:\n" ) ) );
sal_uInt32 nCount = aProps.getLength();
for ( sal_uInt32 n = 0; n < nCount; ++n )
{
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " " ) );
aText += UniString( pProps[ n ].Name );
aText += '\n';
}
print( aText );
return aProps;
}
print( "getProperties failed!" );
return uno::Sequence< beans::Property >();
}
//----------------------------------------------------------------------------
uno::Any UcbContent::getPropertyValue( const rtl::OUString& rName )
{
uno::Sequence< beans::Property > aProps( 1 );
beans::Property& rProp = aProps.getArray()[ 0 ];
rProp.Name = rName;
rProp.Handle = -1; /* unknown */
// rProp.Type = ;
// rProp.Attributes = ;
uno::Any aArg;
aArg <<= aProps;
uno::Any aResult = executeCommand(
rtl::OUString::createFromAscii( "getPropertyValues" ), aArg );
uno::Reference< sdbc::XRow > xValues;
if ( aResult >>= xValues )
return xValues->getObject(
1, uno::Reference< container::XNameAccess>() );
print( "getPropertyValue failed!" );
return uno::Any();
}
//----------------------------------------------------------------------------
rtl::OUString UcbContent::getStringPropertyValue( const rtl::OUString& rName )
{
uno::Any aAny = getPropertyValue( rName );
if ( aAny.getValueType() == getCppuType( (const ::rtl::OUString *)0 ) )
{
const rtl::OUString aValue(
* static_cast< const rtl::OUString * >( aAny.getValue() ) );
UniString aText( rName );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " value: '" ) );
aText += UniString( aValue );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "'" ) );
print( aText );
return aValue;
}
print( "getStringPropertyValue failed!" );
return rtl::OUString();
}
//----------------------------------------------------------------------------
void UcbContent::setPropertyValue( const rtl::OUString& rName,
const uno::Any& rValue )
{
uno::Sequence< beans::PropertyValue > aProps( 1 );
beans::PropertyValue& rProp = aProps.getArray()[ 0 ];
rProp.Name = rName;
rProp.Handle = -1; /* unknown */
rProp.Value = rValue;
// rProp.State = ;
uno::Any aArg;
aArg <<= aProps;
executeCommand( rtl::OUString::createFromAscii( "setPropertyValues" ),
aArg );
// executeCommand( rtl::OUString::createFromAscii( "flush" ), Any() );
}
//----------------------------------------------------------------------------
void UcbContent::setStringPropertyValue( const rtl::OUString& rName,
const rtl::OUString& rValue )
{
uno::Any aAny;
aAny <<= rValue;
setPropertyValue( rName, aAny );
UniString aText( rName );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " value set to: '" ) );
aText += UniString( rValue );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "'" ) );
print( aText );
}
//----------------------------------------------------------------------------
void UcbContent::addProperty( const rtl::OUString& rName,
const uno::Any& rValue )
{
uno::Reference< beans::XPropertyContainer > xContainer( m_xContent,
uno::UNO_QUERY );
if ( xContainer.is() )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Adding property: " ) ) );
aText += UniString( rName );
print( aText );
try
{
xContainer->addProperty( rName, 0, rValue );
}
catch ( beans::PropertyExistException const & )
{
print( "Adding property failed. Already exists!" );
return;
}
catch ( beans::IllegalTypeException const & )
{
print( "Adding property failed. Illegal Type!" );
return;
}
catch ( lang::IllegalArgumentException const & )
{
print( "Adding property failed. Illegal Argument!" );
return;
}
print( "Adding property succeeded." );
return;
}
print( "Adding property failed. No XPropertyContainer!" );
}
//----------------------------------------------------------------------------
void UcbContent::addStringProperty(
const rtl::OUString& rName, const rtl::OUString& rValue )
{
uno::Any aValue;
aValue <<= rValue;
addProperty( rName, aValue );
}
//----------------------------------------------------------------------------
void UcbContent::removeProperty( const rtl::OUString& rName )
{
uno::Reference< beans::XPropertyContainer > xContainer( m_xContent,
uno::UNO_QUERY );
if ( xContainer.is() )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Removing property: " ) ) );
aText += UniString( rName );
print( aText );
try
{
xContainer->removeProperty( rName );
}
catch ( beans::UnknownPropertyException const & )
{
print( "Adding property failed. Unknown!" );
return;
}
print( "Removing property succeeded." );
return;
}
print( "Removing property failed. No XPropertyContainer!" );
}
//----------------------------------------------------------------------------
//
// XInterface methods
//
//----------------------------------------------------------------------------
// virtual
uno::Any SAL_CALL UcbContent::queryInterface( const uno::Type & rType )
throw(uno::RuntimeException)
{
uno::Any aRet = cppu::queryInterface(
rType,
static_cast< lang::XEventListener* >(
static_cast< ucb::XContentEventListener* >( this ) ),
static_cast< ucb::XContentEventListener* >( this ),
static_cast< beans::XPropertiesChangeListener* >( this ) );
return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
}
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbContent::acquire()
throw()
{
OWeakObject::acquire();
}
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbContent::release()
throw()
{
OWeakObject::release();
}
//----------------------------------------------------------------------------
//
// XEventListener methods.
//
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbContent::disposing( const lang::EventObject& /*Source*/ )
throw( uno::RuntimeException )
{
print ( "Content: disposing..." );
}
//----------------------------------------------------------------------------
//
// XContentEventListener methods,
//
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbContent::contentEvent( const ucb::ContentEvent& evt )
throw( uno::RuntimeException )
{
switch ( evt.Action )
{
case ucb::ContentAction::INSERTED:
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"contentEvent: INSERTED: " ) ) );
if ( evt.Content.is() )
{
uno::Reference< ucb::XContentIdentifier > xId(
evt.Content->getIdentifier() );
aText += UniString( xId->getContentIdentifier() );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " - " ) );
aText += UniString( evt.Content->getContentType() );
}
print( aText );
break;
}
case ucb::ContentAction::REMOVED:
print( "contentEvent: REMOVED" );
break;
case ucb::ContentAction::DELETED:
print( "contentEvent: DELETED" );
break;
case ucb::ContentAction::EXCHANGED:
print( "contentEvent: EXCHANGED" );
break;
case ucb::ContentAction::SEARCH_MATCHED:
{
String aMatch(RTL_CONSTASCII_USTRINGPARAM(
"contentEvent: SEARCH MATCHED "));
if (evt.Id.is())
{
aMatch += String(evt.Id->getContentIdentifier());
if (evt.Content.is())
{
aMatch.AppendAscii(RTL_CONSTASCII_STRINGPARAM(" - "));
aMatch += String(evt.Content->getContentType());
}
}
else
aMatch.AppendAscii(RTL_CONSTASCII_STRINGPARAM("<no id>"));
print(aMatch);
break;
}
default:
print( "contentEvent..." );
break;
}
}
//----------------------------------------------------------------------------
//
// XPropertiesChangeListener methods.
//
//----------------------------------------------------------------------------
// virtual
void SAL_CALL UcbContent::propertiesChange(
const uno::Sequence< beans::PropertyChangeEvent >& evt )
throw( uno::RuntimeException )
{
print( "propertiesChange..." );
sal_uInt32 nCount = evt.getLength();
if ( nCount )
{
const beans::PropertyChangeEvent* pEvents = evt.getConstArray();
for ( sal_uInt32 n = 0; n < nCount; ++n )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( " " ) ) );
aText += UniString( pEvents[ n ].PropertyName );
print( aText );
}
}
}
/*========================================================================
*
* MyWin.
*
*=======================================================================*/
#define MYWIN_ITEMID_CLEAR 1
#define MYWIN_ITEMID_CREATE 2
#define MYWIN_ITEMID_RELEASE 3
#define MYWIN_ITEMID_COMMANDS 4
#define MYWIN_ITEMID_PROPS 5
#define MYWIN_ITEMID_ADD_PROP 6
#define MYWIN_ITEMID_REMOVE_PROP 7
#define MYWIN_ITEMID_GET_PROP 8
#define MYWIN_ITEMID_SET_PROP 9
#define MYWIN_ITEMID_OPEN 10
#define MYWIN_ITEMID_OPEN_ALL 11
#define MYWIN_ITEMID_UPDATE 12
#define MYWIN_ITEMID_SYNCHRONIZE 13
#define MYWIN_ITEMID_COPY 14
#define MYWIN_ITEMID_MOVE 15
#define MYWIN_ITEMID_DELETE 16
#define MYWIN_ITEMID_SEARCH 17
#define MYWIN_ITEMID_TIMING 18
#define MYWIN_ITEMID_SORT 19
#define MYWIN_ITEMID_FETCHSIZE 20
#define MYWIN_ITEMID_SYS2URI 21
#define MYWIN_ITEMID_URI2SYS 22
#define MYWIN_ITEMID_OFFLINE 23
#define MYWIN_ITEMID_ONLINE 24
#define MYWIN_ITEMID_REORGANIZE 25
//-------------------------------------------------------------------------
class MyWin : public WorkWindow
{
private:
ToolBox* m_pTool;
Edit* m_pCmdEdit;
MyOutWindow* m_pOutEdit;
Ucb m_aUCB;
UcbContent* m_pContent;
sal_Int32 m_nFetchSize;
bool m_bTiming;
bool m_bSort;
public:
MyWin( Window *pParent, WinBits nWinStyle,
uno::Reference< lang::XMultiServiceFactory >& rxFactory,
rtl::OUString const & rConfigurationKey1,
rtl::OUString const & rConfigurationKey2 );
virtual ~MyWin();
void Resize( void );
DECL_LINK ( ToolBarHandler, ToolBox* );
void print( const UniString& rText );
void print( const sal_Char* pText );
};
//-------------------------------------------------------------------------
MyWin::MyWin( Window *pParent, WinBits nWinStyle,
uno::Reference< lang::XMultiServiceFactory >& rxFactory,
rtl::OUString const & rConfigurationKey1,
rtl::OUString const & rConfigurationKey2 )
: WorkWindow( pParent, nWinStyle ),
m_pTool( NULL ),
m_pOutEdit( NULL ),
m_aUCB( rxFactory, rConfigurationKey1, rConfigurationKey2 ),
m_pContent( NULL ),
m_nFetchSize( 0 ),
m_bTiming( false ),
m_bSort( false )
{
// ToolBox.
m_pTool = new ToolBox( this, WB_3DLOOK | WB_BORDER | WB_SCROLL );
m_pTool->InsertItem ( MYWIN_ITEMID_CLEAR,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Clear" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_CLEAR,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Clear the Output Window" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_CREATE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Create" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_CREATE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Create a content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_RELEASE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Release" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_RELEASE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Release current content" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_COMMANDS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Commands" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_COMMANDS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Get Commands supported by the content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_PROPS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Properties" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_PROPS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Get Properties supported by the content" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_ADD_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"addProperty" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_ADD_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Add a new string(!) property to the content. "
"Type the property name in the entry field and "
"push this button. The default value for the "
"property will be set to the string 'DefaultValue'" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_REMOVE_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"removeProperty" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_REMOVE_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Removes a property from the content. "
"Type the property name in the entry field and "
"push this button." ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_GET_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"getPropertyValue" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_GET_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Get a string(!) property value from the content. "
"Type the property name in the entry field and "
"push this button to obtain the value" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_SET_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"setPropertyValue" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_SET_PROP,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Set a string(!) property value of the content."
"Type the property name in the entry field and "
"push this button to set the value to the string "
"'NewValue'" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_OPEN,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Open" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_OPEN,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Open the content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_OPEN_ALL,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Open All" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_OPEN_ALL,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Open the content and all of its"
" children" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_UPDATE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Update" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_UPDATE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Update the content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_SYNCHRONIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Synchronize" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_SYNCHRONIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Synchronize the content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_SEARCH,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Search" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_SEARCH,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Search the content" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_REORGANIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Reorganize" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_REORGANIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Reorganize the content storage" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_COPY,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Copy" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_COPY,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Copy a content. Type the URL of the source "
"content into the entry field." ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_MOVE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Move" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_MOVE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Move a content. Type the URL of the source "
"content into the entry field." ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_DELETE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Delete" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_DELETE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Delete the content." ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_TIMING,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Timing" ) ),
TIB_CHECKABLE | TIB_AUTOCHECK );
m_pTool->SetHelpText( MYWIN_ITEMID_TIMING,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Display execution times instead of"
" output" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_SORT,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Sort" ) ),
TIB_CHECKABLE | TIB_AUTOCHECK );
m_pTool->SetHelpText( MYWIN_ITEMID_SORT,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Sort result sets" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_FETCHSIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Fetch Size" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_FETCHSIZE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Set cached cursor fetch size to positive value" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_SYS2URI,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"UNC>URI" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_SYS2URI,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Translate 'System File Path' to URI,"
" if possible" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_URI2SYS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"URI>UNC" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_URI2SYS,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Translate URI to 'System File Path',"
" if possible" ) ) );
m_pTool->InsertSeparator();
m_pTool->InsertItem ( MYWIN_ITEMID_OFFLINE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Offline" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_OFFLINE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Go offline" ) ) );
m_pTool->InsertItem ( MYWIN_ITEMID_ONLINE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Online" ) ) );
m_pTool->SetHelpText( MYWIN_ITEMID_ONLINE,
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Go back online" ) ) );
m_pTool->SetSelectHdl( LINK( this, MyWin, ToolBarHandler ) );
m_pTool->Show();
// Edit.
m_pCmdEdit = new Edit( this );
m_pCmdEdit->SetReadOnly( FALSE );
m_pCmdEdit->SetText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "file:///" ) ) );
m_pCmdEdit->Show();
// MyOutWindow.
m_pOutEdit = new MyOutWindow( this, WB_HSCROLL | WB_VSCROLL | WB_BORDER );
m_pOutEdit->SetReadOnly( TRUE );
m_pOutEdit->Show();
m_aUCB.setOutEdit( m_pOutEdit );
}
//-------------------------------------------------------------------------
// virtual
MyWin::~MyWin()
{
if ( m_pContent )
{
m_pContent->dispose();
m_pContent->release();
}
delete m_pTool;
delete m_pCmdEdit;
delete m_pOutEdit;
}
//-------------------------------------------------------------------------
void MyWin::Resize()
{
Size aWinSize = GetOutputSizePixel();
int nWinW = aWinSize.Width();
int nWinH = aWinSize.Height();
int nBoxH = m_pTool->CalcWindowSizePixel().Height();
m_pTool->SetPosSizePixel (
Point( 0, 0 ), Size ( nWinW, nBoxH ) );
m_pCmdEdit->SetPosSizePixel(
Point( 0, nBoxH ), Size( nWinW, nBoxH ) );
m_pOutEdit->SetPosSizePixel(
Point( 0, nBoxH + nBoxH ), Size ( nWinW, nWinH - ( nBoxH + nBoxH ) ) );
}
//-------------------------------------------------------------------------
void MyWin::print( const sal_Char* pText )
{
print( UniString::CreateFromAscii( pText ) );
}
//-------------------------------------------------------------------------
void MyWin::print( const UniString& rText )
{
vos::OGuard aGuard( Application::GetSolarMutex() );
if ( m_pOutEdit )
{
m_pOutEdit->Append( rText );
m_pOutEdit->Update();
}
}
//-------------------------------------------------------------------------
IMPL_LINK( MyWin, ToolBarHandler, ToolBox*, pToolBox )
{
USHORT nItemId = pToolBox->GetCurItemId();
UniString aCmdLine = m_pCmdEdit->GetText();
ULONG n = Application::ReleaseSolarMutex();
switch( nItemId )
{
case MYWIN_ITEMID_CLEAR:
{
vos::OGuard aGuard( Application::GetSolarMutex() );
m_pOutEdit->Clear();
m_pOutEdit->Show();
break;
}
case MYWIN_ITEMID_CREATE:
if ( m_pContent )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Content released: " ) ) );
aText += m_pContent->getURL();
m_pContent->dispose();
m_pContent->release();
m_pContent = NULL;
print( aText );
}
m_pContent = UcbContent::create( m_aUCB, aCmdLine, m_pOutEdit );
if ( m_pContent )
{
String aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Created content: " ) ) );
aText += String( m_pContent->getURL() );
aText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " - " ) );
aText += String( m_pContent->getType() );
print( aText );
}
else
{
String aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Creation failed for content: " ) ) );
aText += String( aCmdLine );
print( aText );
}
break;
case MYWIN_ITEMID_RELEASE:
if ( m_pContent )
{
UniString aText( UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM(
"Content released: " ) ) );
aText += m_pContent->getURL();
m_pContent->dispose();
m_pContent->release();
m_pContent = NULL;
print( aText );
}
else
print( "No content!" );
break;
case MYWIN_ITEMID_COMMANDS:
if ( m_pContent )
m_pContent->getCommands();
else
print( "No content!" );
break;
case MYWIN_ITEMID_PROPS:
if ( m_pContent )
m_pContent->getProperties();
else
print( "No content!" );
break;
case MYWIN_ITEMID_ADD_PROP:
if ( m_pContent )
m_pContent->addStringProperty(
aCmdLine,
rtl::OUString::createFromAscii( "DefaultValue" ) );
else
print( "No content!" );
break;
case MYWIN_ITEMID_REMOVE_PROP:
if ( m_pContent )
m_pContent->removeProperty( aCmdLine );
else
print( "No content!" );
break;
case MYWIN_ITEMID_GET_PROP:
if ( m_pContent )
m_pContent->getStringPropertyValue( aCmdLine );
else
print( "No content!" );
break;
case MYWIN_ITEMID_SET_PROP:
if ( m_pContent )
m_pContent->setStringPropertyValue(
aCmdLine,
rtl::OUString::createFromAscii( "NewValue" ) );
else
print( "No content!" );
break;
case MYWIN_ITEMID_OPEN:
if ( m_pContent )
m_pContent->open(rtl::OUString::createFromAscii("open"),
aCmdLine, !m_bTiming, m_bTiming, m_bSort, 0,
0, m_nFetchSize);
else
print( "No content!" );
break;
case MYWIN_ITEMID_OPEN_ALL:
if ( m_pContent )
m_pContent->openAll(m_aUCB, !m_bTiming, m_bTiming, m_bSort,
m_nFetchSize);
else
print( "No content!" );
break;
case MYWIN_ITEMID_UPDATE:
if ( m_pContent )
m_pContent->open(rtl::OUString::createFromAscii("update"),
aCmdLine, !m_bTiming, m_bTiming, m_bSort, 0,
0, m_nFetchSize);
else
print( "No content!" );
break;
case MYWIN_ITEMID_SYNCHRONIZE:
if ( m_pContent )
m_pContent->open(rtl::OUString::createFromAscii("synchronize"),
aCmdLine, !m_bTiming, m_bTiming, m_bSort, 0,
0, m_nFetchSize);
else
print( "No content!" );
break;
case MYWIN_ITEMID_SEARCH:
if ( m_pContent )
m_pContent->open(rtl::OUString::createFromAscii("search"),
aCmdLine, !m_bTiming, m_bTiming, m_bSort, 0,
0, m_nFetchSize);
else
print( "No content!" );
break;
case MYWIN_ITEMID_REORGANIZE:
if ( m_pContent )
m_pContent->executeCommand (
rtl::OUString::createFromAscii ("reorganizeData"),
uno::Any());
else
print( "No content!" );
break;
case MYWIN_ITEMID_COPY:
if ( m_pContent )
m_pContent->transfer( aCmdLine, sal_False );
else
print( "No content!" );
break;
case MYWIN_ITEMID_MOVE:
if ( m_pContent )
m_pContent->transfer( aCmdLine, sal_True );
else
print( "No content!" );
break;
case MYWIN_ITEMID_DELETE:
if ( m_pContent )
m_pContent->destroy();
else
print( "No content!" );
break;
case MYWIN_ITEMID_TIMING:
m_bTiming = m_pTool->IsItemChecked(MYWIN_ITEMID_TIMING) != false;
break;
case MYWIN_ITEMID_SORT:
m_bSort = m_pTool->IsItemChecked(MYWIN_ITEMID_SORT) != false;
break;
case MYWIN_ITEMID_FETCHSIZE:
{
m_nFetchSize = aCmdLine.ToInt32();
String aText;
if (m_nFetchSize > 0)
{
aText.AssignAscii("Fetch size set to ");
aText += String::CreateFromInt32(m_nFetchSize);
}
else
aText.AssignAscii("Fetch size reset to default");
print(aText);
break;
}
case MYWIN_ITEMID_SYS2URI:
{
uno::Reference< ucb::XContentProviderManager >
xManager(m_aUCB.getContentProvider(), uno::UNO_QUERY);
DBG_ASSERT(xManager.is(),
"MyWin::ToolBarHandler(): Service lacks interface");
rtl::OUString aURL(getLocalFileURL(xManager));
String aText(RTL_CONSTASCII_USTRINGPARAM("Local file URL: "));
aText += String(aURL);
aText.AppendAscii("\nConversion: ");
aText += aCmdLine;
aText.AppendAscii(" to ");
aText += String(getFileURLFromSystemPath(xManager,
aURL,
aCmdLine));
print(aText);
break;
}
case MYWIN_ITEMID_URI2SYS:
{
uno::Reference< ucb::XContentProviderManager >
xManager(m_aUCB.getContentProvider(), uno::UNO_QUERY);
DBG_ASSERT(xManager.is(),
"MyWin::ToolBarHandler(): Service lacks interface");
String aText(RTL_CONSTASCII_USTRINGPARAM("Conversion: "));
aText += aCmdLine;
aText.AppendAscii(" to ");
aText += String(getSystemPathFromFileURL(xManager,
aCmdLine));
print(aText);
break;
}
case MYWIN_ITEMID_OFFLINE:
case MYWIN_ITEMID_ONLINE:
{
uno::Reference< ucb::XContentProviderManager >
xManager(m_aUCB.getContentProvider(), uno::UNO_QUERY);
uno::Reference< ucb::XCommandProcessor > xProcessor;
if (xManager.is())
xProcessor
= uno::Reference< ucb::XCommandProcessor >(
xManager->queryContentProvider(aCmdLine),
uno::UNO_QUERY);
if (!xProcessor.is())
{
String aText(RTL_CONSTASCII_USTRINGPARAM(
"No offline support for URL "));
aText += aCmdLine;
print(aText);
break;
}
rtl::OUString aName;
uno::Any aArgument;
if (nItemId == MYWIN_ITEMID_OFFLINE)
{
aName = rtl::OUString::createFromAscii("goOffline");
uno::Sequence<
uno::Reference< ucb::XContentIdentifier > >
aIdentifiers(1);
aIdentifiers[0]
= m_aUCB.getContentIdentifierFactory()->
createContentIdentifier(aCmdLine);
aArgument <<= aIdentifiers;
}
else
aName = rtl::OUString::createFromAscii("goOnline");
UcbCommandProcessor(m_aUCB, xProcessor, m_pOutEdit).
executeCommand(aName, aArgument);
break;
}
default: // Ignored.
break;
}
Application::AcquireSolarMutex( n );
return 0;
}
/*========================================================================
*
* MyApp.
*
*=======================================================================*/
class MyApp : public Application
{
public:
virtual void Main();
};
MyApp aMyApp;
//-------------------------------------------------------------------------
// virtual
void MyApp::Main()
{
//////////////////////////////////////////////////////////////////////
// Read command line params.
//////////////////////////////////////////////////////////////////////
rtl::OUString aConfigurationKey1(rtl::OUString::createFromAscii(
UCB_CONFIGURATION_KEY1_LOCAL));
rtl::OUString aConfigurationKey2(rtl::OUString::createFromAscii(
UCB_CONFIGURATION_KEY2_OFFICE));
USHORT nParams = Application::GetCommandLineParamCount();
for ( USHORT n = 0; n < nParams; ++n )
{
String aParam( Application::GetCommandLineParam( n ) );
if (aParam.CompareIgnoreCaseToAscii("-key=",
RTL_CONSTASCII_LENGTH("-key="))
== COMPARE_EQUAL)
{
xub_StrLen nSlash
= aParam.Search('/', RTL_CONSTASCII_LENGTH("-key="));
if (nSlash == STRING_NOTFOUND)
{
aConfigurationKey1
= aParam.Copy(RTL_CONSTASCII_LENGTH("-key="));
aConfigurationKey2 = rtl::OUString();
}
else
{
aConfigurationKey1
= aParam.Copy(RTL_CONSTASCII_LENGTH("-key="),
nSlash - RTL_CONSTASCII_LENGTH("-key="));
aConfigurationKey2
= aParam.Copy(nSlash + 1);
}
}
}
//////////////////////////////////////////////////////////////////////
// Initialize local Service Manager and basic services.
//////////////////////////////////////////////////////////////////////
uno::Reference< lang::XMultiServiceFactory > xFac;
try
{
uno::Reference< uno::XComponentContext > xCtx(
cppu::defaultBootstrap_InitialComponentContext() );
if ( !xCtx.is() )
{
DBG_ERROR( "Error creating initial component context!" );
return;
}
xFac = uno::Reference< lang::XMultiServiceFactory >(
xCtx->getServiceManager(), uno::UNO_QUERY );
if ( !xFac.is() )
{
DBG_ERROR( "No service manager!" );
return;
}
}
catch ( uno::Exception )
{
DBG_ERROR( "Exception during creation of initial component context!" );
return;
}
comphelper::setProcessServiceFactory( xFac );
uno::Reference< lang::XComponent > xComponent( xFac, uno::UNO_QUERY );
//////////////////////////////////////////////////////////////////////
// Create Application Window...
//////////////////////////////////////////////////////////////////////
Help::EnableBalloonHelp();
MyWin *pMyWin = new MyWin( NULL, WB_APP | WB_STDWORK, xFac,
aConfigurationKey1, aConfigurationKey2 );
pMyWin->
SetText(
UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "UCB Demo/Test Application" ) ) );
pMyWin->SetPosSizePixel( 0, 0, 1024, 768 );
pMyWin->Show();
//////////////////////////////////////////////////////////////////////
// Go...
//////////////////////////////////////////////////////////////////////
Execute();
//////////////////////////////////////////////////////////////////////
// Destroy Application Window...
//////////////////////////////////////////////////////////////////////
delete pMyWin;
//////////////////////////////////////////////////////////////////////
// Cleanup.
//////////////////////////////////////////////////////////////////////
::ucbhelper::ContentBroker::deinitialize();
// Dispose local service manager.
if ( xComponent.is() )
xComponent->dispose();
}