Somme de 2 PseudoDC

**Yachas** · 12/05/2010, 16h26

Bonjour,
j'ai un petit souci d'ordre sentimentale avec un petit bout d'application que je n'arrive pas à faire fonctionner.
Je sollicite vos compétences parcequ'à force de chercher dans la doc, je ne comprends plus rien aux DC.
Dans un premier temps, je dispose de deux PseudoDC différents avec des éléments dessinés à l'interieur de chacun d'eux...
Serait'il possible de faire une opération du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
dc = wx.PseudoDC()
dc1 = wx.PseudoDC()
 
dc = dc + dc1

enfin, c'est pas si simple, je suis d'accord, c'est juste pour donner l'idée générale.
Mais si quelqu'un peut m'instruire un petit peu, je suis preneur.

Merci d'avance pour vos réponses

**pacificator** · 13/05/2010, 16h12

D'après la doc, les pseudoDC simulent les DC et les commandes qu'ils reçoivent sont stockées dans une liste et peuvent être appliqué à un DC en utilisant la méthode DrawToDC.
Essaye:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

dc1.DrawToDC(dc)

**Yachas** · 19/05/2010, 16h34

Merci pour ta réponse.

à priori cela ne réponds pas tout à fait à mon problème.
Je creuse la question et je posterais un bout de code si des fois je n'arrive pas à m'en sortir.

**nyko77** · 21/05/2010, 00h59

Bonjour,
Je na connaissais wx.PseudoDc et ça m'a l'air très intéressant.
à première vu il n'est pas prévu de pouvoir concaténer 2 PseudoDC.

L'idée qu'il me vient, c'est de créer une classe pour gérer tout ça, voici un exemple:

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
 
import wx
 
class MultiPseudoDC(list):
    def drawToDc(self, dc):
        for pseudoDc in self:
            pseudoDc.DrawToDC(dc)
 
 
 
class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None)
 
        self.pseudoDC1 = wx.PseudoDC()
        self.pseudoDC1.DrawLine(10, 10, 10, 50)
        self.pseudoDC1.DrawLine(10, 10, 50, 10)
 
        self.pseudoDC2 = wx.PseudoDC()
        self.pseudoDC2.DrawRectangle(60, 20, 40, 40) 
 
        self.multiPseudoDC = MultiPseudoDC()
        self.multiPseudoDC.append(self.pseudoDC1)
        self.multiPseudoDC.append(self.pseudoDC2)
 
        self.Show()
 
        self.Bind(wx.EVT_PAINT, self.onPaint)
 
    def onPaint(self, e):
        dc = wx.PaintDC(self)
        self.multiPseudoDC.drawToDc(dc)
 
 
app = wx.App(0)
frame = MyFrame()
app.MainLoop()

Il y a peut être une méthode plus propre, mais je vois rien dans la doc. Il y a une histoire d'id que j'ai pas bien compris.

**Ggamer** · 29/05/2010, 21h10

Bonjour,

Envoyé par nyko77

Il y a une histoire d'id que j'ai pas bien compris.

C'est pourtant la partie la plus intéressante du PseudoDC !

On peut attribuer un ID à chaque commande (ou chaque lot de commandes) de dessin effectuée. Par exemple, l'ID 100 est attribué à un rectangle rouge.

C'est très utile, entre autres, pour les interactions avec le dessin : si vous cliquez avec la souris sur le rectangle rouge, il va vous dire que vous avez cliqué sur l'ID 100.

C'est également utile pour déplacer ou supprimer des éléments du dessin. Par exemple, vous pouvez supprimer le rectangle rouge en spécifiant son ID.

Sympa, non ?

A +

**nyko77** · 30/05/2010, 03h12

En effet ça m'a l'air sympa.
Je viens de regarder la doc plus sérieusement, et surtout la démo. ça va m'éviter bien des galères pour traiter un grand nombre d'item.

Merci pour cette découverte

**Yachas** · 31/05/2010, 21h17

Bonjour,
j'aime bien ton idée de classe niko

je crois que je vais exploiter l'idée.
c'est peut etre la solution à mon problème, justement !
mon soucis c'est que dès que j'ajoute 2 pseudoDC, je perd le principe de l'ID que vous avez evoqué. Du coup, plus moyen de selectionner mon carré rouge par exemple. meme si j'utilise son ID 100.
Bizare... je continu à chercher...

**Ggamer** · 31/05/2010, 21h29

C'est pour faire quoi au fait ? Peut-être que l'on pourrait trouver une alternative ?

**Yachas** · 01/06/2010, 11h34

Bonjour,
L'idée c'est de déplacer des pions sur une map et à chaque fois que je selectionne un pion, je dessine son potentiel de mouvement.

J'ai creer une fonction qui dessine les pions en utilisant un pseudoDC : (dc).
Je pensais naivement que si j'ajoutais un autre pseudoDC (dc1) au précédent (par exemple le potentiel de déplacement du pion selectionné), je pouvais rajouter des informations au fur et à mesure de mes besoins dans ma map et me servir aussi des fonctionnalités d'un pseudoDC (les ID par exemple).

Malheureusement, une fois que j'utilise la ligne de code : dc1.DrawToDC(dc)
je perds toute possibilité de reselectionner mes pions dans mon pseudoDC : (dc).

Bref quelque ligne de code permettraient de mieux comprendre ce que je veux dire.
je vais simplifier mon appli, dès que je pourrais, pour vous fournir ces lignes de code.

**Ggamer** · 01/06/2010, 22h22

Salut,

D'après moi, il n'y a pas d'intérêt d'utiliser ces 2 pseudoDC : 1 seul suffit. Je pense que j'aurais utilisé un simple dictionnaire pour mémoriser les ID du PseudoDC, les position réelles et les positions potentielles, etc...

Mais bon, à voir en fonction de ce que vous souhaitez vraiment...

A +

**Yachas** · 10/06/2010, 16h34

Désolé pour ce retard, j'étais plein d'ambition pour vous montrez ce que je souhaite faire... mais je ne comprends pas quelque chose et donc je me tourne vers vous.
j'ai simplifié mon application initiale et je n'arrive pas à m'expliquer pourquoi je n'arrive plus à selectionner mes pions.
si quelqu'un peu m'apporter une explication, je suis preneur ^^
merci d'avance

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
 
import wx
import random
 
 
class MyCanvas(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, parent = None, id = 1, title = titre, size = (500, 500))
 
        self.conteneur = wx.Panel(self, 1, size = self.GetClientSize())
 
        # Initialise les différents Sizer
        vbox = wx.BoxSizer(wx.HORIZONTAL)
 
        # Create vertical box sizer : bordure
        self.bordure1 = wx.BoxSizer(wx.VERTICAL)
 
        # Création du Widget wxStaticBox : 'Terrain de jeu' avec son Sizer
        self.staticBox1 = wx.StaticBox ( self.conteneur, -1, 'Terrain de jeu' )
        self.staticBoxSizer1 = wx.StaticBoxSizer ( box = self.staticBox1, orient=wx.VERTICAL )
 
        #-------------------------------------------------------------
        # écran "Map_Terrain"
        #-------------------------------------------------------------
        self.sizer_Map = wx.BoxSizer(orient=wx.VERTICAL)
        # Création du panel "P_Map"
        self.P_Map = Interface_Map(self.conteneur)
        self.sizer_Map.AddSizer(self.P_Map, 1, border=0, flag=wx.EXPAND)
        self.staticBoxSizer1.AddSizer(self.sizer_Map, 1, border=0, flag=wx.EXPAND)
 
      #-----------------------------------------------------------
      # Configure the box sizers du Panel1
        self.bordure1.Add(self.staticBoxSizer1, 1, wx.EXPAND | wx.ALL, 10)
 
      # Attach everything
        self.conteneur.SetSizerAndFit (self.bordure1)
        vbox.Add(self.conteneur, 1, wx.EXPAND)
 
      # Rendu final du sizer
        self.SetSizer(vbox)
 
 
#-------------------------------------------------------------------------
class Interface_Map(wx.ScrolledWindow):
    """Création de l'interface "Map Terrain"""
#-------------------------------------------------------------------------
    def __init__(self, conteneur):
 
	wx.ScrolledWindow.__init__(self, conteneur)
 
        # Map "Terrain de jeu" :
        # create a PseudoDC to record our drawing
        self.pdc = wx.PseudoDC()
        self.DoDrawing(self.pdc)
 
        # Evenements
        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x:None)
        self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseMove)
 
        # vars for handling mouse clicks
        self.dragid = -1
        self.lastpos = (0,0)
 
    #*********************************************************
    def DoDrawing(self, dc):
 
        random.seed()
        self.objids = []
        radius = 25
 
        dc.SetPen(wx.Pen('#d4d4d4'))
        dc.SetBrush(wx.Brush('#c50024'))
 
        dc.BeginDrawing()
        # Dessine les Pions
        for i in range(1,4):
            id = wx.NewId()
            dc.SetId(id)
            x = random.randint(100, 300)
            y = random.randint(100, 300)
            dc.DrawCircle(x,y,radius)
            self.objids.append(id)
        dc.EndDrawing()
 
    #---------------------------------------------------------
    def OnPaint(self, event):
        # Create a buffered paint DC.  It will create the real
        # wx.PaintDC and then blit the bitmap to it when dc is
        # deleted.
        dc = wx.BufferedPaintDC(self)
        # use PrepateDC to set position correctly
        self.PrepareDC(dc)
        # we need to clear the dc BEFORE calling PrepareDC
        bg = wx.Brush(self.GetBackgroundColour())
        dc.SetBackground(bg)
        dc.Clear()
        self.pdc.DrawToDC(dc)
 
    #---------------------------------------------------------
    def OnMouseMove(self, event):
        hitradius = 5
 
        if event.LeftDown():
            x,y = event.GetPosition()
 
            l = self.pdc.FindObjects(x, y, hitradius)
            for id in l:
                if not self.pdc.GetIdGreyedOut(id):
                    self.dragid = id
                    self.lastpos = (event.GetX(),event.GetY())
                    break
 
        elif event.RightDown():
            x,y = event.GetPosition()
            l = self.pdc.FindObjects(x, y, hitradius)
            if l:
                self.pdc.SetIdGreyedOut(l[0], not self.pdc.GetIdGreyedOut(l[0]))
                r = self.pdc.GetIdBounds(l[0])
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
 
        elif event.Dragging() or event.LeftUp():
            if self.dragid != -1:
                x,y = self.lastpos
                dx = event.GetX() - x
                dy = event.GetY() - y
                r = self.pdc.GetIdBounds(self.dragid)
                self.pdc.TranslateId(self.dragid, dx, dy)
                r2 = self.pdc.GetIdBounds(self.dragid)
                r = r.Union(r2)
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
                self.lastpos = (event.GetX(),event.GetY())
            if event.LeftUp():
                self.dragid = -1
 
 
class MonApp(wx.App):
    def OnInit(self):
        fen = MyCanvas("Déplacement Pions")
        fen.Show(True)
        self.SetTopWindow(fen)
        return True
 
app = MonApp()
app.MainLoop()

**Yachas** · 17/06/2010, 14h27

Bonjour,
j'ai quelque peu modifié mon code en me servant du principe de classe de nyko77. Mais je n'arrive toujours pas à comprendre pourquoi ma fonction "FindObjects" ne détecte rien et me retourne une liste vide.
Y 'a quelque chose qui m'échappe ou alors je suis complètement à coté de la plaque ?
Si quelqu'un peut m'expliquer pourquoi je n'arrive pas à détecter un de mes pions en le selectionnant avec la sourie. je ne le remercierai jamais assez

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
 
import wx
import random
 
objids = []
 
 
class MultiPseudoDC(list):
    def drawToDc(self, dc):
        for pseudoDc in self:
            pseudoDc.DrawToDC(dc)
 
 
