Récupérer le type de surface avec Pygame

Bonjour à tous,

ça fais un bon moment que je cherche sur le net un peu partout, mais j'ai rien trouvé qui répond vraiment à ma question...

Donc la voici,

je cherche à savoir s'il existe une façon simple et propre pour savoir si une surface est en réalité l'écran elle-même.

un exemple vaut mille mots:

screen = pygame.display.set_mode((800,600)) <-- ça c'est une surface qui est l'écran

frame = pygame.Surface((800,600)) <-- ça c'est une surface normal

Mon problème c'est que je me suis créé une bibliothèque de bouton, label, cadre, champs de texte... qui fonctionne à l'aide de frame(cadre)

Lorsque j'appel un objet de type bouton par exemple, je vais lui dire de ce coller sur une surface, par exemple la surface frame_1, et là, il va
se placer à l'intérieur de celle-ci en prennent en compte l'emplacement de cette surface sur l'écran. Je fais ceci en utilisant le Rect de la surface.

Pour rappel, toute surface obtient automatiquement un Rect lorsqu'elle est créé, sauf l'écran.
Pour obtenir le Rect de l'écran je dois obtenir sa surface : pygame.display.get_surface() puis après je peux aller chercher sont Rect

Sauf que si j'essaie d'aller chercher la surface de l'écran et que ce n'est pas l'écran mais une surface normal, mon code plante.
J'ai bien réussi quand même à me débrouiller avec des try: et except: mais je trouve ça mal propre un peu.

Donc, existe t'il une façon simple de savoir si c'est l'écran ou une surface normal, ou encore mieux de récupérer le Rect de tout les types de
surface.

Merci.

Citation:

Envoyé par PascalStl

Pour rappel, toute surface obtient automatiquement un Rect lorsqu'elle est créé, sauf l'écran.

tu as vu ça où ? Tout au plus les subsurfaces ont un offset par rapport à la surface parent.

Citation:

Envoyé par PascalStl

Sauf que si j'essaie d'aller chercher la surface de l'écran et que ce n'est pas l'écran mais une surface normal, mon code plante.

que veux-tu dire par "aller chercher" ?

Citation:

Envoyé par PascalStl

Donc, existe t'il une façon simple de savoir si c'est l'écran ou une surface normal

Code:

ma_frame is pygame.display.get_surface() ?

Et bien j'ai vue sa dans la doc de pygame. pygame.Surface.get_rect() c'est qui veut dire que d'une façon ou d'une autre, il y a un Rect dans l'objet non?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #Bout du code si le cadre (self.master) n'est pas l'écran, si c'est l'écran on récupère l'exception soulevé par self.master.rect (il n'a pas d'attribue .rect) try: x, y, w, h = self.rect #rect de l'objet x2, y2, _, _ = self.master.rect #rect de la surface ou l'on colle l'objet relativeRect = pygame.Rect(x+x2, y+y2, w, h) #Calcul de l'offset if relativeRect.collidepoint(coord): fais quelque chose... #Si c'est l'écran, pas de calcul d'offset puisque le point en haut à gauche sera 0,0 except: if self.rect.collidepoint(coord): fais quelque chose...
En gros, je voulais savoir s'il n'a pas une façon de faire plus simple :?
Gardez en tête que je suis très très débutant :P

Si c'est pas asser clair je peux mettre le code de mon module en entier, il est fonctionnel mais pas très propre encore

Citation:
Envoyé par PascalStl
Et bien j'ai vue sa dans la doc de pygame. pygame.Surface.get_rect() c'est qui veut dire que d'une façon ou d'une autre, il y a un Rect dans l'objet non?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #Bout du code si le cadre (self.master) n'est pas l'écran, si c'est l'écran on récupère l'exception soulevé par self.master.rect (il n'a pas d'attribue .rect) try: x, y, w, h = self.rect #rect de l'objet x2, y2, _, _ = self.master.rect #rect de la surface ou l'on colle l'objet relativeRect = pygame.Rect(x+x2, y+y2, w, h) #Calcul de l'offset if relativeRect.collidepoint(coord): fais quelque chose... #Si c'est l'écran, pas de calcul d'offset puisque le point en haut à gauche sera 0,0 except: if self.rect.collidepoint(coord): fais quelque chose...
En gros, je voulais savoir s'il n'a pas une façon de faire plus simple :?
Gardez en tête que je suis très très débutant :P

Si c'est pas asser clair je peux mettre le code de mon module en entier, il est fonctionnel mais pas très propre encore
Je suis dans la même situation que la tienne "débutant en quête de savoir " , sauf que toi , t'as mieux fait ta présentation ,moi, j'avais dit que j'étais un bébé en python :mouarf:

