FR/Documentation/Composants et boite de dialogue

Nous allons réaliser une boîte de dialogue pour faire fonctionner notre compteur, ce sera le fil conducteur de ce chapitre. L'idée est d'utiliser l'environnement OOoBasic, car il est aisé d'y créer des boîtes de dialogue. Comme on va le voir tout au long de ce chapitre, il existe plusieurs méthodes pour faciliter l'utilisation d'un composant à l'aide des boîtes de dialogue. La première solution que l'on se propose d'examiner consiste à ne rien changer du code C++ du composant mais à enrober ce code par du OOoBasic et à utiliser ainsi les facilités de la gestion des sous-programmes OOoBasic par des boutons d'une boîte de dialogue.

Ajouter une boîte de dialogue au compteur avec le Basic

Rappelons pour information que notre compteur dispose de quatre méthodes :

1. increment
2. decrement
3. setCount
4. getCount

On va donc chercher à réaliser une boîte de dialogue qui va proposer un bouton par méthode. Elle proposera d'autre part deux champs texte :

1. un champ texte pour positionner une valeur dans le compteur (donc associé au bouton setCount)
2. un champ texte pour afficher la valeur du compteur (donc associé au bouton getCount)

Pour se faire une idée de quoi il s'agit, voici une image de la boîte de dialogue

Notre boîte de dialogue

Pour faire fonctionner l'ensemble on peut tout simplement utiliser le code OOoBasic suivant :

'Listing 1
REM  *****  BASIC  *****
	Dim oSimpleComponent
	Dim oDialog
Sub demonstrateSimpleComponent
	oSimpleComponent = CreateUnoService( "foo.Counter" )
	'oInspector = createUnoService("org.openoffice.InstanceInspector")
	'oInspector.inspect(oSimpleComponent, "MyCounter")
	'XRay oSimpleComponent
	oDialog=CreateUnoDialog(DialogLibraries.Standard.Dialog1)
	oDialog.Execute()
	oDialog.dispose()
End Sub

Sub increment
  oSimpleComponent.increment()
End Sub

Sub decrement
   oSimpleComponent.decrement()
End Sub

Sub getCount
   Dim oTextField
   oTextField = oDialog.getControl("TextField2")
   oTextField.setText( oSimpleComponent.getCount())  
End Sub

Sub setCount
	Dim oTextField
	oTextField = oDialog.getControl("TextField1")
	'implicit conversion String to Integer
	oSimpleComponent.setCount(oTextField.getText())
End Sub

en prenant soin d'associer aux boutons les sous-programmes OOoBasic correspondants. Dans ce programme on a laissé en commentaire les différentes façons de réaliser l'introspection sur notre compteur, mais ceci n'a pas grand intérêt pour ce qui nous préoccupe. Template:Documentation/Note

Appel direct des méthodes du compteur à l'aide du service d'Introspection

Comme indiqué dans le Developer's Guide, depuis la version 2.0.4 il est possible d'associer directement des méthodes d'un composant à des événements de boutons (ou autres contrôles). Une autre façon de dire les choses, c'est que l'enrobage que l'on a utilisé dans la section précédente du genre :

'Listing 2
REM  *****  BASIC  *****
Sub increment
  oSimpleComponent.increment()
End Sub

n'est plus nécessaire. Mais ceci a un coût : on ne pourra pas toujours garder le composant sans en modifier le code C++. Pour commencer par le plus simple, nous allons modifier notre programme OOoBasic, notre boîte de dialogue mais pas notre compteur.

Appel direct d'une méthode du compteur sans changer son code

On reprend en le modifiant le programme OOoBasic (Listing 1) précédent pour qu'il utilise le service com.sun.star.awt.DialogProvider2 qui nous fournit la méthode "createDialogWithHandler" convoitée. Voici le programme correspondant :

'Listing 3
REM  *****  BASIC  *****
	Dim oSimpleComponent
	Dim oDialog