class MyCanvas(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, parent = None, id = 1, title = titre, size = (500, 500))
 
        self.conteneur = wx.Panel(self, 1, size = self.GetClientSize())
 
        # Initialise les différents Sizer
        vbox = wx.BoxSizer(wx.VERTICAL)
 
        # Create vertical box sizer : bordure
        self.bordure1 = wx.BoxSizer(wx.VERTICAL)
 
        # Création du Widget wxStaticBox : 'Terrain de jeu' avec son Sizer
        self.staticBox1 = wx.StaticBox ( self.conteneur, -1, 'Terrain de jeu' )
        self.staticBoxSizer1 = wx.StaticBoxSizer ( box = self.staticBox1, orient=wx.VERTICAL )
 
        # écran "Map_Terrain"
        self.sizer_Map = wx.BoxSizer(orient=wx.VERTICAL)
 
        # Création du panel "P_Map"
        self.P_Map = Interface_Map(self.conteneur)
        self.sizer_Map.AddSizer(self.P_Map, 1, border=0, flag=wx.EXPAND)
        self.staticBoxSizer1.AddSizer(self.sizer_Map, 1, border=0, flag=wx.EXPAND)
 
      #-----------------------------------------------------------
      # Configure the box sizers
        self.bordure1.Add(self.staticBoxSizer1, 1, wx.EXPAND | wx.ALL, 10)
 
      # Attach everything
        self.conteneur.SetSizerAndFit (self.bordure1)
        vbox.Add(self.conteneur, 1, wx.EXPAND)
 
      # Rendu final du sizer
        self.SetSizer(vbox)
 
#-------------------------------------------------------------------------
class Interface_Map(wx.ScrolledWindow):
    """Création de l'interface "Map Terrain"""
#-------------------------------------------------------------------------
    def __init__(self, conteneur):
 
	wx.ScrolledWindow.__init__(self, conteneur)
 
        # Map "Terrain de jeu" :
        self.SetBackgroundColour(wx.Colour(255, 141, 14)) # Couleur 'Orange'
        self.Rouge = 1
        self.Vert = 2
 
        # create a PseudoDC to record our drawing
        self.pdc = wx.PseudoDC()
        self.DoDrawing(self.pdc)
 
        # Evenements
        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x:None)
        self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseMove)
 
        # vars for handling mouse clicks
        self.dragid = -1
        self.lastpos = (0,0)
 
 
    #*********************************************************
    def DoDrawing(self, dc):
 
        self.pseudoDC1 = self.OnAddPions(self.Rouge)
        self.pseudoDC2 = self.OnAddPions(self.Vert)
 
        self.multiPseudoDC = MultiPseudoDC()
        self.multiPseudoDC.append(self.pseudoDC1)
        self.multiPseudoDC.append(self.pseudoDC2)
        self.multiPseudoDC.append(dc)
    #-----------------------------------------------------------
 
 
    #---------------------------------------------------------
    def OnPaint(self, event):
        # Create a buffered paint DC.  It will create the real
        # wx.PaintDC and then blit the bitmap to it when dc is
        # deleted.
        dc = wx.BufferedPaintDC(self)
        # use PrepateDC to set position correctly
        self.PrepareDC(dc)
        # we need to clear the dc BEFORE calling PrepareDC
        bg = wx.Brush(self.GetBackgroundColour())
        dc.SetBackground(bg)
        dc.Clear()
        self.multiPseudoDC.drawToDc(dc)
 
    #---------------------------------------------------------
    def OnMouseMove(self, event):
        hitradius = 5
 
        if event.LeftDown():
            x,y = event.GetPosition()
 
            l = self.pdc.FindObjects(x, y, hitradius)
            for id in l:
                if not self.pdc.GetIdGreyedOut(id):
                    self.dragid = id
                    self.lastpos = (event.GetX(),event.GetY())
                    break
 
        elif event.RightDown():
            x,y = event.GetPosition()
            l = self.pdc.FindObjects(x, y, hitradius)
            if l:
                self.pdc.SetIdGreyedOut(l[0], not self.pdc.GetIdGreyedOut(l[0]))
                r = self.pdc.GetIdBounds(l[0])
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
 
        elif event.Dragging() or event.LeftUp():
            if self.dragid != -1:
                x,y = self.lastpos
                dx = event.GetX() - x
                dy = event.GetY() - y
                r = self.pdc.GetIdBounds(self.dragid)
                self.pdc.TranslateId(self.dragid, dx, dy)
                r2 = self.pdc.GetIdBounds(self.dragid)
                r = r.Union(r2)
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
                self.lastpos = (event.GetX(),event.GetY())
            if event.LeftUp():
                self.dragid = -1
 
    #---------------------------------------------------------
    def OffsetRect(self, r):
        xView, yView = self.GetViewStart()
        xDelta, yDelta = self.GetScrollPixelsPerUnit()
        r.OffsetXY(-(xView*xDelta),-(yView*yDelta))
 
    #---------------------------------------------------------
    def OnAddPions(self, couleur):
            radius = 25
 
            pDC = wx.PseudoDC()
            pDC.SetPen(wx.Pen('#d4d4d4'))
 
            if couleur == self.Rouge :
                # Dessine les Pions Rouges
                pDC.SetBrush(wx.Brush('#c50024')) # Couleur 'Rouge'
            else :
                # Dessine les Pions verts
                pDC.SetBrush(wx.Brush('#1ac500')) # Couleur 'Verte'
 
            pDC.BeginDrawing()
            for i in range(1,4):
                id = wx.NewId()
                pDC.SetId(id)
                x = random.randint(50, 200)
                y = random.randint(50, 200)
                x1 = x - radius
                y1 = y - radius
                x2 = 2 * radius
                y2 = 2 * radius
                r = wx.Rect(x1,y1,x2,y2)
                pDC.DrawCircle(x,y,radius)
                pDC.SetIdBounds(id,r)
                objids.append(id)
            pDC.EndDrawing()
            return pDC
    #---------------------------------------------------------
 
 
class MonApp(wx.App):
    def OnInit(self):
        fen = MyCanvas("Somme de 2 PseudoDC")
        fen.Show(True)
        self.SetTopWindow(fen)
        return True
 
app = MonApp()
app.MainLoop()

**Yachas** · 02/07/2010, 08h40

Bonjour,
J'ai enfin compris pourquoi je n'arrivais pas à selectionner mes pions et les déplacer. En fait, je n'ai pas trouvé solution à mon problème de départ, à savoir : la somme de 2 PseudoDC.
Rien n'indique dans la doc la possiblité de le faire, DrawToDC() comme l'indique son nom, ne fait que dessiner le PseudoDC dans un DC

J'ai mis un moment fou à comprendre cela...
En revanche, rien n'empèche d'enrichir le PseudoDC au fur et à mesure de ses besoins. Il est possible de travailler plusieurs fois de suite dans le même PseudoDC.

Euhhh... c'est pas clair là.?. Regarder dans la methode DoDrawing ^^ vous comprendrez mieux que ce que je suis capable d'expliquer.
Bon, je vous fournis le resultat de mes cogitations ci dessous.
Ce n'est certainement pas la meilleur façon d'y arriver, cela dit... ça fonctionne, et c'est déjà un plus par rapport au début.

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
 
import wx
import random
 
class MyCanvas(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, parent = None, id = 1, title = titre, size = (500, 500))
 
        self.conteneur = wx.Panel(self, 1, size = self.GetClientSize())
 
        # Initialise les diff?rents Sizer
        vbox = wx.BoxSizer(wx.VERTICAL)
 
        # Create vertical box sizer : bordure
        self.bordure1 = wx.BoxSizer(wx.VERTICAL)
 
        # Cr?ation du Widget wxStaticBox : 'Terrain de jeu' avec son Sizer
        self.staticBox1 = wx.StaticBox ( self.conteneur, -1, 'Terrain de jeu' )
        self.staticBoxSizer1 = wx.StaticBoxSizer ( box = self.staticBox1, orient=wx.VERTICAL )
 
        # ?cran "Map_Terrain"
        self.sizer_Map = wx.BoxSizer(orient=wx.VERTICAL)
 
        # Cr?ation du panel "P_Map"
        self.P_Map = Interface_Map(self.conteneur)
        self.sizer_Map.AddSizer(self.P_Map, 1, border=0, flag=wx.EXPAND)
        self.staticBoxSizer1.AddSizer(self.sizer_Map, 1, border=0, flag=wx.EXPAND)
 
      #-----------------------------------------------------------
      # Configure the box sizers
        self.bordure1.Add(self.staticBoxSizer1, 1, wx.EXPAND | wx.ALL, 10)
 
      # Attach everything
        self.conteneur.SetSizerAndFit (self.bordure1)
        vbox.Add(self.conteneur, 1, wx.EXPAND)
 
      # Rendu final du sizer
        self.SetSizer(vbox)
 
#-------------------------------------------------------------------------
class Interface_Map(wx.ScrolledWindow):
    """Cr?ation de l'interface "Map Terrain"""