pygame.Surface.get_rect() retourne un Rect tiré des dimensions de la surface.

ensuite, pygame.Surface.subsurface peut correspondre à ce que tu veux faire.
envoies quand même le module.

Je vous mets le module. Il possède 4 objets soit un pour les Frames, un pour les Labels, un pour les Boutons et un pour les Champs de texte.

Comme je vous disais, c'est un code de débutant et pas vraiment uniforme car je rajoutais des choses au fur et à mesure.

J'ai quand même essayé de garder une logique. J'ai également essayé de faire de l'héritage en créant une classe maître car beaucoup d’attributs
et de fonctions se répètent mais ça ne marchait jamais... J'avais toutes sortes d'erreurs. Mais ça c'est un autre problème :P

Pour utiliser le module, il faut l'importer ;) , ensuite créer un objet du type que l'on veut en lui donnant (obligatoire) la surface sur laquelle on veut le voir
(ça peut-être l'écran lui-même ou bien une autre surface), puis lui passer les attributs que l'on veut (facultatif). Puis plus loin, on le blit sur l'écran en
appelant sa méthode .display(). Si vous avez beaucoup d'objets, vous pouvez stocker tous les objets dans une liste et appeler la méthode display()
à travers une boucle for. Ça fait plus clean.

Si certains se sentent en forme, vous pouvez améliorer le code et le poster, ça me permettra d'apprendre de vrais pros :D

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
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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
 
#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
#---Importation des modules
try:
    import pygame
except ImportError as err:
    print("Impossible de charger le module: ", err)
    print("Sortie forcé du systeme")
 
#---Class
class Frame(pygame.Surface):
 
    def __init__(self, master, **kwarg):
 
        self.width = 1
        self.height = 1
        self.coord = (0,0)
        self.color = (0,0,0)
        self.border = None
        self.borderColor = (0,0,0)
        self.visible = True
 
        for key in kwarg:
            if key == "width": self.width = kwarg[key]
            elif key == "height": self.height = kwarg[key]
            elif key == "coord": self.coord = kwarg[key]
            elif key == "color": self.color = kwarg[key]
            elif key == "border": self.border = kwarg[key]
            elif key == "borderColor": self.borderColor = kwarg[key]
            elif key == "visible": self.visible = kwarg[key]
            else: raise ValueError("Invalid Argument")
 
        pygame.Surface.__init__(self, (self.width, self.height))
 
        self.master = master
 
        self.rect = self.get_rect()
        self.rect.move_ip(self.coord)
 
    def collide(self, mouse):
 
        if self.rect.collidepoint(mouse):
            return True
        else:
            return False
 
    def changePlace(self, coord):
 
        self.rect.x = 0
        self.rect.y = 0
        self.rect.move_ip(coord)
 
    def move(self, motion):
 
        self.rect = self.rect.move(motion)
 
    def display(self):
 
        if not self.visible:
            self.set_colorkey(self.color)
        else:
            self.set_colorkey(None)
 
        self.master.blit(self, self.rect)
 
        self.fill(self.color)
 
        if self.border:
            pygame.draw.rect(self, self.borderColor,
                            ((0,0), (self.width, self.height)),
                            self.border)
 
class Label(pygame.Surface):
 
    def __init__(self, master, **kwarg):
 
        self.width = 1
        self.height = 1
        self.fontSize = 20
        self.coord = (0,0)
        self.colorText = (0,0,0)
        self.text = ""
        self.orientation = "left"
        self.timer = 0
 
        for key in kwarg:
            if key == "width": self.width = kwarg[key]
            elif key == "height": self.height = kwarg[key]
            elif key == "fontSize": self.fontSize = kwarg[key]
            elif key == "coord": self.coord = kwarg[key]
            elif key == "colorText": self.colorText = kwarg[key]
            elif key == "text": self.text = kwarg[key]
            elif key == "orientation": self.orientation = kwarg[key]
            else: raise ValueError("Invalid Argument")
 
        pygame.Surface.__init__(self, (self.width, self.height))
 
        self.master = master
 
        self.font = pygame.font.Font(None, self.fontSize)
        self.message = self.font.render(self.text, 1, self.colorText)
        self.rect = self.message.get_rect()
 
        if self.orientation == "left":
            self.rect.move_ip(self.coord)
        elif self.orientation == "right":
            self.rect.move_ip(self.coord[0]-self.rect.width, self.coord[1])
 
    def changePlace(self, coord):
 
        self.rect.x = 0
        self.rect.y = 0
        if self.orientation == "left":
            self.rect.move_ip(self.coord)
        elif self.orientation == "right":
            self.rect.move_ip(self.coord[0]-self.rect.width, self.coord[1])
 
    def move(self, motion):
 
        self.rect = self.rect.move(motion)
 
    def changeColor(self, color):
 
        self.colorText = color
        self.message = self.font.render(self.text, 1, self.colorText)
 
    def flashColor(self, delay, color1, color2):
 
        if self.timer <= delay:
            self.changeColor(color1)
        elif self.timer > delay and self.timer <= delay*2:
            self.changeColor(color2)
        else:
            self.timer = 0
        self.timer += 1
 
    def changeSize(self, size):
 
        self.fontSize = size
        self.font = pygame.font.Font(None, self.fontSize)
        self.message = self.font.render(self.text, 1, self.colorText)
        self.rect = self.message.get_rect()
 
        if self.orientation == "left":
            self.rect.move_ip(self.coord)
        elif self.orientation == "right":
            self.rect.move_ip(self.coord[0]-self.rect.width, self.coord[1])
 
    def changeText(self, text):
 
        self.text = text
        self.message = self.font.render(self.text, 1, self.colorText)
        self.rect = self.message.get_rect()
 
        if self.orientation == "left":
            self.rect.move_ip(self.coord)
        elif self.orientation == "right":
            self.rect.move_ip(self.coord[0]-self.rect.width, self.coord[1])
 
    def display(self):
 
        self.master.blit(self.message, self.rect)
 
class Botton(pygame.Surface):
    """Crée un bouton poussoir"""
 
    def __init__(self, master, **kwarg):
        """Constructeur
           master = surface d'affichage
           width = largeur
           height = hauteur
           coord = (x, y)
           text = texte à afficher
           textSize = taille du texte
           bgColor = couleur de fond
           textColor = couleur du texte"""
 
        self.master = master
        width = 60
        height = 25
        coord = (0,0)
        self.text = "OK"
        textSize = 18
        self.bgColor = (255,255,255)
        self.textColor = (0,0,0)
 
        for key in kwarg:
            if key == "width": width = kwarg[key]
            elif key == "height": height = kwarg[key]
            elif key == "coord": coord = kwarg[key]
            elif key == "text": self.text = kwarg[key]
            elif key == "textSize": textSize = kwarg[key]
            elif key == "bgColor": self.bgColor = kwarg[key]
            elif key == "textColor": self.textColor = kwarg[key]
            else: raise ValueError("Argument invalide")
 
        pygame.Surface.__init__(self, (width, height)) 
 
        self.surface = pygame.Surface((width, height))
        self.rect = self.surface.get_rect()
        self.rect.move_ip(coord)
 
        self.bgColorCopy = self.bgColor #mémoire pour les changement de couleur
                                        #lorsque l'on clique sur le bouton
 
        self.font = pygame.font.Font(None, textSize)
        self.message = self.font.render(self.text, 1, self.textColor)
        w, h = self.font.size(self.text)
        self.position = (self.rect.width/2-w/2, self.rect.height/2-h/2) #centrage du texte
 
    def clickOn(self, coord):
        """Vérifie si l'on a cliquer sur le bouton et retourne une confirmation"""
 
        action = False
 
        #Essaie de loader le rect de la surface, si c'est impossible
        #c'est que la surface c'est le display(l'écran elle-même), donc
        #pas besoin de mesurer la position relative
        try:
            x, y, w, h = self.rect
            x2, y2, _, _ = self.master.rect
 
            relativeRect = pygame.Rect(x+x2, y+y2, w, h)
 
            if relativeRect.collidepoint(coord):
                action = True
 
                #Inverse la couleur du texte avec celle du fond
                self.message = self.font.render(self.text, 1, self.bgColor)
                self.bgColorCopy = self.textColor
        except:
            if self.rect.collidepoint(coord):
                action = True
 
                #Inverse la couleur du texte avec celle du fond
                self.message = self.font.render(self.text, 1, self.bgColor)
                self.bgColorCopy = self.textColor
 
        return action
 
    def reset(self):
        """Déclique le bouton"""
 
        self.bgColorCopy = self.bgColor
        self.message = self.font.render(self.text, 1, self.textColor)
 
    def display(self):
        """Affichage"""
 
        self.surface.fill(self.bgColorCopy)
        self.surface.blit(self.message, self.position)
        self.master.blit(self.surface, self.rect)
 
class Text(pygame.Surface):
    """Crée une zone de texte dans laquelle on peut écrire"""
 
    def __init__(self, master, **kwarg):
        """Constructeur
           master = surface d'affichage
           width = largueur
           height = hauteur
           coord = (x, y)
           text = text par défaut
           textSize = taille du texte
           bgColor = couleur de fond
           textColor = couleur du texte"""
 
        self.master = master
        width = 150
        height = 25
        coord = (0,0)
        self.text = "Tape votre texte ici"
        textSize = 18
        self.bgColor = (255,255,255)
        self.textColor = (0,0,0)
        self.illegalCharacter = ""
        self.timeFlash = 50
 
        for key in kwarg:
            if key == "width": width = kwarg[key]
            elif key == "height": height = kwarg[key]
            elif key == "coord": coord = kwarg[key]
            elif key == "text": self.text = kwarg[key]
            elif key == "textSize": textSize = kwarg[key]
            elif key == "bgColor": self.bgColor = kwarg[key]
            elif key == "textColor": self.textColor = kwarg[key]
            elif key == "illegalCharacter": self.illegalCharacter = kwarg[key]
            elif key == "timeFlash": self.timeFlash = kwarg[key]
            else: raise ValueError("Argument invalide")
 
        pygame.Surface.__init__(self, (width, height))
 
        self.surface = pygame.Surface((width, height))
        self.rect = self.surface.get_rect()
        self.rect.move_ip(coord)
 
        self.focus = False
        self.compteur = 0 #timer pour animation
 
        self.font = pygame.font.Font(None, textSize)
        self.message = self.font.render(self.text, 1, self.textColor)
        _, self.h = self.font.size(self.text)
        self.position = (0, self.rect.height/2-self.h/2) #centrage du texte
 
    def clickOn(self, coord):
        """Vérifie si l'on a cliqué sur la zone de text et lui donne
           le focus"""
 
        #Essaie de loader le rect de la surface, si c'est impossible
        #c'est que la surface c'est le display(l'écran elle-même), donc
        #pas besoin de mesurer la position relative
        try:
            x, y, w, h = self.rect
            x2, y2, _, _ = self.master.rect
 
            relativeRect = pygame.Rect(x+x2, y+y2, w, h)
 
            if relativeRect.collidepoint(coord):
                self.focus = True
                self.text = "" #efface tout dans la zone de texte
                self.message = self.font.render(self.text, 1, self.textColor)
            else:
                #enleve le focus si l'on clique ailleur
                self.focus = False
        except:
 
            if self.rect.collidepoint(coord):
                self.focus = True
                self.text = "" #efface tout dans la zone de texte
                self.message = self.font.render(self.text, 1, self.textColor)
            else:
                #enleve le focus si l'on clique ailleur
                self.focus = False
 
    def changeText(self, liste):
        """Écris des caractères dans la zone de texte"""
 
        if liste.type == pygame.KEYDOWN:
            #touche return
            if liste.key == 8:
                self.text = self.text[:-1] #efface le dernier caractère
            #touche enter
            elif liste.key == 13 or liste.key == 271:
                self.focus = False
            #touche echap ou tab
            elif liste.key == 27 or liste.key == 9:
                pass
            #toutes les autres touche selon leur unicode
            else:
                autorized = True
                for character in self.illegalCharacter:
                    #vérifie si la lettre n'a pas été interdite
                    if character == liste.unicode:
                        autorized = False
                        break
                if autorized:
                    self.text += liste.unicode
 
        self.message = self.font.render(self.text, 1, self.textColor)
 
    def display(self):
        """Affichage et création d'un curseur qui flash"""
 
        self.surface.fill(self.bgColor)
 
        if self.focus:
            if self.compteur < self.timeFlash:
                #curseur
                x, _ = self.font.size(self.text) #Position en X du curseur
                pygame.draw.rect(self.surface, self.textColor, (x,0,0,self.rect.height))
            elif self.compteur >= self.timeFlash and self.compteur < self.timeFlash*2:
                pass
            else:
                self.compteur = 0
            self.compteur += 1
 
        self.surface.blit(self.message, self.position)
        self.master.blit(self.surface, self.rect)

hériter de Surface pour un système de pseudo-fenêtrage, je vois.
mais pour faire des widgets bouton, texte, etc ... j'hériterai plutôt de Rect.

oui sauf qu'il me faut une surface pour l'affichage, non? Si j’essaie d'afficher un rect je verrais rien dans la fenêtre...

A moins qu'il y est un truc que je connais pas :P