Sub demonstrateSimpleComponent
	oSimpleComponent = CreateUnoService( "foo.Counter" )
	oCreateDialog2=CreateUnoService("com.sun.star.awt.DialogProvider2")
	'Merci ms777 pour la ligne suivante (voir http://www.oooforum.org/forum/viewtopic.phtml?t=84168)
	oCreateDialog2.initialize(Array(ThisComponent))
	oDialog=oCreateDialog2.createDialogWithHandler("vnd.sun.star.script:Standard.Dialog1?location=document", _
		oSimpleComponent )
	oDialog.Execute()
	oDialog.dispose()
End Sub

'Sub increment
'  oSimpleComponent.increment()
'End Sub

Sub decrement
   oSimpleComponent.decrement()
End Sub

Sub getCount
   Dim oTextField
   oTextField = oDialog.getControl("TextField2")
   oTextField.setText( oSimpleComponent.getCount())  
End Sub

Sub setCount
	Dim oTextField
	oTextField = oDialog.getControl("TextField1")
	'implicit conversion String to Integer
	oSimpleComponent.setCount(oTextField.getText())
End Sub

Comme vous pouvez le voir, j'ai mis en commentaire le sous-programme OOoBasic "increment", il ne peut donc plus fonctionner. En fait j'ai modifié aussi la boîte de dialogue pour que le bouton "increment" n'appelle plus un sous-programme de macro, mais directement une méthode du composant counter. Cette page en anglais du Developer's Guide explique comment on procède pour cela. La partie initialisation s'en trouve légèrement changée. Template:Documentation/Note Il nous est possible de poursuivre comme cela avec la méthode decrement du compteur, mais impossible de continuer avec les deux autres méthodes "setCount" et "getCount". Pour comprendre pourquoi, il faut se poser la question de savoir comment tout cela fonctionne. En fait dans ce cas précis c'est le service d'introspection com.sun.star.beans.Introspection qui va être utilisé automatiquement pour retrouver la méthode. Mais cette introspection automatique n'est capable de retrouver que les méthodes ayant pour signature :

void [nomMethod](void);

ou encore

  void [nomMethod] 
  ( 
      [in] com::sun::star::awt::XDialog xDialog, 
      [in] any aEvent 
  );

et cela tombe bien parce que nos deux premières méthodes "increment" et "decrement" ont cette signature là, mais ce n'est pas le cas des deux suivantes "setCount" et "getCount". Si l'on veut les faire fonctionner avec le même principe que celui déjà invoqué, il nous faudra retirer les paramètres correspondants. C'est ce que l'on a fait en OOoBasic lorsqu'on a enrobé les méthodes C++ : regardez le "Sub getCount" en OOoBasic n'a plus de paramètre dans le listing 3 !

Je me suis aperçu après coup que la signature de "increment" est en fait "long increment();" mais cela ne semble pas avoir perturbé le fonctionnement. A vérifier tout cela.

Appel direct de toutes les méthodes du compteur

Dans cette section nous allons chercher à modifier le compteur pour qu'il fonctionne complètement par appel direct de toutes ses méthodes. Comme indiqué en fin de section précédente, cela veut dire que nos deux méthodes "setCount" et "getCount" n'auront plus de paramètres. Elles devront être capables de lire/écrire dans les contrôles de champs de textes de la boîte de dialogue. Ceci va avoir de profondes répercutions sur le code du compteur car il va nous falloir obtenir un Service Manager (com.sun.star.lang.XMultiComponentFactory) pour être capable de lancer la boîte de dialogue à partir du code C++ et surtout d'obtenir l'interface com.sun.star.awt.XControlContainer pour accéder aux contrôles qui nous intéressent. Le Developer's Guide considère que l'obtention d'un Service Manager se fait par l'intermédiaire du contexte. Nous allons donc d'abord résoudre ce problème.

Obtention du contexte

L'obtention du contexte peut se faire à l'aide de quatre modifications de notre fichier source counter.cxx.

Ajout d'un champ

Pour récupérer le contexte on ajoute le champ

Reference< XComponentContext > m_xContext;

dans la classe du compteur. On rappelle qu'un contexte est une paire chaîne de caractères/valeur.

Remplacement du sous-programme d'initialisation

L'ancien sous-programme d'initialisation (qui appelle le constructeur de notre compteur) doit être remplacé. Il s'agissait de

// ancien sous programme a supprimer
Reference< XInterface > SAL_CALL MyCounterImpl_create(
    Reference< XComponentContext > const & xContext )
    SAL_THROW( () )
{
    return static_cast< XTypeProvider * >( new MyCounterImpl() );
}

que l'on change maintenant par

// nouveau sous-programme de remplacement
Reference< XInterface > SAL_CALL MyCounterImpl_createInstance(
    Reference< XComponentContext > const & xContext )
    SAL_THROW( () )
{
    return static_cast< ::cppu::OWeakObject * >( new MyCounterImpl( xContext ) );
}

Le nom de ce sous-programme n'a aucune importance, car il va être mis dans une structure très particulière (ou un tableau de ces structures). C'est ce que l'on se propose d'examiner maintenant.

Changement du tableau des entrées

On doit procéder au changement dans le tableau des entrées indiqué dans le commentaire ci-dessous

static struct ::cppu::ImplementationEntry s_component_entries [] =
{
    { // MyCounterImpl_create replaced by MyCounterImpl_createInstance 19/05/09
        MyCounterImpl_createInstance, getImplementationName_MyCounterImpl,
        getSupportedServiceNames_MyCounterImpl, ::cppu::createSingleComponentFactory,
        0, 0
    },
    { 0, 0, 0, 0, 0, 0 }
};

Changement du constructeur de la classe

Le constructeur de la classe doit être modifié car il possède un paramètre com.sun.star.uno.XComponentContext maintenant.

inline MyCounterImpl( Reference< XComponentContext > const & xContext)
        : m_xContext( xContext ) {
	//m_xMCF=m_xContext->getServiceManager();
	}

Ces quatres opérations fonctionnent, on peut mémoriser le contexte dans notre classe mais on n'a toujours pas le service manager !

J'ai essayé de réaliser un constructeur de classe du type // doesn't work Reference< XInterface > SAL_CALL MyCounterImpl_createInstance( const Reference< XMultiServiceFactory > & rSMgr) throw( Exception ) { return (cppu::OWeakObject*) new MyCounterImpl( rSMgr ); } qui obtient directement un service Manager (comme dans les AddOn) mais sans succès. A explorer plus tard.

Obtention du Service Manager

Il existe en fait plusieurs Service Manager mais celui qu'il nous est possible de récupérer à partir du contexte d'un composant est une interface com.sun.star.lang.XMultiComponentFactory. L'interface XMultiComponentFactory peut être mémorisée en ajoutant un champ :

Reference< XMultiComponentFactory > m_xMCF;

à notre classe compteur. Il nous faut alors changer notre constructeur de la classe pour qu'il mémorise vraiment le Service Manager :

inline MyCounterImpl( Reference< XComponentContext > const & xContext)
        : m_xContext( xContext ) {
	m_xMCF=m_xContext->getServiceManager();
	}

Vous devez ajouter dans le code source une directive d'inclusion

#ifndef _COM_SUN_STAR_LANG_XMULTICOMPONENTFACTORY_HPP_
#include <com/sun/star/lang/XMultiComponentFactory.hpp>
#endif

mais rien dans le Makefile car si vous prenez soin de regarder le fichier CppComponent.uno.xml vous verrez bien apparaître l'interface com.sun.star.lang.XMultiComponentFactory et donc le fichier com/sun/star/lang/XMultiComponentFactory.hpp a été généré pour vous.

Prêt pour le grand saut