#-------------------------------------------------------------------------
    def __init__(self, conteneur):
 
	wx.ScrolledWindow.__init__(self, conteneur)
 
        # Map "Terrain de jeu" :
        self.SetBackgroundColour(wx.Colour(255, 141, 14)) # Couleur 'Orange'
        self.Rouge = 1
        self.Vert = 2
 
        # create a PseudoDC to record our drawing
        self.pdc = wx.PseudoDC()
        self.DoDrawing(self.pdc)
 
        # Evenements
        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x:None)
        self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseMove)
 
        # vars for handling mouse clicks
        self.dragid = -1
        self.lastpos = (0,0)
 
 
    #*********************************************************
    def DoDrawing(self, dc):
 
        self.OnAddPions(self.Rouge, dc)
        self.OnAddPions(self.Vert, dc)
 
    #-----------------------------------------------------------
 
 
    #---------------------------------------------------------
    def OnPaint(self, event):
        # Create a buffered paint DC.  It will create the real
        # wx.PaintDC and then blit the bitmap to it when dc is
        # deleted.
        dc = wx.BufferedPaintDC(self)
        # use PrepateDC to set position correctly
        self.PrepareDC(dc)
        # we need to clear the dc BEFORE calling PrepareDC
        bg = wx.Brush(self.GetBackgroundColour())
        dc.SetBackground(bg)
        dc.Clear()
        self.pdc.DrawToDC(dc)
 
    #---------------------------------------------------------
    def OnMouseMove(self, event):
        hitradius = 5
 
        if event.LeftDown():
            x,y = event.GetPosition()
 
            l = self.pdc.FindObjects(x, y, hitradius)
            for id in l:
                if not self.pdc.GetIdGreyedOut(id):
                    self.dragid = id
                    self.lastpos = (event.GetX(),event.GetY())
                    break
 
        elif event.RightDown():
            x,y = event.GetPosition()
            l = self.pdc.FindObjects(x, y, hitradius)
            if l:
                self.pdc.SetIdGreyedOut(l[0], not self.pdc.GetIdGreyedOut(l[0]))
                r = self.pdc.GetIdBounds(l[0])
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
 
        elif event.Dragging() or event.LeftUp():
            if self.dragid != -1:
                x,y = self.lastpos
                dx = event.GetX() - x
                dy = event.GetY() - y
                r = self.pdc.GetIdBounds(self.dragid)
                self.pdc.TranslateId(self.dragid, dx, dy)
                r2 = self.pdc.GetIdBounds(self.dragid)
                r = r.Union(r2)
                r.Inflate(4,4)
                self.OffsetRect(r)
                self.RefreshRect(r, False)
                self.lastpos = (event.GetX(),event.GetY())
            if event.LeftUp():
                self.dragid = -1
 
    #---------------------------------------------------------
    def OffsetRect(self, r):
        xView, yView = self.GetViewStart()
        xDelta, yDelta = self.GetScrollPixelsPerUnit()
        r.OffsetXY(-(xView*xDelta),-(yView*yDelta))
 
    #---------------------------------------------------------
    def OnAddPions(self, couleur, dc):
            radius = 25
 
            self.pDC = dc
            self.pDC.SetPen(wx.Pen('#d4d4d4'))
 
            if couleur == self.Rouge :
                # Dessine les Pions Rouges
                self.pDC.SetBrush(wx.Brush('#c50024')) # Couleur 'Rouge'
            else :
                # Dessine les Pions verts
                self.pDC.SetBrush(wx.Brush('#1ac500')) # Couleur 'Verte'
 
            self.pDC.BeginDrawing()
            for i in range(1,4):
                id = wx.NewId()
                self.pDC.SetId(id)
                x = random.randint(50, 200)
                y = random.randint(50, 200)
                x1 = x - radius
                y1 = y - radius
                x2 = 2 * radius
                y2 = 2 * radius
                r = wx.Rect(x1,y1,x2,y2)
                self.pDC.DrawCircle(x,y,radius)
                self.pDC.SetIdBounds(id,r)
            self.pDC.EndDrawing()
            return self.pDC
    #---------------------------------------------------------
 
 
class MonApp(wx.App):
    def OnInit(self):
        fen = MyCanvas("Somme de 2 PseudoDC")
        fen.Show(True)
        self.SetTopWindow(fen)
        return True
 
app = MonApp()
app.MainLoop()

Somme de 2 PseudoDC

wxPython

Discussions similaires

Partager

Partager