Dimensionnement d'un boxSizer dans une frame

Version imprimable

3 pièce(s) jointe(s)

Bonjour,
J'ai besoin d'un petit coup de main sur ce coup là, je fais donc appel à vos compétences.
Y aurait-il quelqu'un dans l'assistance qui pourrait m'expliquer pourquoi ma barre d'outils et mon Panel vert ne remplissent pas la totalité de ma fenêtre grise ?
Enfin, jetez un oeil sur le code, je pense que vous comprendrez mieux qu'une tonne d'explications confuses.
Merci de votre réponse :ccool:

Module 01

Code:

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
 
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
 
# Tempo_01.py
 
import wx
import Tempo_02
 
 
class SimpleFrame(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title)
 
        frameSizer = wx.BoxSizer(wx.VERTICAL)
        panelSizer = wx.BoxSizer(wx.VERTICAL)
 
        conteneur = wx.Panel(self, -1)
        conteneur.SetBackgroundColour('#80f14e')
 
 
#*********************************************************
        # panel_A : Barre d'outils
        panel_A = Tempo_02.Barre_Outils_01(conteneur)
 
#*********************************************************
        # panel_B : Interface Graphique
        panel_B = Tempo_02.Interface_Graphique_01(conteneur)
 
 
        panelSizer.Add(panel_A, 2, wx.EXPAND)
        panelSizer.Add(panel_B, 2, wx.EXPAND)
 
 
        conteneur.SetSizer(panelSizer)
        frameSizer.Add(conteneur, 1, wx.EXPAND)
        self.SetSizer(frameSizer)
        frameSizer.SetSizeHints(self)
 
        self.SetSize((500,500))
 
        self.Centre()
        self.Show(True)
 
 
 
app = wx.App()
SimpleFrame(None, -1, 'Ma Belle Fenêtre')
app.MainLoop()

Module 02

Code:

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
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
# Tempo_02.py
 
import wx
 
#-------------------------------------------------------------------------
class Barre_Outils_01(wx.Panel):
    """Barre d'outils de la fenêtre principale"""
#-------------------------------------------------------------------------
    def __init__(self, parent):
        wx.Panel.__init__(self, parent)
 
        TBFLAGS = ( wx.TB_HORIZONTAL
                  | wx.NO_BORDER
                  | wx.TB_FLAT
                  )
 
        tb = wx.ToolBar(self, style=TBFLAGS)  # self
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(tb, 0, wx.EXPAND)
        self.SetSizer(sizer)
 
        tsize = (24,24)
 
       # Définition des différents icones de la barre d'outils
        Png_01 =  wx.Bitmap("exit.png")
        Png_02 =  wx.Bitmap("book.png")
        Png_03 =  wx.Bitmap("linux.png")
 
        tb.SetToolBitmapSize(tsize)
 
        # Dessine la Barre d'outils
        tb.AddLabelTool(10, "", Png_01)
        tb.AddSeparator()
 
        tb.AddLabelTool(20, "", Png_02)
        tb.AddSeparator()
 
        tb.AddLabelTool(30, "", Png_03)
        tb.AddSeparator()
 
        tb.Realize()
 
#-------------------------------------------------------------------------
class Interface_Graphique_01(wx.Panel):
    """Interface_Graphique de la fenêtre principale"""
#-------------------------------------------------------------------------
    def __init__(self, parent):
        wx.Panel.__init__(self, parent, -1)
 
        panel = wx.Panel(self, -1)
        panel.SetBackgroundColour('#4f5049')
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel, 1, wx.EXPAND)
        self.SetSizer(sizer)

05/11/2009, 21h31
Shadok

Bonsoir,

Tu veux arriver à quel résultat au juste ?

En l'état ton code fait les choses suivantes :
- il créée une frame,
- il créée une panel vert qui couvre toute la frame,
- il créée un panel gris clair et un panel gris foncé et leur demande de couvrir, l'un la moitié supérieure du panel vert, l'autre la moitié inférieure du panel vert

Ce qui fait que l'on ne voit plus le panel vert, il est recouvert par les deux autres.
06/11/2009, 09h20
Yachas

Merci de ta réponse.
l'idée générale consiste à créer un panel indépendant de la fonction principale.
j'aurais, je l'espère, une interface graphique indépendante située dans un module (tempo_02).

Et donc, la finalité c'est d'avoir un panel vert en fond dans ma frame avec un panel gris clair centré au milieu de ce panel vert .
En fait, je n'arrive pas à comprendre ce qui se passe.
Dans mon idée initiale :
je créer un panel gris foncé qui servira de receptacle
ensuite, je creer un panel vert issu de mon module tempo_02 (par la suite ce panel sera beaucoup plus étoffé ^^)
que je rempli avec un panel gris clair centré au milieu.
A la sortie de mon module tempo_02, je remplie le panel gris foncé par le panel vert.
ce que tu me decris ne ressemble pas du tout à mon but initial ^^

je ne comprends pas pourquoi je creé un panel vert au début (pourquoi, il n'est pas gris foncé ?)
ensuite, à quel endroit et par quoi, je demande à couvrir la moitiée supérieure et la moitiée inferieure de mon panel vert.
pour le coup, je suis complétement perdu.
D'autre part, lorsque je lance l'applic, je voie les trois couleurs de mes panels.
à aucun moment j'ai un panel qui disparait sous les deux autres. au contraire, le panel vert est le plus présent !
merci de bien vouloir affranchir un p'auve pepere comme moi !
06/11/2009, 21h05
Shadok

>Bonsoir,

On va essayer d'y aller pas à pas. On est tous passés par là :zoubi:.

Il me semble que je t'avais déjà répondu sur un autre post et que ton problème c'était alors d'appréhender la notion de parent : ben c'est toujours là que tu bloques :mouarf:.

Dans le fichier Tempo_01 tout d'abord...

ligne 19 :
conteneur = wx.Panel(self, -1)
Tu crées un panel et tu lui indique que son parent c'est self (= ta frame) : donc, ton panel sera posé sur ta frame.

ligne 20 :
conteneur.SetBackgroundColour('#80f14e')
Tu demandes à ce panel de prendre une couleur de fond, ce code correspond au vert clair.

lignes 16, 37 et 38 :
Tu crées un sizer, tu le colles sur self (= ta frame, pour mémoire), et tu demandes que ton panel soit géré par ce sizer ; ligne 37 : tu précises que le sizer doit gérer ton panel de telle sorte qu'il s'étende à toute la surface de ta frame.

Pour tester, désactive temporairement les lignes 23 à 33 incluses et lance le programme : tu as bien une frame avec un panel vert qui couvre tout.

Tu constates donc que ton panel vert n'est pas du tout créé dans Tempo02...

Les lignes 25 et 26 créent deux autres panels issus des classes qui se trouvent dans le fichier Tempo_02 :
- "panel_A", de la classe Barre_Outils_01 ; dans cette classe, aucune couleur de fond particulière n'est spécifiée, donc il a la couleur par défaut d'un panel : gris clair si on est sous Linux, transparent si on est sous Windows ;
- "panel_B", de la classe Interface_Graphique_01 ; ligne 55 (dans Tempo_02), il est spécifié qu'un panel de cette classe est gris foncé.

Le parent de ces deux panels est "conteneur" (= le panel vert) ; c'est ce que tu demandes lignes 25 et 29 (le parent est le premier argument - ici, le seul - que l'on passe entre parenthèses quand on crée un objet).

Lignes 17, 32, 33, 36 :
Tu crées un sizer, tu le colles sur conteneur (= le panel vert), et tu demandes que panel_A et panel_B soient gérés par ce sizer ; ligne 36 : tu précises que le sizer doit gérer ces deux panels de telle sorte qu'ils s'étendent à toute la surface de leur parent ; ce parent, c'est le panel vert : il est donc complètement recouvert par les deux autres !

Sous Linux, on ne voit pas de vert du tout, sous windows, le vert apparaît entre la toolbar et la panel gris foncé, mais il est bel et bien recouvert par Panel_A (rappel : Panel_A est gris sous Linux, transparent sous Win) ; tu sembles être sous Windows, donc tu peux vérifier en ajoutant ceci ligne 46 dans Tempo_02 :
self.SetBackgroundColour('blue')

Lance alors le programme : tout ce qui est vert sera recouvert...

Bien, bien, je te remercie de ta patience... tu dois en avoir à revendre... surtout lorsque je me suis apperçu que l'on ne parlait plus des mêmes fichiers.... D'où le "gris clair" par exemple.. Oui, je sais.... Moi aussi je me suis traité d'andouille...
J'ai corsé un petit peu la difficulté pour comprendre l'utilisation d'un panel et d'un sizer. Donc, j'ai repris ce que tu m'as expliqué précédement en rajoutant un carré gris clair dans mon panel gris foncé (j'ai joint le code pour que l'on parle de la meme chose (Aiiiyyeeeeuuu.... Pas taper, j'ai des lunettes) :aie:

Bon, je crois comprendre que j'ai deux problèmes en fait...

1 : Je ne maitrise pas la taille de mon panel_A (la barre d'outils) , j'ai beau essayé de chercher, je n'arrive pas à modifier la taille de sortie de ce panel... je pensais naivement qu'il prenait la taille de ma ToolBar et qu'il s'adaptait à la taille de ma frame parent !
Ce n'est pas du tout le cas ^^ en fait, il apparait avec une taille que je ne maitrise pas (exactement la moitiée de la taille de mon panel vert clair). L'idée générale étant d'avoir quelque chose qui ressemble à une barre d'outils tout court...

2 : Le deuxième souci semble plus pervère, on dirait que je crée systematiquement deux parties de panel à chaque fois que j'utilise un sizer.
à chaque fois, j'ai l'impression d'avoir en sortie la moitiée de la moitiée. ( Erhrmm, à la relecture j'ai moi meme du mal à me comprendre... Je t'invite à essayer le code qui suit pour me comprendre)

Pourquoi deux moitiées de panel à chaque fois ? (j'ai gardé un code couleur pour chaque panel)

Module 1 :

Code:

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
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
 
# module1.py
 
import wx
import module2
 
 
class SimpleFrame(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title)
 
        frameSizer = wx.BoxSizer(wx.VERTICAL)
        panelSizer = wx.BoxSizer(wx.VERTICAL)
 
        conteneur = wx.Panel(self, -1)
        conteneur.SetBackgroundColour('#80f14e') #Vert Clair
 
 
#*********************************************************
        # panel_A : Barre d'outils
        panel_A = module2.Barre_Outils_01(conteneur)
 
#*********************************************************
        # panel_B : Interface Graphique
        panel_B = module2.Interface_Graphique_01(conteneur)
 
        panelSizer.Add(panel_A, 1, wx.EXPAND)
        panelSizer.Add(panel_B, 1, wx.EXPAND)
 
        conteneur.SetSizer(panelSizer)
        frameSizer.Add(conteneur, 1, wx.EXPAND)
        self.SetSizer(frameSizer)
        frameSizer.SetSizeHints(self)
 
        self.SetSize((500,500))
 
        self.Centre()
        self.Show(True)
 
 
 
app = wx.App()
SimpleFrame(None, -1, u'Ma Belle Fen?tre')
app.MainLoop()

Module 2 :

Code:

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
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
# module2.py
 
import wx
 
#-------------------------------------------------------------------------
class Barre_Outils_01(wx.Panel):
    """Barre d'outils de la fenêtre principale"""
#-------------------------------------------------------------------------
    def __init__(self, parent):
 
        wx.Panel.__init__(self, parent)
 
        TBFLAGS = ( wx.TB_HORIZONTAL
                  | wx.NO_BORDER
                  | wx.TB_FLAT
                  )
 
        tb = wx.ToolBar(self, style=TBFLAGS)  # self
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(tb, 0, wx.EXPAND)
        self.SetSizer(sizer)
 
        tsize = (24,24)
 
       # Définition des différents icones de la barre d'outils
        Png_01 =  wx.Bitmap("exit.png")
        Png_02 =  wx.Bitmap("book.png")
        Png_03 =  wx.Bitmap("linux.png")
 
        tb.SetToolBitmapSize(tsize)
 
        # Dessine la Barre d'outils
        tb.AddLabelTool(10, "", Png_01)
        tb.AddSeparator()
 
        tb.AddLabelTool(20, "", Png_02)
        tb.AddSeparator()
 
        tb.AddLabelTool(30, "", Png_03)
        tb.AddSeparator()
 
        tb.Realize()
 
        self.SetBackgroundColour('blue') # Bleu
 
 
#-------------------------------------------------------------------------
 
#-------------------------------------------------------------------------
class Interface_Graphique_01(wx.Panel):
    """Interface_Graphique de la fenêtre principale"""
#-------------------------------------------------------------------------
    def __init__(self, parent):
        wx.Panel.__init__(self, parent, -1)
 
        panel = wx.Panel(self, -1)
        panel.SetBackgroundColour('#4f5049') # Gris foncé
 
        midPan = wx.Panel(panel, -1)
        midPan.SetBackgroundColour('#ededed') # Gris clair
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(midPan, 1, wx.EXPAND | wx.ALL, 20)
        sizer.Add(panel, 1, wx.EXPAND)
        self.SetSizer(sizer)

07/11/2009, 20h56
Shadok

Bonsoir,

Pour ton point 1 : sisi, tu peux maîtriser tout ça ! Reprenons le code de ton sizer, car tout est là :

panelSizer.Add(panel_A, 2, wx.EXPAND)
panelSizer.Add(panel_B, 2, wx.EXPAND)

Premier élément important quand on utilise un sizer et qu'on ajoute un objet à ceux qui doivent être gérés par le sizer, le chiffre qui se trouve en seconde position :
- ici, tu as 2 éléments, et tu as passé en argument "2" à chaque fois : donc on a 2 + 2 = 4. Le premier objet va occuper 2/4 de la place disponible, le second, 2/4 ; ce qui revient à dire que chaque panneau va occuper la moitié de l'espace dispo !
- modifie la première de ces deux lignes en mettant "1" au lieu de "2" ; on va désormais avoir 1 + 2 = 3. Le premier panel occupera cette fois 1/3 de l'espace dispo et le second 2/3 ;
-modifie encore la première ligne en mettant "0", et sur la seconde n'importe quel autre chiffre (mais en ce cas, par convention on met habituellement 1)...

Pour ton point 2, petit jeu :
Combien y a-t-il de panels :
- dans la version initiale de ton code ?
- dans la version modifiée ?
Top chrono...
09/11/2009, 13h48
Yachas

Bonjour,
ça, c'est ce qu'il s'appelle une réponse argumentée...
Je n'avais pas du tout compris comment utiliser le flag "proportion"... Enfin, c'est à dire à quoi il servait ^^
Merci... Malgrés tout, je n'ai toujours pas réussi à trouver le nombre de panel dans mon code.
J'ai une explication, faut que j'arrête de porter un casque de sécurité dans mon boulot.... il doit certainement trop appuyer sur la tête et gener la circulation sanguine et donc ne pas hydrater corectement mon cerveau... Je ne vois que ça pour expliquer pourquoi je suis encore largué.

Bien...
Je reprends tes explications :

si je compte maintenant le nombre de panel qu'il y a dans mon sizer panelSiser, desormais, j'en dénombre 1.
Je remplace le 2 de la ligne 31 de mon module 1 par 0. et donc : 0 + 1(celui de la ligne 32) cela me fait donc 1 panel qui doit prendre toute la zone de mon panel conteneur

Cependant, si je teste mon code, je me retrouve avec ma barre d'outils correctement dimensionnée. Puis encore une fois, 2 moitiées de panel dans ma fenêtre principale. Fort des explications précédentes, j'en déduis que je dois avoir 2 panels... Et c'est là que cela coince...
je ne comprends pas pourquoi j'ai 2 moitiée de panels. Je pense que ces deux panels proviennent de mon panel_B. Mais je ne me l'explique pas non plus :(

pourrais tu m'affranchir, s'il te plait ?
je ne vois pas où j'ai faut... Pourtant, j'ai faut !!! :mrgreen:
Merci de ta réponse
09/11/2009, 15h24
Shadok

Bonjour,

Attention !

Si tu as :

panelSizer.Add(panel_A, 2, wx.EXPAND)
panelSizer.Add(panel_B, 2, wx.EXPAND)

ou :

panelSizer.Add(panel_A, 0, wx.EXPAND)
panelSizer.Add(panel_B, 1, wx.EXPAND)

... tu as toujours le même nombre de panels ! La seule chose qui change c'est la façon dont ton code gère leur affichage : quand on passe "0" comme argument pour un objet (ici : panel _A), il va prendre uniquement la place qui est nécessaire pour afficher le contenu (= les enfants) de cet objet - cad dans le cas de panel_A : la toolbar ; donc, visuellement, tu ne vois plus que la toolbal mais panel_A est toujours là, en sandwich entre conteneur et la toolbar. L'autre panel qui a reçu "1" comme argument ne va pas prendre la totalité de la surface de conteneur (car il y a un minimum incompressible pour panel_A : la place nécessaire pour l'affichage du contenu de ce dernier), il va prendre la totalité de ce qui reste.

Le cas "proportion" étant résolu, on va s'attaquer au deuxième problème.

Dans ta première version du code, tu as 4 panels :
- conteneur ;
- panel_A ;
- panel_B ;
- panel_B.panel (relis bien ton code pour ta classe "class Interface_Graphique_01" : cette classe est une classe de panel et dans le code, tu crées un autre panel nommé "panel" ! panel_B est un objet parent qui a un objet enfant nommé "panel").

Dans ta seconde version du code, tu as 5 panels :
- conteneur ;
- panel_A ;
- panel_B ;
- panel_B.panel ;
- panel_B.midPan. Cette fois, panel_B est est le parent de deux enfants : panel et midPan.

Il me semble que tu fais une confusion entre deux choses bien différentes :
- les widgets (ou "contrôles", ou "windows") cad les composants graphiques - que l'on voit à l'écran : frame, panel, toolbar, textctrl...
- le sizer, qui n'est pas un composant graphique, mais une sorte de grille invisible, de gabarit, qui sert à positionner les widgets que l'ont décide de lui relier au moyen de la commande "add".
09/11/2009, 16h12
Yachas

Whoawwww.
Effectivement, je me mélangeais un peu les pinceaux entre les Widgets et le sizer. Tes explications sont claires, merci bien.
En reprenant les différents codes, j'arrive enfin à retrouver le nombre de panel. cela me semble un peu plus compréhensible.
Par contre, je ne voie pas comment réussir à faire rentrer tout ça (mes 5 panels) dans ma fenetre principale !!!
Ce que je n'arrive pas à comprendre, c'est pourquoi mon panel_B (composé de deux enfants: panel et midpan) ne se superpose pas sur le reste qui compose mon panel "conteneur". Si je comprends bien, je n'ai pas en retour de panel_B, qu'un seul panel !?! je me retrouve avec un panel : panel_B + un autre panel (Celui du panel gris fonçé et gris clair) .
Autant, j'ai compris l'histoire du panel_A avec son encombrement minimal... Autant, je n'arrive pas à saisir pourquoi mon panel_B se décompose en deux panels.
Je pensais naivement que le retour de mon panel_B était composé d'un seul tenant : un seul panel (le gris foncè + le gris clair) nommé panel_B.
Alors, comment faire pour n'avoir qu'un seul panel remplissant le reste du conteneur ? J'avoue que là, je suis un peu perdu.
L'idée initiale était de composer une interface graphique dans un module indépendant puis de la rapatrier dans ma fenetre principale lorsque j'en avait besoin.
10/11/2009, 13h50
Shadok

Bonjour,

Dans mon dernier message, il y a une grosse erreur :oops: - désolé :
- panel_B n'a qu'un seul panel enfant nommé panel ;
- midPan n'est pas enfant de panel_B mais de panel.

Si tu veux avoir un panel_A réduit à la toolbar, tu dois avoir dans module1.py lignes 30 et 31 :
panelSizer.Add(panel_A, 0, wx.EXPAND)
panelSizer.Add(panel_B, 1, wx.EXPAND)

...et le code minimal pour panel_B serait le suivant à partir de la ligne 58 jusqu'à la fin du module (la ligne "self.SetBackgroundColour('yellow')" n'est pas indispensable, elle sert juste à colorer panel_B en jaune pour qu'il soit plus visible et qu'on voie bien qu'il couvre tout le conteneur qui lui est en vert) :

wx.Panel.__init__(self, parent, -1)

self.SetBackgroundColour('yellow')

Il ne te reste plus qu'à compléter le code de la classe "Interface_Graphique_01" en créant des widgets enfants de cette classe de panel :

widget = wx.classedewidget(self, id, autresarguments)
10/11/2009, 17h04
Yachas

Bonjour,
Bon, je crois que cela va finir avec une opération "papier-dessin-ciseau-colle" scotché sur l'écran, ça va pas trainer... :mouarf:
Pour le coup, j'ai un petit soucis de compréhension concernant ta dernière réponse. (Je progresse quand même, j'avais rectifié de moi-même concernant ta "grosse erreur" !!!, mais je m'égare ^^)

Citation:

...et le code minimal pour panel_B serait le suivant à partir de la ligne 58 jusqu'à la fin du module (la ligne "self.SetBackgroundColour('yellow')" n'est pas indispensable, elle sert juste à colorer panel_B en jaune pour qu'il soit plus visible et qu'on voie bien qu'il couvre tout le conteneur qui lui est en vert) :

wx.Panel.__init__(self, parent, -1)

self.SetBackgroundColour('yellow')

N'est ce pas ce qui est ecrit dans mon code ? Ou alors il manque du texte... non ?

Ensuite,

Citation:

Il ne te reste plus qu'à compléter le code de la classe "Interface_Graphique_01" en créant des widgets enfants de cette classe de panel :

widget = wx.classedewidget(self, id, autresarguments)

J'ai l'impression d'avoir cela également dans mon code...
J'ai un panel déclaré selon ta syntaxe, non ? ( panel = wx.Panel(self, -1))
Là où c'est peut etre négociable c'est pour mon panel midpan... Mais je vois pas comment le déclarer autrement...

où alors j'ai rien compris à ta réponse (ce qui n'est pas exclu non plus ^^)
13/11/2009, 13h55
Shadok

Citation:

Envoyé par Yachas

N'est ce pas ce qui est ecrit dans mon code ?

Sisi ! Je voulais juste bien mettre l'accent sur le fait que, si le but poursuivi n'est que de mettre un panel sur ton panel vert, il n'était pas nécessaire d'en mettre davantage... C'est bien pour ça que j'ai parlé d'un code minimal.

Je me doute que tu vas ajouter d'autre objets dessus et la déclaration de panel_B.panel est d'ailleurs tout à fait réglo.

Par contre, pour midPan, ce que tu as fait est incorrect : ne jamais relier ensemble dans un même sizer des objets qui ont des parents différents (soit ça plantera soit ton affichage sera... très différent du but recherché).
13/11/2009, 17h37
Yachas

Merci de ta réponse.
Effectivement, lorsque je neutralise "panel" dans mon code du module 2, j'arrive à ce que je voulais.... un panel gris foncé (moyennant une petite modif dans le choix de la couleur de la ligne : self.SetBackgroundColour('#4f5049') et un panel blanc cassé
Pfff... Cela fait 3 jours que je cherche comme un malade pour finalement arriver supprimer mon panel ^^ Et le pire, c'est que je n'y ai même pas pensé.
Avant de proposer mon code à tout me monde, je vais chercher à étoffer mon interface graphique afin de voir si j'ai bien tout compris sur la base de tout ce que tu m'as dis.
En tout cas, tu m'as rendu un grand service, et je retiens la leçon, ne jamais mélanger les parents d'objet différents dans un même sizer.

Bonjour,
Pour ceux à qui cela peut intéresser, voici le code enfin finalisé.
Bon d'accord, j'ai peu étoffé cette interface graphique, mais l'essentiel est de comprendre comment cela fonctionne.
Après, pour ceux qui souhaite s'en servir, je laisse votre coté artiste s'exprimer ^^
un Grand merci à Shadok, qui n'est pas étranger au resultat, également pour sa patience :ccool:

module 01

Code:

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
 
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
 
# module1.py
 
import wx
import module2
 
 
class SimpleFrame(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title)
 
        frameSizer = wx.BoxSizer(wx.VERTICAL)
        panelSizer = wx.BoxSizer(wx.VERTICAL)
 
        conteneur = wx.Panel(self, -1)
        conteneur.SetBackgroundColour('#80f14e') #Vert Clair
 
 
#*********************************************************
        # panel_A : Barre d'outils
        panel_A = module2.Barre_Outils_01(conteneur)
 
#*********************************************************
        # panel_B : Interface Graphique
        panel_B = module2.Interface_Graphique_01(conteneur)
 
        panelSizer.Add(panel_A, 0, wx.EXPAND)
        panelSizer.Add(panel_B, 1, wx.EXPAND)
 
        conteneur.SetSizer(panelSizer)
        frameSizer.Add(conteneur, 1, wx.EXPAND)
        self.SetSizer(frameSizer)
        frameSizer.SetSizeHints(self)
 
        self.SetClientSize(conteneur.GetBestSize())
 
        self.Centre()
        self.Show(True)
 
 
 
app = wx.App()
SimpleFrame(None, -1, u'Ma Belle Fenêtre')
app.MainLoop()

module 02

Code:

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
#!/usr/bin/env python
# -*- coding: cp1252 -*-
 
# module2.py
 
import wx
 
#-------------------------------------------------------------------------
class Barre_Outils_01(wx.Panel):
    """Barre d'outils de la fenêtre principale"""
#-------------------------------------------------------------------------
    def __init__(self, parent):
 
        wx.Panel.__init__(self, parent, -1)
 
        TBFLAGS = ( wx.TB_HORIZONTAL
                  | wx.NO_BORDER
                  | wx.TB_FLAT
                  )
 
        tb = wx.ToolBar(self, style=TBFLAGS)  # self
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(tb, 0, wx.EXPAND)
        self.SetSizer(sizer)
 
        tsize = (24,24)
 
       # Définition des différents icones de la barre d'outils
        Png_01 =  wx.Bitmap("exit.png")
        Png_02 =  wx.Bitmap("book.png")
        Png_03 =  wx.Bitmap("linux.png")
 
        tb.SetToolBitmapSize(tsize)
 
        # Dessine la Barre d'outils
        tb.AddLabelTool(10, "", Png_01)
        tb.AddSeparator()
 
        tb.AddLabelTool(20, "", Png_02)
        tb.AddSeparator()
 
        tb.AddLabelTool(30, "", Png_03)
        tb.AddSeparator()
 
        tb.Realize()
 
 
#-------------------------------------------------------------------------
 
#-------------------------------------------------------------------------
class Interface_Graphique_01(wx.Panel):
    """Interface_Graphique de la fenêtre principale"""
#-------------------------------------------------------------------------
 
    def __init__(self, parent):
        wx.Panel.__init__(self, parent, -1)
 
        # Initialise les différents Sizer
        vbox_top = wx.BoxSizer(wx.VERTICAL)
        vbox = wx.BoxSizer(wx.VERTICAL)
 
#*********************************************************
        # panel1
        panel1 = wx.Panel(self, -1)
        panel1.SetBackgroundColour('#4f5049') # Gris foncé
        midpan = wx.Panel(panel1, -1, size=(300, 300))
        midpan.SetBackgroundColour('#ededed') # Gris clair
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(midpan, 1, wx.EXPAND | wx.ALL, 20)
 
        panel1.SetSizer(sizer)
        vbox.Add(panel1, 0, wx.EXPAND)
 
        vbox.Add((-1, 10))
#*********************************************************
        # panel2
 
        panel2 = wx.Panel(self, -1)
        bouton = wx.Button(panel2, -1, 'Close', size=(50, -1))
 
        sizer2 = wx.BoxSizer(wx.HORIZONTAL)
        sizer2.Add(bouton)
 
        panel2.SetSizer(sizer2)
        vbox.Add(panel2, 1, wx.BOTTOM)
 
        vbox_top.Add(vbox, 1, wx.EXPAND | wx.ALL, 10)
        self.SetSizer(vbox_top)