Nous sommes prêt à réaliser notre compteur autonome avec sa boîte de dialogue. Pour éviter un agacement du lecteur, nous allons cesser de détailler les modifications une par une et donner dans cette section les codes complets associés.

Fichier Counter.idl

J'ai beaucoup hésité sur la façon de procéder. Il y a un exemple dans le Developer's Guide détaillé en Java et j'ai pensé le traduire en C++ mais je n'ai pas réussi à traduire la ligne

// gros gros problemes avec le this !!!
XDialog xDialog = xDialogProvider.createDialogWithHandler( DialogURL, this );

Ce qui caractérise l'exemple c'est que c'est un composant qui affiche tout seul son menu. Moi je sais seulement l'afficher en OOoBasic. Je vais garder cet affichage en OOoBasic mais puisque mes sous programmes C++ devront lire les contrôles de texte, il faut que je passe une interface com.sun.star.awt.XDialog à mon composant. Notre nouveau fichier IDL va prendre en compte cette contrainte et respecte vraiment la signature des méthodes maintenant. Il devient donc :

#include <com/sun/star/uno/XInterface.idl>
#include <com/sun/star/awt/XDialog.idl>

module foo
{
       interface XCountable : com::sun::star::uno::XInterface
	{
		void setDialog( [in] ::com::sun::star::awt::XDialog xDialog);
		void getCount();
		void setCount();
		void increment();
		void decrement();
	};	
	service Counter : XCountable ;
};

où nous avons ajouté une méthode "setDialog". L'objectif de cette méthode est de passer notre interface XDialog au composant et par la même occasion de voir un peu comment on gère les types de paramètres un peu évolués. Examinons maintenant le code correspondant du compteur.

Fichier counter.cxx

Je suis resté plusieurs jours bloqué par un message d'erreur pas très clair qui clamait son impossibilité d'invoquer le constructeur de ma classe compteur. Le problème venait tout simplement de la signature de mon sous programme "setDialog" en C++. Donc regardez cela de très près si vous ne voulez pas être confronté à des problèmes : les "const" et "&" sont obligatoires dans le(s) paramètre(s).

Le code source est un peu long et fait appel aux interfaces com.sun.star.awt.XDialog, com.sun.star.awt.XTextComponent, com.sun.star.awt.XControl, com.sun.star.awt.XControlContainer, com.sun.star.lang.XMultiComponentFactory, com.sun.star.lang.XServiceInfo et com.sun.star.registry.XRegistryKey.

/***************************************************************************************************
 ***************************************************************************************************
 *
 * service implementation:	 foo.Counter
 * exported interfaces:		 foo.XCounter
 *
 * simple example component implementing a counter
 *
 ***************************************************************************************************
 **************************************************************************************************/

#include <rtl/ustring.hxx>
#include <rtl/string.hxx>
#include <cppuhelper/queryinterface.hxx> // helper for queryInterface() impl
#include <cppuhelper/factory.hxx> // helper for component factory
// New
#include <cppuhelper/implbase2.hxx> // "2" implementing three interfaces
#include <cppuhelper/implementationentry.hxx>
#include <com/sun/star/awt/XDialog.hpp>
#include <com/sun/star/awt/XTextComponent.hpp>
#include <com/sun/star/awt/XControl.hpp>
#include <com/sun/star/awt/XControlContainer.hpp>
// generated c++ interfaces
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/lang/XMultiComponentFactory.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/registry/XRegistryKey.hpp>
#include <foo/XCountable.hpp>


#define SERVICENAME "foo.Counter"
#define IMPLNAME "com.sun.star.comp.example.cpp.Counter"

