IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

wxWidgets Discussion :

Comment créer des dll avec wxWidgets sous Code Blocks.


Sujet :

wxWidgets

  1. #1
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut Comment créer des dll avec wxWidgets sous Code Blocks.
    Bonjour,

    Je fais appel à vous en dernier ressort, après avoir fouillé en vain dans tous les recoins possibles d'internet. (Merci Google ! )

    J'utilise, sous W10 (régulièrement mis à jour) wxWidgets 3.1.0 et la dernière version de Code Blocks, la 20.03.

    wxWidgets a été compilé avec GCC 4.9.2 (j'utilisais avant la version 16.1 de Code Blocks) que j'ai installé en doublon sur le nouveau Code Blocks.
    Pourquoi me diriez-vous ? Et bien pour éviter de recompiler wxWidgets avec le nouveau GCC 8.1.0 qui équipe la version 20.03 de C::B... (Flegme quand tu nous tiens... )

    wxWidgets a été compilé de la façon suivante :
    BUILD = Release, MONOLITHIC = 0, UNICODE = 1, SHARED = 1
    Tout fonctionne correctement, sauf que j'ai décidé d'apprendre à créer et utiliser des DLL.

    Et donc, je souhaiterai mettre dans une DLL certaines classes wxWidgets, tels que: wxFrame, wxPanel, wxBouton etc.

    Je cherche donc des explications et des exemples simples (pour commencer), fonctionnels et efficaces.

    Or le seul exemple de code fonctionnel, simple et efficace que j'ai pu trouver est celui du wxWiki qui utilise wxDynamicLibrary. (http://wiki.wxwidgets.org/WxDynamicLibrary)

    Je l'ai construit, il fonctionne correctement et j'ai, je pense, bien compris le fonctionnement de ce code.
    Mais pour le moment, il ne répond pas exactement à ce que je recherche.

    Les autres exemples que j'ai pu glaner ici et là sont, soit obsolètes, soit non fonctionnels ou trop compliqués, beaucoup de liens sont morts car trop vieux et je veux aussi rester sous et avec wxWidgets.

    Je souhaite commencer avec des exemples simples.
    Le but étant de comprendre pas de faire bêtement du "copier/coller".

    Espérant avoir été assez claire et explicite dans mes desiderata, j'attends avec impatience les réponses et aides que vous pourrez m'apporter.

    Avec mes remerciements.

    Bien à vous.

    Claude

  2. #2
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    J'ai pas bien compris...
    Tu essaies de mettre dans une DLL à toi des classes de wxWidgets ?
    C'est le build de wxWidgets qui le fait, et d'ailleurs, vu qu'il est compilé avec l'option SHARED, c'est déjà le cas.
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  3. #3
    Membre averti Avatar de wxXav
    Homme Profil pro
    Développeur amateur
    Inscrit en
    Décembre 2008
    Messages
    214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur amateur

    Informations forums :
    Inscription : Décembre 2008
    Messages : 214
    Points : 354
    Points
    354
    Par défaut
    Hello.

    Citation Envoyé par Claude URBAN Voir le message
    wxWidgets a été compilé avec GCC 4.9.2 (j'utilisais avant la version 16.1 de Code Blocks) que j'ai installé en doublon sur le nouveau Code Blocks.
    Pourquoi me diriez-vous ? Et bien pour éviter de recompiler wxWidgets avec le nouveau GCC 8.1.0 qui équipe la version 20.03 de C::B... (Flegme quand tu nous tiens... )
    Y'a qu'à demander : https://wxstuff.xaviou.fr

    Citation Envoyé par Claude URBAN Voir le message
    wxWidgets a été compilé de la façon suivante :
    BUILD = Release, MONOLITHIC = 0, UNICODE = 1, SHARED = 1
    Tout fonctionne correctement, sauf que j'ai décidé d'apprendre à créer et utiliser des DLL.

    Et donc, je souhaiterai mettre dans une DLL certaines classes wxWidgets, tels que: wxFrame, wxPanel, wxBouton etc.
    Comme l'a dit dragonjoker59 dans sa réponse : c'est déjà le cas puisque tu as une version dll de wxWidgets.

    Par contre, si tu souhaites placer dans ta dll tes propres classes dérivées des classes wxWidgets, c'est bien entendu tout à fait faisable.
    Et wxDynamicLibrary n'est pas nécessaire : cette classe ne sert (à mon avis mais je peux me tromper) qu'à charger des dlls dynamiquement sans qu'elles soient forcément liées à l'exécutable au moment de la compilation.

    Il faut donc partir sur un projet classique de lib dynamique sous Code::Blocks, ainsi qu'un projet contenant un exécutable de test (qui pourras dans un premier temps n'être qu'un petit projet "console").
    La première étape cruciale étant d'arriver à utiliser une fonction de la lib depuis l'exécutable (pour l'instant, je n'ai pas parlé fait allusion à wxWidgets).

    Ensuite, il faut arriver à créer (et bien entendu exporter) une classe basique (un truc bidon que tu pourras utiliser facilement depuis l'exécutable).

    Une fois que ces deux étapes sont passées avec succès, tu vas pouvoir y intégrer wxWidgets : il faudra ajouter au projet "dll" les réglages que tu dois déjà avoir pour une application wxWidgets classique, et ça devrait fonctionner.

    Je n'ai pas actuellement la possibilité de me pencher plus en avant sur le problème, mais je devrait pouvoir m'y atteler d'ici la semaine prochaine.
    Tiens nous au courant des tes éventuelles avancées, et j'essayerais de te pondre un petit truc fonctionnel dès que possible.

    Et si tu as besoin d'un coup de main pour installer une de mes versions de wxWidgets, ne te gênes pas....

    @+
    Xav'

  4. #4
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut

    @ dragonjoker56

    Tout d'abord, merci pour avoir pris le temps de me lire et pour ta réponse.
    Désolé, je pensais avoir été suffisamment clair dans mon descriptif.
    Je vais donc essayé d'être plus précis.

    J'ai déjà une version DLL de wxWidgets et je ne souhaite pas en créer une autre.
    Je souhaite, par contre, créer un programme exécutable qui appellerait mes propres DLL dans lesquelles j'incorporerai mes propres classes dérivées des classes wxWidgets.

    Plutôt que de tout mettre dans un *.exe, je voudrai mettre une partie des fichiers de mon programme dans des DLL.
    En fait, additionner des "modules" à mon exe.

    J'espère avoir été plus précis dans mes explication et que tu pourras ainsi m'apporter ton aide.

    Merci et @++
    Claude



    @Wav'

    Merci pour ta réponse et content de te retrouver. (J'ai déjà eu à faire à tes connaissances et ton aide principalement sur ton site wxDev.fr, il y a quelque temps déjà... et en son temps, tes informations pour compiler wxWidgets m'ont été d'une aide précieuse.)

    Comme tu l'as bien compris, effectivement mon problème est de pouvoir placer dans une DLL mes propres classes dérivées de wxWidgets.

    Et l'arrivé d'un "petit truc personnel et fonctionnel" serait le bien venu.

    Comme expliqué plus haut, j'ai déjà construit un petit programme exécutable qui appelle une DLL très basique qui délivre simplement un message.
    Je voudrais maintenant, à la place de ce message, mettre une wxFrame ou une wxQuelconque...

    Je prends bonne note de ton coup de main pour installer une de tes version wxWidgets et t'en remercie, mais pour le moment je préfère rester comme je suis, cela me va bien.
    On verra peut-être plus tard.

    J'attends avec impatience ton "petit truc perso" et pendant ce temps je continue à chercher.

    Merci et @++
    Claude

  5. #5
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    j'ai déjà construit un petit programme exécutable qui appelle une DLL très basique qui délivre simplement un message.
    Tu as donc déjà fait et compris l'essentiel.
    Pour créer une DLL qui contient des classes dérivées (de classes wxWidgets ou autre), il faut faire la même chose.

    Par contre, comment souhaites tu travailler avec ta DLL ?
    La charger dynamiquement, pour appeler les fonctions que tu auras exportées, via wxDynamicLibrary ?
    Ou alors travailler avec comme tu travaillerais avec une bibliothèque statique (à quelques différences près) ?
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  6. #6
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut
    comment souhaites tu travailler avec ta DLL ?
    Je souhaite utiliser mes DLL avec un chargement dynamique et de façon explicite.

    Merci et @++

  7. #7
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Du coup, il te manque quoi, pour faire ce que tu veux ?
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  8. #8
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut

    @dragonjoker59

    Merci de t'intéresser à mon problème.

    ... il te manque quoi, pour faire ce que tu veux ?
    Et pour répondre à ta question: "Bah ! l'essentiel, c.à.d TOUT... "

    Je ne vois même pas comment organiser mon programme.

    Ni quelles en seraient les grandes lignes ?

    L'idéal serait d'avoir un model que je pourrai adapter en fonctions de mes besoins.

    Et comme dit précédemment, rien trouvé sur internet.

    Merci et @++

    Claude

  9. #9
    Membre éclairé
    Homme Profil pro
    Inscrit en
    Février 2006
    Messages
    562
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Charente Maritime (Poitou Charente)

    Informations forums :
    Inscription : Février 2006
    Messages : 562
    Points : 859
    Points
    859
    Par défaut
    Bonjour.

    Je pense que vous cherchez à utiliser un modèle de plugin avec chargement des dll 'à la volée'. Avez-vous lu cet article https://wxwidgets.info/tag/plugins/. Certes, le code exemple est très complet mais facilement adaptable à vos besoin.

  10. #10
    Membre averti Avatar de wxXav
    Homme Profil pro
    Développeur amateur
    Inscrit en
    Décembre 2008
    Messages
    214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur amateur

    Informations forums :
    Inscription : Décembre 2008
    Messages : 214
    Points : 354
    Points
    354
    Par défaut
    Hello.

    Citation Envoyé par Claude URBAN Voir le message
    Je souhaite utiliser mes DLL avec un chargement dynamique et de façon explicite.
    Qu'entends-tu par "de façon explicite" ?

    Pour utiliser un chargement dynamique de tes Dlls, et ainsi de tes classes, il faut que tu te définisses quels sont les types de classes que tu souhaites créer et utiliser de cette façon.

    Parce qu'il faut garder à l'esprit que ton application n'est pas censée connaître le nom des classes à charger/créer.

    À l'inverse, si ton but est juste de placer ta classe de fenêtre principale, ainsi que toutes tes classes dérivées des clases wxWidgets pour simplement alléger l'exécutable, il est inutile (est surtout très fastidieux) de passer par un chargement dynamique (je ne dis pas que ce n'est pas faisable...).

    Il est également possible d'utiliser un mix des deux méthodes mais il faut dans un premier temps définir :
    • quelles sont les classes que tu veux/peux laisser dans l'exécutable
    • quelles sont celles que tu souhaites placer dans une dll directement liée à l'exécutable
    • quelles sont celles que seront placées dans des dlls "plugins" et qui seront chargées dynamiquement


    @+
    Xav'

  11. #11
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut
    Bonjour,

    Merci à vous tous pour votre participation.

    Vous trouverez ci-dessous copie du code qui pour le moment répond à mes attentes.

    Avant d'envisager un projet un peu plus large, je voulais dans un premier temps voir et comprendre comment je pouvais éventuellement créer et utiliser mes propres DLL sous wxWidgets et aussi en apprendre un peu plus sur ces DLL.

    Au delà du fait que pour le moment il semble correspondre effectivement à ce que je recherchais, peut-être pourriez-vous me laisser quelques commentaires sur ce code.


    Et pour commencer, la DLL.
    Le fichier main.h

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
    #ifndef  __MAIN_H__
    #define __MAIN_H__
     
    #include <wx/wx.h>
     
    #define DLL_EXPORT __declspec(dllexport)
     
    //------------------------------------------------------------------------------
    class cl_FrameDLL : public wxFrame
    {
        public:
            cl_FrameDLL( ) ;
            virtual  ~cl_FrameDLL( ) ;
     
        protected: //protected ->Les méthodes ( ou fonctions )
     
        private: //private -> les arguments ( ou variables )
            wxPanel   *pPanelDLL       = NULL ;
    } ;
     
    //------------------------------------------------------------------------------
    #endif       // __MAIN_H__
    Puis le main.cpp

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
     
    #include "main.h"
     
    //------------------------------------------------------------------------------
    // Constructeur  ( Sans CLOSE_BOX )
    cl_FrameDLL :: cl_FrameDLL( )
                            : wxFrame( NULL, wxID_ANY, ( "Fenêtre DLL"  ), wxDefaultPosition, wxSize(400, 200),
                              wxDEFAULT_FRAME_STYLE &~  wxCLOSE_BOX  )
    {
        //Création de l'objet pPanel global.
        pPanelDLL = new wxPanel( this, -1 ) ;
        pPanelDLL -> SetBackgroundColour( *wxLIGHT_GREY ) ;
     
        Show( true ) ;
     }
     
     
    //------------------------------------------------------------------------------
    // Destructeur.
    cl_FrameDLL :: ~ cl_FrameDLL( )
    {
     
    }
     
    //------------------------------------------------------------------------------
     
    // ICI la définition du pointeur car les fonctions ci-dessous, ne font pas parties de cl_Frame..
     cl_FrameDLL *pMyFrame = NULL ;
     
    //------------------------------------------------------------------------------
    // Cette fonction exportera la DLL.
    extern "C" DLL_EXPORT cl_FrameDLL *pCreateDLL( )
    {
        pMyFrame = new cl_FrameDLL( ) ;
     
        return pMyFrame ;
    }
     
    //------------------------------------------------------------------------------
    // Cette fonction supprimera la DLL.
    extern "C" DLL_EXPORT cl_FrameDLL *pDestroyDLL( )
    {
        pMyFrame -> Destroy( ) ;
     
        return pMyFrame ;
    }
    Puis le programme appelant.
    ChargerMYDLL.h


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
     
    #ifndef  __CHARGERMYDLL_H__
    #define __CHARGERMYDLL_H__
     
    #include  <wx/wx.h>
    #include <wx/wxprec.h>
    #include <wx/dynlib.h>          //Inclure la classe wxDynamicLibrary.
     
    #include "main.h"
     
    //------------------------------------------------------------------------------
    class myApp : public wxApp
    {
        public:
            virtual bool OnInit( ) ;
            virtual int OnExit( ) ;
    };
    //------------------------------------------------------------------------------
    class cl_Frame : public wxFrame
    {
        public:
            cl_Frame( ) ;
            virtual ~cl_Frame( ) ;
     
        protected: //protected ->Les méthodes ( ou fonctions )
             void ChargerDLL( wxString nom1 ) ;    //Charger la DLL.
             void FermerDLL(  ) ;                             //Fermer la DLL.
             void FermerParX( wxCloseEvent &event ) ;       // Interception de la croix ( X ).
     
        private: //private -> les arguments ( ou variables )
             typedef cl_FrameDLL *pNomDLL;
             pNomDLL  ( *pFonctionDLL)( ) = NULL ;
             wxDynamicLibrary *pDynLib     = NULL ;
     
            wxPanel   *pPanel               = NULL ;
            wxButton *pBtChargerDLL = NULL ;
            wxButton *pBtFermerDLL  = NULL ;
    };
    //------------------------------------------------------------------------------
    #endif //__CHARGERMYDLL_H__
    Et enfin.
    ChargerMYDLL.cpp

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
     
    #include "ChargerMYDLL.h"
     
    IMPLEMENT_APP( myApp )
     
    //------------------------------------------------------------------------------
    // Implémentation de la méthode OnExit.
    int  myApp :: OnExit( )
    {
        return  0 ;
    }
     
    //------------------------------------------------------------------------------
    // Implémentation de la méthode OnInit..
    bool myApp :: OnInit( )
    {
        //Création de la fenêtre principale.
        cl_Frame *pFrame = new cl_Frame( ) ;
     
        pFrame -> Centre( wxBOTH ) ;     //Affichage de la fenêtre au centre de l'écran
     
        pFrame -> Show( true ) ;               //On fait en sorte que la fenêtre soit visible.
     
        return true ;                                //true pour que le programme ne se termine pas immédiatement.
    }
     
    //------------------------------------------------------------------------------
    // Constructeur.
    cl_Frame :: cl_Frame( )
                     : wxFrame( NULL, wxID_ANY, ( "ChargementDLL" ), wxDefaultPosition, wxSize( 600, 300 ),
                       wxDEFAULT_FRAME_STYLE | wxCLIP_CHILDREN | wxFULL_REPAINT_ON_RESIZE )
    {
        //Création de l'objet pPanel global.
        pPanel = new wxPanel( this, -1 ) ;
        pPanel -> SetBackgroundColour( *wxGREEN ) ;
     
        //Affichage de pBtChargerDLL sur le panel.
        pBtChargerDLL  = new wxButton( pPanel, -1, "Charger la DLL.",  wxPoint( 20, 60 ), wxDefaultSize ) ;
     
        wxString nomDLL = "./MyDll/bin/Release/MyDll.dll" ;
     
        pBtChargerDLL  -> Bind( wxEVT_COMMAND_BUTTON_CLICKED, [ nomDLL, this ]  ( wxCommandEvent  &event ) { cl_Frame :: ChargerDLL( nomDLL ) ; } ) ;
     
        // Interception de la fermeture de la fenêtre par la crois ( X )
        this -> Bind( wxEVT_CLOSE_WINDOW,  & cl_Frame :: FermerParX, this ) ;
    }
     
    //------------------------------------------------------------------------------
    // Destructeur.
     cl_Frame :: ~cl_Frame( )
    {
        //Destruction de...
    }
     
    //------------------------------------------------------------------------------
    // Fermeture de la DLL si celle-ci existe avant la fermeture de la fenêtre.
    void cl_Frame :: FermerParX( wxCloseEvent &event )
    {
        if ( pFonctionDLL != NULL )     // C'est à dire que la DLL est chargée.
        {
            cl_Frame :: FermerDLL( ) ;
        }
            Destroy( ) ;
    }
     
    // Fermer la DLL.
    void cl_Frame :: FermerDLL(  )
    {
        if ( pDynLib -> IsLoaded( ) )
        {
              pFonctionDLL = ( pNomDLL(*)( ) )  pDynLib -> GetSymbol( "pDestroyDLL" ) ;
              if( pFonctionDLL == NULL )
              {
                wxMessageBox( "Fonction non chargée" ) ;
                exit( 0 ) ;
              }
     
              pFonctionDLL( ) ;                      // Affiche la fonction pDestroyDLL.
     
              pBtFermerDLL -> Destroy( ) ;  // Détruit le bouton, on en a plus besoin.
     
              pFonctionDLL = NULL ;            // FonctionDLL non chargée.
        }
    }
     
    //-------------------------------------------------------------------------
    // Chargement de la DLL.
    void cl_Frame::ChargerDLL( wxString nomDLL )
    {  
        pDynLib = new wxDynamicLibrary ( ) ;
        //Déclaration d'un pointeur pDynLib sur la classe wx.
     
        pDynLib -> Load( nomDLL ) ; 
     
        if (  ! pDynLib -> IsLoaded( ) )
        {
            wxMessageBox( "Erreur de chargement de la DLL" ) ;
            exit( 0 ) ;
        }
        else
        {
            if ( pFonctionDLL == NULL )
            {
                 pFonctionDLL =  ( pNomDLL(*)( ) ) pDynLib -> GetSymbol( "pCreateDLL" )  ;  
     
                if ( pFonctionDLL == NULL )
                {
                    wxMessageBox( "Fonction non chargée" ) ;
                    exit( 0 ) ;
                }
     
                pFonctionDLL( ) ;        // Affiche la fonction.
     
                // Création d'un bouton pour fermer correctement la DLL.
                pBtFermerDLL  = new wxButton( pPanel, -1, " Fermer la DLL .",  wxPoint( 20, 100 ), wxDefaultSize ) ;
                pBtFermerDLL -> Bind( wxEVT_COMMAND_BUTTON_CLICKED, [ this ]  ( wxCommandEvent  &event ) { cl_Frame :: FermerDLL(  ) ; } ) ;
          }
       }
    }
    Voilà.

    Merci pour votre attention et pour les commentaires que vous voudrez bien me laisser, afin de m'améliorer. (J'en ai bien besoin.)

    Pour information, je ne suis pas un professionnel de l'informatique, simplement un passionné.

    J'espère ne pas avoir fait de "boulettes" avec le copier/coller de ce code...

    Bien à vous.

    Claude.

  12. #12
    Membre averti
    Avatar de Claude URBAN
    Homme Profil pro
    Prendre le temps de vivre. . .
    Inscrit en
    Mai 2006
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Prendre le temps de vivre. . .

    Informations forums :
    Inscription : Mai 2006
    Messages : 274
    Points : 327
    Points
    327
    Par défaut
    Bonjour,

    J'ai découvert dans la bibliothèque wxWidgets la fonction :

    wxDYNLIB_FUNCTION( Type, Nom, dynlib ) qui est sensée simplifier l'utilisation de la fonction :

    pFonctionDLL = ( pNomDll(*)()) pDynLib -> GetSymbol( "pDestroyDLL" ) ( Que vous pouvez par exemple trouver

    dans le code mentionné ci-dessus à: ChargementMYDLL.cpp -> void cl_Frame::FermerDLL(){... ... }


    J'ai donc par curiosité, essayé et... ... FLOP ! ça plante.



    Voilà comment je l'ai écrite:

    wxDYNLIB_FUNCTION( pNomDLL, pDestroyDLL, *pDynLib );


    Et après, quelque soit le façon d'utiliser pfnDestroyDLL, ça ne fonctionne pas.

    Le plus souvent le compilateur m'indique : error: 'pfnpDestroyDLL' cannot be used as a function


    Je comprends la phase, mais je ne sais pas comment faire...

    Quelqu'un pourrait-il m'aider et m'expliquer pourquoi ?


    Avec mes remerciements anticipés.

    Bien à vous.

    Claude.

Discussions similaires

  1. Réponses: 3
    Dernier message: 12/05/2010, 10h54
  2. Comment créer un menu avec un sous menu à partir de VB6
    Par alouca dans le forum VB 6 et antérieur
    Réponses: 2
    Dernier message: 24/03/2010, 23h12
  3. comment créer des pages avec le c
    Par litle-hacker dans le forum C
    Réponses: 8
    Dernier message: 21/07/2008, 17h34
  4. [Lazarus] Comment créer une DLL avec Lazarus
    Par rajawi00 dans le forum Lazarus
    Réponses: 1
    Dernier message: 19/07/2007, 13h49
  5. comment créer un forum avec C# sous ASP.Net?
    Par Peezgeuzg dans le forum C#
    Réponses: 1
    Dernier message: 23/03/2007, 11h30

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo