xref: /trunk/main/svtools/workben/treecontrol/treetest.cxx (revision 5900e8ec128faec89519683efce668ccd8cc6084)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



#include <stdio.h>
#include <wchar.h>

#include <cppuhelper/bootstrap.hxx>

#include <osl/file.hxx>
#include <osl/process.h>

#include <com/sun/star/bridge/XUnoUrlResolver.hpp>
#include <com/sun/star/frame/XComponentLoader.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/awt/tree/XMutableTreeDataModel.hpp>
#include <com/sun/star/awt/tree/XTreeControl.hpp>
#include <com/sun/star/awt/tree/XTreeExpansionListener.hpp>
#include <com/sun/star/awt/tree/XTreeEditListener.hpp>
#include <com/sun/star/awt/XDialog.hpp>
#include <com/sun/star/awt/XControlModel.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/awt/XControl.hpp>
#include <com/sun/star/awt/XControlContainer.hpp>
#include <com/sun/star/view/SelectionType.hpp>

#include <tools/urlobj.hxx>
#include <vcl/image.hxx>
#include <vcl/graph.hxx>

#include <cppuhelper/implbase2.hxx>

#include <string.h>
#include <rtl/ref.hxx>

#include "imagemgr.hxx"

using rtl::OUString;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::beans;
using namespace com::sun::star::bridge;
using namespace com::sun::star::frame;
using namespace com::sun::star::registry;
using namespace com::sun::star::awt;
using namespace com::sun::star::awt::tree;
using namespace com::sun::star::container;
using namespace com::sun::star::view;
using namespace com::sun::star::util;

class DirectoryTree : public ::cppu::WeakImplHelper2< XTreeExpansionListener, XTreeEditListener >
{
public:
    DirectoryTree( const Reference< XComponentContext >& xComponentContext );
    virtual ~DirectoryTree();

    void fillNode( const Reference< XMutableTreeNode >& xNode );
    void display( const OUString& rURL );

    // XTreeExpansionListener
    virtual void SAL_CALL requestChildNodes( const TreeExpansionEvent& Event ) throw (RuntimeException);
    virtual void SAL_CALL treeExpanding( const TreeExpansionEvent& Event ) throw (ExpandVetoException, RuntimeException);
    virtual void SAL_CALL treeCollapsing( const TreeExpansionEvent& Event ) throw (ExpandVetoException, RuntimeException);
    virtual void SAL_CALL treeExpanded( const TreeExpansionEvent& Event ) throw (RuntimeException);
    virtual void SAL_CALL treeCollapsed( const TreeExpansionEvent& Event ) throw (RuntimeException);

    // XTreeEditListener
    virtual void SAL_CALL nodeEditing( const Reference< XTreeNode >& Node ) throw (VetoException, RuntimeException);
    virtual void SAL_CALL nodeEdited( const Reference< XTreeNode >& Node, const OUString& NewText ) throw (RuntimeException);

    // XEventListener
    virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException);

    Reference< XMultiComponentFactory > mxMultiComponentFactoryServer;
    Reference< XComponentContext > mxComponentContext;
    Reference< XTreeControl > mxTreeControl;
    Reference< XMutableTreeDataModel > mxTreeDataModel;
};

DirectoryTree::DirectoryTree( const Reference< XComponentContext >& xComponentContext )
: mxComponentContext( xComponentContext )
, mxMultiComponentFactoryServer( xComponentContext->getServiceManager() )
{
}

DirectoryTree::~DirectoryTree()
{
}

void DirectoryTree::display( const OUString& rURL )
{
    // some property names for later use
    const OUString sPositionX( RTL_CONSTASCII_USTRINGPARAM( "PositionX" ) );
    const OUString sPositionY( RTL_CONSTASCII_USTRINGPARAM( "PositionY" ) );
    const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM( "Width" ) );
    const OUString sHeight( RTL_CONSTASCII_USTRINGPARAM( "Height" ) );
    const OUString sDataModel( RTL_CONSTASCII_USTRINGPARAM( "DataModel" ) );
    const OUString sSelectionType( RTL_CONSTASCII_USTRINGPARAM( "SelectionType" ) );
    const OUString sShowsRootHandles( RTL_CONSTASCII_USTRINGPARAM( "ShowsRootHandles" ) );
    const OUString sShowsHandles( RTL_CONSTASCII_USTRINGPARAM( "ShowsHandles" ) );
    const OUString sRootDisplayed( RTL_CONSTASCII_USTRINGPARAM( "RootDisplayed" ) );
    const OUString sEditable( RTL_CONSTASCII_USTRINGPARAM( "Editable" ) );
    const OUString sTitle( RTL_CONSTASCII_USTRINGPARAM( "Title" ) );
    const OUString sRowHeight( RTL_CONSTASCII_USTRINGPARAM( "RowHeight" ) );

    // first create a data model for our tree control
    mxTreeDataModel = Reference< XMutableTreeDataModel >(
        mxMultiComponentFactoryServer->createInstanceWithContext(
            OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.tree.MutableTreeDataModel" ) ),
            mxComponentContext ), UNO_QUERY_THROW );

    // now fill it with some sample data
    Reference< XMutableTreeNode > xNode( mxTreeDataModel->createNode( Any( rURL ), false ), UNO_QUERY_THROW );
    xNode->setDataValue( Any( rURL ) );
    xNode->setExpandedGraphicURL( OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/sd/res/triangle_down.png" ) ) );
    xNode->setCollapsedGraphicURL( OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/sd/res/triangle_right.png" ) ) );

    fillNode( xNode );
    mxTreeDataModel->setRoot( xNode );

    // now create the dialog
    Reference< XControlModel > xDialogModel(
        mxMultiComponentFactoryServer->createInstanceWithContext(
            OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.UnoControlDialogModel" ) ),
            mxComponentContext ), UNO_QUERY_THROW );

    Reference< XPropertySet > xDialogPropertySet( xDialogModel, UNO_QUERY_THROW );
    xDialogPropertySet->setPropertyValue( sPositionX,   Any( sal_Int32(50) ) );
    xDialogPropertySet->setPropertyValue( sPositionY,   Any( sal_Int32(50) ) );
    xDialogPropertySet->setPropertyValue( sWidth,       Any( sal_Int32(256) ) );
    xDialogPropertySet->setPropertyValue( sHeight,      Any( sal_Int32(256) ) );
    xDialogPropertySet->setPropertyValue( sTitle,       Any( OUString( RTL_CONSTASCII_USTRINGPARAM( "Tree Control Test" ) ) ) );

    Reference< XMultiServiceFactory > xDialogMSF( xDialogModel, UNO_QUERY_THROW );

    // now create our tree control
    Reference< XControlModel > xTreeControlModel(
        xDialogMSF->createInstance(
            OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.tree.TreeControlModel" ) ) ),
            UNO_QUERY_THROW );

    Reference< XPropertySet > XTreeControlModelSet( xTreeControlModel, UNO_QUERY_THROW );

    XTreeControlModelSet->setPropertyValue( sSelectionType, Any( SelectionType_NONE ) );
    XTreeControlModelSet->setPropertyValue( sPositionX,     Any( sal_Int32(3) ) );
    XTreeControlModelSet->setPropertyValue( sPositionY,     Any( sal_Int32(3) ) );
    XTreeControlModelSet->setPropertyValue( sWidth,         Any( sal_Int32(253) ) );
    XTreeControlModelSet->setPropertyValue( sHeight,        Any( sal_Int32(253) ) );
    XTreeControlModelSet->setPropertyValue( sDataModel,     Any( mxTreeDataModel ) );
    XTreeControlModelSet->setPropertyValue( sShowsRootHandles,Any( sal_False ) );
    XTreeControlModelSet->setPropertyValue( sShowsHandles,  Any( sal_False ) );
    XTreeControlModelSet->setPropertyValue( sRootDisplayed, Any( sal_True ) );
    XTreeControlModelSet->setPropertyValue( sEditable,      Any( sal_True ) );
//  XTreeControlModelSet->setPropertyValue( sRowHeight,     Any( sal_Int32( 12 ) ) );

    Reference< XNameContainer > xDialogModelContainer( xDialogModel, UNO_QUERY_THROW );

    const OUString sTreeControlName( RTL_CONSTASCII_USTRINGPARAM( "tree" ) );

    xDialogModelContainer->insertByName( sTreeControlName, Any( xTreeControlModel ) );

    // now create the peers
    Reference< XControl > xDialogControl(
        mxMultiComponentFactoryServer->createInstanceWithContext(
            OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.UnoControlDialog" ) ),
            mxComponentContext ), UNO_QUERY_THROW );

    xDialogControl->setModel( xDialogModel );

    Reference< XToolkit > xToolkit(
        mxMultiComponentFactoryServer->createInstanceWithContext(
            OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.Toolkit" ) ),
            mxComponentContext ), UNO_QUERY_THROW );
    xDialogControl->createPeer( xToolkit, 0 );

    // get the peers of the sub controls from the dialog peer container
    Reference< XControlContainer > xDialogContainer( xDialogControl, UNO_QUERY_THROW );
    mxTreeControl = Reference< XTreeControl >( xDialogContainer->getControl( sTreeControlName ), UNO_QUERY_THROW );

    Reference< XTreeExpansionListener > xListener( static_cast<XWeak*>(this), UNO_QUERY_THROW );
    mxTreeControl->addTreeExpansionListener( xListener );
    Reference< XDialog > xDialog( xDialogControl, UNO_QUERY_THROW );
    xDialog->execute();
}

void DirectoryTree::fillNode( const Reference< XMutableTreeNode >& xNode )
{
    if( xNode->getChildCount() == 0 )
    {
        OUString sParentPath;
        xNode->getDataValue() >>= sParentPath;

        osl::Directory aDirectory( sParentPath );
        if( aDirectory.open() == osl::Directory::E_None )
        {
            osl::DirectoryItem aItem;
            osl::FileStatus fs( FileStatusMask_Type | FileStatusMask_FileURL);
            while( aDirectory.getNextItem( aItem, 0xffffffff ) == osl::Directory::E_None )
            {
                if (aItem.getFileStatus(fs) == osl::FileBase::E_None)
                {
                    bool bDirectory = fs.getFileType() == osl::FileStatus::Directory;
                    Reference< XMutableTreeNode > xChildNode( mxTreeDataModel->createNode( Any( fs.getFileName() ), bDirectory ), UNO_QUERY_THROW );
                    xChildNode->setDataValue( Any( fs.getFileURL() ) );
                    if( bDirectory )
                    {
                        xChildNode->setExpandedGraphicURL( OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/sd/res/triangle_down.png" ) ) );
                        xChildNode->setCollapsedGraphicURL( OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/sd/res/triangle_right.png" ) ) );
                    }
                    else
                    {
                        xChildNode->setNodeGraphicURL( OUString( RTL_CONSTASCII_USTRINGPARAM("private:graphicrepository/sw/imglst/nc20010.png") ) );
                    }
                    xNode->appendChild( xChildNode );
                }
            }
        }
    }
}

// XTreeExpansionListener
void SAL_CALL DirectoryTree::requestChildNodes( const TreeExpansionEvent& rEvent ) throw (RuntimeException)
{
    if( rEvent.Node.is() && rEvent.Node->hasChildsOnDemand() )
    {
        Reference< XMutableTreeNode > xNode( rEvent.Node, UNO_QUERY );
        if( xNode.is() )
        {
            fillNode( xNode );
            xNode->setHasChildsOnDemand( sal_False );
        }
    }
}

void SAL_CALL DirectoryTree::treeExpanding( const TreeExpansionEvent& /*rEvent*/ ) throw (ExpandVetoException, RuntimeException)
{
}

void SAL_CALL DirectoryTree::treeCollapsing( const TreeExpansionEvent&  ) throw (ExpandVetoException, RuntimeException)
{
}

void SAL_CALL DirectoryTree::treeExpanded( const TreeExpansionEvent&  ) throw (RuntimeException)
{
}

void SAL_CALL DirectoryTree::treeCollapsed( const TreeExpansionEvent& /*rEvent*/ ) throw (RuntimeException)
{
/*
    if( rEvent.Node != mxTreeDataModel->getRoot() )
    {
        Reference< XMutableTreeNode > xNode( rEvent.Node, UNO_QUERY );
        if( xNode.is() )
        {
            while( xNode->getChildCount() )
                xNode->removeChildByIndex(0);
            xNode->setHasChildsOnDemand( sal_True );
        }
    }
*/
}

// XTreeEditListener
void SAL_CALL DirectoryTree::nodeEditing( const Reference< XTreeNode >&  ) throw (VetoException, RuntimeException)
{
}

void SAL_CALL DirectoryTree::nodeEdited( const Reference< XTreeNode >& , const OUString&  ) throw (RuntimeException)
{
}

// XEventListener
void SAL_CALL DirectoryTree::disposing( const ::com::sun::star::lang::EventObject&  ) throw (RuntimeException)
{
}

//============================================================================
int SAL_CALL main( int argc, char **argv )
{
    OUString sConnectionString(RTL_CONSTASCII_USTRINGPARAM("uno:socket,host=localhost,port=5678;urp;StarOffice.ServiceManager"));

    if (argc < 2)
    {
        printf("using: treetest <directory> [<uno_connection_url>]\n\n"
#ifdef WNT
                "example: treetest  \"c:\" \"uno:socket,host=localhost,port=5678;urp;StarOffice.ServiceManager\"\n");
#else
                "example: treetest  \"/etc\" \"uno:socket,host=localhost,port=5678;urp;StarOffice.ServiceManager\"\n");
#endif
        exit(1);
    }
    if (argc == 3)
    {
        sConnectionString = OUString::createFromAscii(argv[2]);
    }

    // Creates a simple registry service instance.
    Reference< XSimpleRegistry > xSimpleRegistry(::cppu::createSimpleRegistry() );

    // Connects the registry to a persistent data source represented by an URL.
    xSimpleRegistry->open(
        OUString( RTL_CONSTASCII_USTRINGPARAM("treetest.rdb") ), sal_True, sal_False );

    /* Bootstraps an initial component context with service manager upon a given
       registry. This includes insertion of initial services:
       - (registry) service manager, shared lib loader,
       - simple registry, nested registry,
       - implementation registration
       - registry typedescription provider, typedescription manager (also
         installs it into cppu core)
    */
    Reference< XComponentContext > xComponentContext(
        ::cppu::bootstrap_InitialComponentContext( xSimpleRegistry ) );

    /* Gets the service manager instance to be used (or null). This method has
       been added for convenience, because the service manager is a often used
       object.
    */
    Reference< XMultiComponentFactory > xMultiComponentFactoryClient(
        xComponentContext->getServiceManager() );

    /* Creates an instance of a component which supports the services specified
       by the factory.
    */
    Reference< XInterface > xInterface =
        xMultiComponentFactoryClient->createInstanceWithContext(
            OUString::createFromAscii( "com.sun.star.bridge.UnoUrlResolver" ),
            xComponentContext );

    Reference< XUnoUrlResolver > resolver( xInterface, UNO_QUERY );

    // Resolves the component context from the office, on the uno URL given by argv[1].
    try
    {
        xInterface = Reference< XInterface >(
            resolver->resolve( sConnectionString ), UNO_QUERY );
    }
    catch ( Exception& e )
    {
        printf("Error: cannot establish a connection using '%s':\n       %s\n",
               OUStringToOString(sConnectionString, RTL_TEXTENCODING_ASCII_US).getStr(),
               OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US).getStr());
        exit(1);
    }

    // gets the server component context as property of the office component factory
    Reference< XPropertySet > xPropSet( xInterface, UNO_QUERY );
    xPropSet->getPropertyValue( OUString::createFromAscii("DefaultContext") ) >>= xComponentContext;

    // gets the service manager from the office
    Reference< XMultiComponentFactory > xMultiComponentFactoryServer(
        xComponentContext->getServiceManager() );

    try
    {
        OUString ustrFileURL;
        osl::FileBase::getFileURLFromSystemPath( OUString::createFromAscii(argv[1]), ustrFileURL );

        rtl::Reference< DirectoryTree >(
            new DirectoryTree( xComponentContext ) )->display(ustrFileURL);
    }
    catch( Exception& e )
    {
        printf("Error: exception caught during test:\n       %s\n",
               OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US).getStr());
        exit(1);
    }

    // dispose the local service manager
    Reference< XComponent >::query( xMultiComponentFactoryClient )->dispose();

    return 0;
}