using namespace ::rtl;
using namespace ::osl;
using namespace ::cppu;
using namespace ::com::sun::star::awt;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::registry;
//using namespace ::com::sun::star::frame;
using namespace ::foo;
//==================================================================================================
namespace my_sc_impl
{
static Sequence< OUString > getSupportedServiceNames_MyCounterImpl()
{
	static Sequence < OUString > *pNames = 0;
	if( ! pNames )
	{
//		MutexGuard guard( Mutex::getGlobalMutex() );
		if( !pNames )
		{
			static Sequence< OUString > seqNames(1);
			seqNames.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICENAME));
			pNames = &seqNames;
		}
	}
	return *pNames;
}

static OUString getImplementationName_MyCounterImpl()
{
	static OUString *pImplName = 0;
	if( ! pImplName )
	{
//		MutexGuard guard( Mutex::getGlobalMutex() );
		if( ! pImplName )
		{
			static OUString implName( RTL_CONSTASCII_USTRINGPARAM(IMPLNAME) );
			pImplName = &implName;
		}
	}
	return *pImplName;
}

// New
class MyCounterImpl : public ::cppu::WeakImplHelper2<
      XCountable, XServiceInfo >
{
	// to obtain other services if needed
	Reference< XMultiComponentFactory > m_xMCF;
	Reference< XComponentContext > m_xContext;
	Reference< XDialog > m_xDialog;
	sal_Int32 m_nCount;
	
public:
// added this constructor 19/05/09
    inline MyCounterImpl( Reference< XComponentContext > const & xContext) throw ()
        : m_xContext( xContext ) {
	m_xMCF=m_xContext->getServiceManager();
	}
    virtual ~MyCounterImpl() {}
    
    // XServiceInfo specification
    virtual OUString SAL_CALL getImplementationName(  ) throw(RuntimeException);
    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw(RuntimeException);
    static Sequence< OUString > SAL_CALL getSupportedServiceNames_Static(  );

    // XCountable specification
    virtual void SAL_CALL getCount() throw (RuntimeException);
    virtual void SAL_CALL setCount() throw (RuntimeException);
    virtual void SAL_CALL increment() throw (RuntimeException);
    virtual void SAL_CALL decrement() throw (RuntimeException);
//    virtual OUString createDialog( const OUString & DialogURL/*, Reference< XModel > const & xModel, 
//					Reference< XFrame > const & xFrame*/ )throw (RuntimeException);
    virtual void setDialog( Reference< XDialog > const & xDialog )throw (RuntimeException);
};
// XCountable implementation
//*************************************************************************
void SAL_CALL MyCounterImpl::setDialog(Reference< XDialog > const & xDialog) throw (RuntimeException)
{
	m_xDialog=xDialog;
}
void SAL_CALL MyCounterImpl::getCount() throw (RuntimeException){
	Reference< XControlContainer > xControlContainer(m_xDialog,UNO_QUERY);
	Reference< XControl > xTextControl=xControlContainer->getControl(OUString::createFromAscii("TextField2"));
	Reference< XTextComponent > xTextComponent(xTextControl,UNO_QUERY);
	xTextComponent->setText(OUString::valueOf((sal_Int32)m_nCount));  
}
void SAL_CALL MyCounterImpl::setCount() throw (RuntimeException){
	Reference< XControlContainer > xControlContainer(m_xDialog,UNO_QUERY);
	Reference< XControl > xTextControl=xControlContainer->getControl(OUString::createFromAscii("TextField1"));
	Reference< XTextComponent > xTextComponent(xTextControl,UNO_QUERY);
	m_nCount=(xTextComponent->getText()).toInt32();  
}

void SAL_CALL MyCounterImpl::increment() throw (RuntimeException)
		{ ++m_nCount; }
void SAL_CALL MyCounterImpl::decrement() throw (RuntimeException)
		{ --m_nCount; }
// XServiceInfo	implementation
//*************************************************************************
OUString SAL_CALL MyCounterImpl::getImplementationName(  )
	throw(RuntimeException)
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM(IMPLNAME) );
}

//*************************************************************************
sal_Bool SAL_CALL MyCounterImpl::supportsService( const OUString& ServiceName )
	throw(RuntimeException)
{
	return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(SERVICENAME) );
}	

//*************************************************************************
Sequence<OUString> SAL_CALL MyCounterImpl::getSupportedServiceNames(  )
	throw(RuntimeException)
{
	return getSupportedServiceNames_Static();
}

//*************************************************************************
Sequence<OUString> SAL_CALL MyCounterImpl::getSupportedServiceNames_Static(  )
{
	Sequence<OUString> names(1);
    names[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICENAME));
    return names;
}

//*****New vesion with context management
Reference< XInterface > SAL_CALL MyCounterImpl_createInstance(
    Reference< XComponentContext > const & xContext )
    SAL_THROW( () )
{
    return static_cast< ::cppu::OWeakObject * >( new MyCounterImpl( xContext ) );
//	return static_cast< XTypeProvider * >( new MyCounterImpl( xContext) );
//	return static_cast< XTypeProvider * >( new MyCounterImpl() );
}
}

//##################################################################################################
//#### EXPORTED ####################################################################################
//##################################################################################################

/* New ****/
/* shared lib exports implemented without helpers in service_impl1.cxx */

namespace my_sc_impl
{
static struct ::cppu::ImplementationEntry s_component_entries [] =
{
    { // MyCounterImpl_create replaced by MyCounterImpl_createInstance 19/05/09
        MyCounterImpl_createInstance, getImplementationName_MyCounterImpl,
        getSupportedServiceNames_MyCounterImpl, ::cppu::createSingleComponentFactory,
        0, 0
    },
    { 0, 0, 0, 0, 0, 0 }
};
}

extern "C"
{
void SAL_CALL component_getImplementationEnvironment(
    sal_Char const ** ppEnvTypeName, uno_Environment ** ppEnv )
{
    *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}
sal_Bool SAL_CALL component_writeInfo(
    XMultiServiceFactory * xMgr, XRegistryKey * xRegistry )
{
    return ::cppu::component_writeInfoHelper(
        xMgr, xRegistry, ::my_sc_impl::s_component_entries );
}
void * SAL_CALL component_getFactory(
    sal_Char const * implName, XMultiServiceFactory * xMgr,
    XRegistryKey * xRegistry )
{
    return ::cppu::component_getFactoryHelper(
        implName, xMgr, xRegistry, ::my_sc_impl::s_component_entries );
}
}

La partie OOoBasic

Le programme OOoBasic doit changer. On retire toutes les anciens sous-programmes et surtout on apelle le setDialog au bon moment. Voici donc le nouveau programme :

REM  *****  BASIC  *****

Sub demonstrateSimpleComponent
    Dim oSimpleComponent
	Dim oDialog
	oSimpleComponent = CreateUnoService( "foo.Counter" )
	oCreateDialog2=CreateUnoService("com.sun.star.awt.DialogProvider2")
	'Thank you ms777 for the line below (http://www.oooforum.org/forum/viewtopic.phtml?t=84168)
	oCreateDialog2.initialize(Array(ThisComponent))
	oDialog=oCreateDialog2.createDialogWithHandler("vnd.sun.star.script:Standard.Dialog1?location=document", _
		oSimpleComponent )
	oSimpleComponent.setDialog(oDialog)	
	oDialog.Execute()
	oDialog.dispose()
End Sub

'Sub increment
'  oSimpleComponent.increment()
'End Sub

'Sub decrement
'   oSimpleComponent.decrement()
'End Sub

'Sub getCount
'   Dim oTextField
'   oTextField = oDialog.getControl("TextField2")
'   oTextField.setText( oSimpleComponent.getCount())  
'End Sub

'Sub setCount
'	Dim oTextField
'	oTextField = oDialog.getControl("TextField1")
	'implicit conversion String to Integer
'	oSimpleComponent.setCount(oTextField.getText())
'End Sub

