Discussion :

[Grégory PLANCHAT]

Bonjour,

Je cherche à gérer dynamiquement mes menus sous Win32 grâce à un arbre binaire, mais je n'arrive pas à trouver quoi que ce soit qui me permettrait d'éviter de tout recoder (je veux aussi rester indépendant des HMENU jusqu'au bout).

Après une petite recherche, je n'ai pas pu trouver quoi que ce soit qui s'en rapproche, ni dans la STL, ni chez Boost et les codes que j'ai pu trouver sont soit trop complexes pour ce que je veux en faire, soit trop mal codées ou documentés pour pouvoir en faire quoi que ce soit. J'ai bien trouvé des sources pour gérer des arborescences de fichiers que je pourrais adapter, mais tout le monde cherche à utiliser du n-aire, alors que j'en veux pas

Es-ce que quelqu'un aurait une idée?

[Médinoc]

Euh...
Comment veux-tu générer dynamiquement un menu sous Win32 sans HMENU ?

Tu veux générer des menus qui ne sont pas des menus Win32 ?

[Grégory PLANCHAT]

non, je les génère au dernier moment avec l'opérateur de cast vers HMENU

[Médinoc]

Un cast en HMENU ?
Dès qu'il est question de cast en un type quelquonque de handle, ça veut dire un truc crade, non-documenté, du genre qui donne des sueurs froides à des types comme Raymond Chen par la faute du programmeur.

Soit tu utilises les vraies fonctions de Windows pour générer un menu, soit tu fais des menus non-Windows. Mais pas de cast.

[Grégory PLANCHAT]

non, je crée une couche d'abstraction sous la forme d'un wrapper C++, les opérateurs de cast ne sont appelés que par l'interface elle-même, en utilisant une class de ce type :

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
template<class _Traits>
class wrapper
{
public:
    typedef unsigned long size_type;
 
    wrapper(){}
    wrapper(_Traits pal) : _handle(pal) {}
    wrapper(wrapper &pal) : _handle(pal._handle) {}
 
    wrapper &operator= (wrapper &pal) {_handle = pal._handle; return *this;}
    wrapper &operator= (_Traits pal) {_handle = pal; return *this;}
    operator _Traits() {return _handle;}
    _Traits * operator &() {return &_handle;}
    _Traits * operator-> () {return &_handle;}
    _Traits  &operator* () {return _handle;}
    bool operator! () {return !_handle;}
    bool operator!= (wrapper &pal) {return _handle != pal._handle;}
    bool operator== (wrapper &pal) {return _handle == pal._handle;}
 
    static const size_type size() {return sizeof(_Traits);}
 
protected:
    _Traits _handle;
};

l'opérateur de cast fait office d'accesseur/compilateur, rien de plus. par exemple avec une implémentation pour win32, j'ai quelquechose du genre :

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
 
#ifdef _WIN32
typedef wrapper<HMENU> menu_handler;
#else
...
#endif
 
class menu : public menu_handler
{
...
};
 
window &window::set_menu(menu &m)
{
    if(!SetMenu(_handle, m))
        throw "Doh!";
 
    return *this;
}

mais ca m'arrangerait une petite réponse à la question initiale

[Médinoc]

Premièrement, je pense que ton template manque pas mal de const.

Ensuite, si je comprends bien, tu cherches une bibliothèque ou des exemples de code sur les arbres binaires ?
Et des fonctions qui prcourent ce genre d'arbre pour faire les AppendMenu() et CreateMenu() qui vont bien...

Pourquoi spécialement binaires, les arbres ? J'ai du mal à comprendre ta conception...