où vous voyez le "setDialog" juste avant l'exécution de la boîte de dialogue. Tous les anciens sous-programmes sont en commentaires maintenant. N'oubliez pas non plus de modifier votre boîte de dialogue pour qu'elle n'appelle plus des sous-programmes OOoBasic mais des méthodes.

Il existe une autre méthode pour appeler les méthodes d'un composant. Il s'agit d'implanter une interface com.sun.star.awt.XDialogEventHandler dans notre composant. Je ne sais pas si cette méthode est plus efficace que l'utilisation de l'introspection, je veux dire efficace en temps que rapidité d'exécution. En ce qui concerne le code, on va en rajouter pour gérer l'interface XDialogEventHandler mais par contre on peut garder notre fichier IDL initial de notre compteur (Listing 6 du chapitre précédent).

Utilisation de l'interface XDialogEventHandler

L'intérêt de cette façon de procéder est que tout est prévu : en particulier on n'aura pas besoin de la méthode supplémentaire "setDialog" que l'on a ajouté dans la section précédente pour mémoriser l'interface XDialog. En effet, maintenant cette interface fait partie des paramètres et donc nos méthodes pourront s'en servir pour retrouver le contrôles de texte dans la boîte de dialogue. Bon c'est un peu compliqué, il est temps de passer aux exemples concrets de code.

L'utilisation de cette interface nécessite d'implanter deux méthodes. C'est ce que nous allons détailler maintenant.

L'interface XDialogEventHandler détaillée

Comme d'habitude dans ce document, nous allons nous pencher sur le fichier IDL de l'interface XDialogEventHandler pour savoir ce que l'on a à réaliser. Nous y voyons deux méthodes :

module com { module sun { module star { module awt {

//============================================================================= 

/** Handles events fired by dialogs represented by a
    <type scope="com::sun::star::awt">XDialog</type> interface.
 */
interface XDialogEventHandler : ::com::sun::star::uno::XInterface {

    //------------------------------------------------------------------------- 

    /** Handles an event generated by a dialog.

        The implementation must be aware that the EventObject argument contains types
        which it is not prepared to handle. Similarly this applies for the MethodName
        argument. In this case the method should simply return false.

        @param xDialog
            the dialog instance that generated the event. This is the same dialog instance
			that was returned by the <type scope="com::sun::star::awt">XDialogProvider2</type>
			createDialogWithHandler method when passing the XDialogEventHandler instance
			receiving the event as handler parameter.

        @param EventObject
            an object describing the event which occurred in the dialog or anything else that
            provides additional information for the event.
            If the event was caused by the dialog or any of the controls which it contains
            then the any should contain an object derived from
            <type scope="com::sun::star::lang">EventObject</type>. Typically this would be one
            of the several com::sun::star::awt::*Event types.

        @param MethodName
            the name of the function which is to be called.
            
        @returns
            true if the event was handled, otherwise false.

        @throws com::sun::star::lang::WrappedTargetException  
			if the implementation of the method, which is determined by the argument MethodName,
			throws an exception. This exception is then wrapped into a
			<type scope="com::sun::star::lang">WrappedTargetException</type>.

     */
	boolean callHandlerMethod(
		[in] com::sun::star::awt::XDialog xDialog,
		[in] any EventObject,
		[in] string MethodName)
        raises(com::sun::star::lang::WrappedTargetException); 


    /** returns a sequence of supported method names

        @returns
            all method names that will be accepted in calls to callHandlerMethod.
     */
	sequence<string> getSupportedMethodNames();
};

//============================================================================= 

}; }; }; };

"callHandlerMethod" et "getSupportedMethodNames()" qu'il nous faudra donc implanter.

Retour à la page d'accueil

Page d'accueil du développement C++ à l'aide du SDK

Voir aussi

• Version anglaise de ce chapitre
• Construire des composants
• Le paragraphe consacré au sujet dans le Developer's Guide
• La description du langage OOoBasic
• La gestion des boîtes de dialogue en OOoBasic.
• Objects contextuels en OOoBasic