-
Notifications
You must be signed in to change notification settings - Fork 16
/
cairomm.txt
402 lines (330 loc) · 25.8 KB
/
cairomm.txt
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
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
CAIROMM
/=+===============================+=\
/ : : \
)==: GENERAL :==(
\ :_______________________________: /
\=+===============================+=/
BUT ==> #Dessin vectoriel. Portable.
CAIRO ET CAIROMM ==> #Il s'agit du wrapper C++ pour Cairo (C).
#Cairo a aussi des bindings vers Perl, Python, Ruby, Scheme, Smalltalk et Haskell.
#Cairo est utilisé par GTK+ pour dessiner les widgets.
HEADER ==> # <cairomm/cairomm.h>
LIBRARIES ==> #libcairomm-${VERSION}
DEPENDANCES ==> #Cairo, Glib et libsigc++. Utiliser :
# - $(pkg-config cairomm-1.0 --libs --cflags)
PAQUETS ==> #libcairomm-${VERSION} (runtime)
#libcairomm-${VERSION}-dev
NAMESPACE ==> #Cairo::
PANGO ==> #Préférer Pango pour l'affichage de texte.
# - meilleure internationalization
# - support de plus de fonctionnalités par rapport aux polices et aux paragraphes
UTILISATION ==> # - création fichier externe.
# - via Gtkmm : via handler du signal draw de DrawingArea
# - via SFML : utiliser IMAGE.LoadFromPixels(SURFACE.get_data()) avec un FORMAT_ARGB32, à appeler à
# chaque modification de SURFACE, ou changement d'échelle d'IMAGE.
IDEE ==> # - utilise des states (comme opengl)
# - Source (Surface ou Pattern) -> Mask (dont paths) -> Destination (Surface)
COORDONNES ==> #Il s'agit des coordonnées de la SURFACE de Destination.
PATHS OUVERTS ET #Les paths actifs sont les paths actuellement en train d'être dessinés. Les opérations de dessin
ACTIFS ==> #utilisent souvent les paths actifs. fill(), clip() et stroke() désactivent les paths actifs. Leurs
#version avec *_preserve() non : les paths peuvent donc à nouveau être utilisés par une opération de
#dessin.
#Un path ouvert a une fin et un début, un path fermé non.
#Certaines opérations sont reliantes : elles tracent une ligne entre le dernier point du dernier path
#du path actif (s'il y en a un) et le premier point du path dessiné. D'autres non.
#Les paths actifs peut être constitué d'une multitude de paths, fermés ou non.
POSITION COURANTE ==> #Elle est modifiée par les opérations de dessin.
#Cependant, fill(), clip() et stroke() (et non leur version avec *_preserve()) la remettent à zéro, ce
#qui signifie non pas qu'elle est à 0,0, mais qu'il n'y a pas de position courante.
#Le point de référence (matrice courante, translate(), etc.) est lui différent de la position
#courante, et n'est pas affecté par fill(), clip() stroke().
USER ET WORLD #Les user coordonnates sont celles affichées après application de la matrice courante (translate(),
COORDINATES ==> #etc.), les world coordonnates sont celles d'avant.
#Convertir par exemple la line width depuis world coordonnates vers user coordonnates pour avoir une
#line width indépendante de la matrice courante.
#Exemple (le save() et restore() évite d'avoir une line width différente horizontalement et
#verticalement):
# //Le scale est actuellement uniforme
# cr->save();
# cr->scale(scale_x, scale_y); //scale_x != scale_y
# ... //Dessins (hors stroke())
# std::pair <double, double> ln_wid(epaisseur, epaisseur);
# cr->device_to_user_distance(ln_wid.first, ln_wid.second);
# cr->set_line_width(std::min(ln_wid.first, ln_wid.second));
# cr->restore();
# cr->stroke();
/=+===============================+=\
/ : : \
)==: SURFACE :==(
\ :_______________________________: /
\=+===============================+=/
Surface #Base classe représentant une surface (au sens de SDL ou SFML).
#Utilisée comme Destination ou Source par un Context.
#Devrait être utilisés via des REFPTR.
SURFACE.write_to_png #
(STRING) #Enregistre SURFACE au format .png dans le chemin STRING
ImageSurface #Enfant de Surface, représente une Surface avec une hauteur et largueur précise, pour obtenir au final
#un fichier image, ou un array de pixels.
ImageSurface::create #Renvoie un REFPTR<IMAGESURFACE> dont la hauteur est INT_VAL pixels, la largeur INT_VAL2 pixels,
(FORMAT, INT_VAL, #et le format FORMAT, parmi : FORMAT_{ARGB32,RGB24,A8,A1,RGB16_565} (RGBA, RGB, Alpha (8 puis 1 bit/
INT_VAL2) #pixel), RGB (16 bits/pixel, 5 pour R et B, 6 pour G))
ImageSurface::
create_from_png(STRING) #Renvoie une copie du fichier .png dont le chemin est STRING, sous forme de REFPTR<IMAGESURFACE>
IMAGESURFAC.get_height()#Renvoie la hauteur d'IMAGESURFACE.
IMAGESURFACE.get_width()#Renvoie la largeur d'IMAGESURFACE.
IMAGESURFAC.get_format()#Renvoie le FORMAT d'IMAGESURFACE.
IMAGESURFACE.get_data() #Renvoie les pixels d'IMAGESURFACE sous forme d'une array UCHAR_ADR (1 pixel = 4 UCHAR_VAL si le
#format est FORMAT_ARGB32).
SvgSurface #Enfant de Surface, représente une Surface .svg.
SvgSurface::create #Renvoie un REFPTR<SVGSURFACE>, qui sera sauvegardé au chemin STRING, avec une dimension
(STRING, DOUBLE_VAL, #DOUBLE_VAL * DOUBLE_VAL2, par le destructor de SVGSURFACE.
DOUBLE_VAL2) #La taille est aussi la taille de la SURFACE qui sera utilisée lors des opérations de dessin et autres.
#Sinon, le .svg produit n'est pas rasterisé, quelque soit la dimension indiquée (sauf les images
#insérées via create_from_png() par exemple)
PdfSurface #Enfant de Surface, représente une Surface .pdf. Mêmes membres que SvgSurface, avec en plus :
PDFSURFACE.set_size #
(DOBLE_VAL1, DOBLE_VAL2)#Modifie la dimension indiquée lors de l'instantiation.
PsSurface #Enfant de Surface, représente une Surface .ps. Mêmes membres que PdfSurface.
/=+===============================+=\
/ : : \
)==: PATTERN :==(
\ :_______________________________: /
\=+===============================+=/
Pattern #Base classe pour Gradient, SolidPattern et SurfacePattern, destinés à être utilisés comme Source d'un
#CONTEXT.
PATTERN.get_type() #Renvoie le type de PATTERN sous forme de PATTERNTYPE, parmi PATTERN_TYPE_{SOLID,SURFACE,LINEAR,RADIAL}
Gradient #Désigne un dégradé, utilisé comme Source d'un CONTEXT.
#Enfant de Patter, base classe pour LinearGradient et RadialGradient.
GRADIENT.
add_color_stop_rgba #Ajoute une couleur à GRADIENT, à son offset DOUBLE_VAL1 (0 pour le début, 1 pour la fin), dont les
(DOBLE_VAL1, 4 DOBLE_VL)#valeurs RGBA sont désignées par les quatres paramètres suivants.
GRADIENT.
add_color_stop_rgb #
(DOBLE_VAL1, 3 DOBLE_VL)#Comme add_color_stop_rgba(), sauf que l'alpha est par défaut opaque.
GRADIENT. #Renvoie les couleurs de GRADIENT sous forme de STD::VECTOR<COLORSTOP>
get_color_stops() #COLORSTOP est une struct avec les membres .offset (offset de 0 à 1), .red, .green, .blue et .alpha
LinearGradient #Enfant de Gradient, désigne un dégradé linéaire.
LinearGradient::create #Renvoie un REFPTR<LINEARGRADIENT> avec un dégradé allant des deux premiers coordonnées aux
( 4 DOUBLE_VAL ) #deux derniers.
LINEARGRADIENT.
get_linear_points #
( 4 DOUBLE_VAL ) #Renvoie les paramètres utilisés lors de l'instantiation via LinearGradient::create()
RadialGradient #Enfant de Gradient, désigne un dégradé radial.
RadialGradient::create #Renvoie un REFPTR<RADIALGRADIENT> avec un dégradé allant d'un premier cercle dont le centre est
(DOBLE_VAL1, DOBLE_VAL2,#désigné par les deux premiers coordonnées et dont le rayon de DOUBLE_VAL3 pixels, à un second centre
DOUBLE_VAL3, DOBLE_VAL4,#est désigné par les deux coordonnées suivants et dont le rayon de DOUBLE_VAL6 pixels.
DOUBLE_VAL5, DOBLE_VAL6)#Le début du dégradé ne commence qu'aux frontières du premier cercle, et s'arrête aux frontières du
#second.
#Le premier centre doit être contenu dans le second cercle.
RADIALGRADIENT.
get_radial_circles #
( 6 DOUBLE_VAL ) #Renvoie les paramètres utilisés lors de l'instantiation via RadialGradient::create()
SurfacePattern #Enfant de Pattern. Désigne une SURFACE, utilisée comme Source d'un CONTEXT
SurfacePattern::create #
(REFPTR_VAR<SURFACE>) #Renvoie un REFPTR<SURFACEPATTERN> associé à SURFACE.
SURFCPTRN.{s,g}et_extend#Modifie la manière de SURFACEPATTERN de se répéter parmi : EXTEND_{NONE,REPEAT,REFLECT,PAD} (sinon
(EXTEND) #NONE). REFLECT donne une symétrie verticlae pour chaque répétition verticale. PAD : ne comprends pas.
SURFCPTRN.{s,g}et_filter#Modifie la manière de SURFACEPATTERN d'être agrandie par un scale() ou autre, parmi :
(FILTER) #FILTER_{FAST,GOOD,BEST,NEAREST,BILINEAR,GAUSSIAN}
SRFACPATRN.get_surface()#Renvoie la REFPTR_VAR<SURFACE> utilisée lors de l'instantiation via SurfacePattern::create()
SolidPattern #Désigne une couleur, utilisée comme Source d'un CONTEXT
SolidPattern::
create_rgba(4 DOUBL_VAL)#Renvoie un REFPTR<SOLIDPATTERN> associé à la couleur RGBA définie par les quatres paramètres.
SolidPattern::create_rgb#
( 3 DOUBLE_VAL ) #Même chose, avec un alpha opaque.
SOLIDPATTERN.get_rgba #
( 4 DOUBLE_VAL ) #Renvoie les paramètres passés lors de l'instantiation via SolidPattern::create*()
/=+===============================+=\
/ : : \
)==: CONTEXT :==(
\ :_______________________________: /
\=+===============================+=/
Context #Contexte. Enregistre les states courants, dont :
# - la Source (PATTERN (dont couleur unie))
# - le Mask (au départ aucun Mask)
# - la Destination (SURFACE modifiée au fur et à mesure des stroke(), fill(), etc.)
#Les "coordonnées" sont celles de la SURFACE de la Destination, plus précisément de son point de
#référence (0,0 pour le coin supérieur gauche au départ), qui peut subir des rotations, translations
#et mises à échelle, comme en OpenGL.
#Utiliser get_height() et get_width() pour adapter à la taille de la SURFACE si IMAGESURFACE.
Context::create #
(REFPTR_VAR<SURFACE>) #Renvoie un REFPTR<CONTEXT> dont la Destination est SURFACE.
CONTEXT.set_source_rgba #
( 4 DOUBLE_VAL ) #La Source de CONTEXT devient la couleur RGBA définie par les quatres paramètres.
CONTEXT.set_source_rgb #
( 3 DOUBLE_VAL ) #Même chose, avec un alpha opaque.
CONTEXT.set_source #
(REFPTR_VAR<SURFACE>, #La Source de CONTEXT devient SURFACE, décalée vers la
DOUBLE_VAL1, DOBLE_VAL2)#droite et le bas de DOBLE_VAL1 et DOBLE_VAL2 pixels.
CONTEXT.{s,g}et_source #
(REFPTR_VAR<PATTERN>) #La Source de CONTEXT devient PATTERN.
CONTEXT.paint() #Remplit la Destination de CONTEXT de la Source (sans application du Mask)
CONTEXT.paint_with_alpha#
(DOUBLE_VAL1) #Comme paint(), mais multiplie la transparence de la Source par DOBLE_VAL1 avant.
CONTEXT.fill() #Désactive et ferme les paths actifs, et remplit la Destination de CONTEXT de la Source (après
#application du Mask dessiné par les paths actifs)
CONTEXT.stroke() #Remplit la Destination de CONTEXT de la Source (après application du Mask définit par un contour
#autour des paths du Mask, en fonction de la line width, line join, line cap et dash settings de
#CONTEXT).
#Désactive les paths actifs.
CONTEXT.fill_preserve() #
COTEXT.stroke_preserve()#Même chose mais ne désactive pas les paths actifs.
CONTEXT.mask(SURFACE, #Remplit la Destination de CONTEXT de la Source, après application de la transparence de SURFACE, et
DOBLE_VAL1, DOUBLE_VAL2)#après avoir déplacé, le temps de l'appel, SURFACE de DOUBLE_VAL1 pixels vers la droite, et de
#DOUBLE_VAL2 vers le bas.
COTEXT.show_text(STRING)#Remplit la Destination de CONTEXT d'un message écrit à la position courante (coin inférieur gauche),
#avec la police courante et la taille de police courante.
CONTEXT.clip() #Désactive et ferme les paths actifs, et définit une clip region, définie comme l'intérieur des paths
#actifs, et leur éventuelle intersection avec la clip region actuelle s'il y en a une.
#Désormais, la Destination de CONTEXT ne pourra plus être mise à jour qu'à l'intérieur de cette clip
#region.
#Pour supprimer la clip region, faire appel à reset_clip(), ou à save() et restore() (préférer cette
#dernière solution).
#Si, et seulement si, la clip region est rectangulaire, cela peut améliorer les performances.
CONTEXT.clip_preserve() #Même chose mais ne désactive pas les paths actifs.
CONTEXT.reset_clip() #Supprime la clip region courante s'il y en a une.
CONTEXT.
copy_clip_rectangle_list#Copie la clip region courante dans VECTOR<RECTANGLE>.
(VECTOR<RECTANGLE>) #RECTANGLE est une struct dont les membres sont .x, .y, .width et .height
CONTEXT.get_clip_extents#
( 4 DOUBLE_VAL ) #Renvoie le coin supérieur gauche et inférieur droit de la clip region courante dans les paramètres.
CONTEXT.get_path_extents#
( 4 DOUBLE_VAL ) #Même chose pour la bounding box des paths actifs.
CONTEXT.get_fill_extents#
( 4 DOUBLE_VAL ) #Comme get_path_extents(), mais ne prend en compte que les paths actifs fermés.
COTET.get_stroke_extents#Comme get_path_extents(), mais prend aussi en compte la line width, la line join, la line cap et les
( 4 DOUBLE_VAL ) #pointillés.
CONTEXT.in_fill #
(DOBLE_VAL1, DOBLE_VAL2)#Renvoie true si le point aux coordoonées indiquées se trouve dans l'un path fermés des paths actifs.
CONTEXT.in_stroke #Même chose, mais renvoie true aussi si le point ne se trouve pas dans un path, mais sur l'un de ses
(DOBLE_VAL1, DOBLE_VAL2)#bords tel que dessiné par stroke() (en fonction de la line width, etc.)
CONTEXT.in_clip #
(DOBLE_VAL1, DOBLE_VAL2)#Même chose, pour le clip.
CONTXT.{s,g}et_fill_rule#Modifie la manière pour clip() et fill() de considérer
(FILLRULE) #qu'une zone est comprise dans un path, parmi : FILL_RULE_WINDING (si elle est entourée par un path
#(défaut) ou FILL_RULE_EVEN_ODD (si un path est overlapped par un autre ou par lui-même un nombre
#impair de fois, la zone est considérée comme en dehors du path).
COTEXT.get_current_point#
(DOBLE_VAL1, DOBLE_VAL2)#Renvoie la position courante dans les deux paramètres (0,0 s'il n'y a pas de position courante).
COTEXT.
has_current_point() #Renvoie false s'il n'y a pas de position courante.
CONTEXT.rectangle #Ajoute aux paths actifs un path fermé rectangulaire non-reliant dont les coordoonées du point
( 4 DOUBLE_VAL ) #supérieur gauche sont DOUBLE_VAL1 et DOUBLE_VAL2 (qui devient la position courante), la largeur
#DOUBLE_VAL3 et la hauteur DOUBLE_VAL4.
CONTEXT.arc #Ajoute au Masque un path ouvert reliant en forme d'arc de cercle dont les coordoonées sont :
( 5 DOUBLE_VAL ) # - centre : DOUBLE_VAL1,DOUBLE_VAL2
# - rayon : DOUBLE_VAL3
# - début et fin de l'arc (angle, en radian) : DOUBLE_VAL4 et DOUBLE_VAL5 (0 et 2 * M_PI dessine
# donc un cercle) (0 est l'angle 90 degrés vers la droite)
CONTEXT.arc_negative #
( 5 DOUBL_VAL ) #Même chose, sauf que l'arc est counter-clockwise et non clockwise.
CONTEXT.move_to #Fait que la position courante devient DOUBLE_VAL,DOBLE_VAL2 (position absolue), et que la prochaine
(DOUBLE_VAL, DOBLE_VAL2)#opération de dessin, si reliante, sera considérée non-reliante.
CONTEXT.
begin_new_sub_path() #Fait que la prochaine opération de dessin, si reliante, sera considérée non-reliante.
CONTEXT.begin_new_path()#Même chose, mais supprime en plus les paths actifs.
CONTEXT.line_to #Ajoute aux paths actifs un path ouvert reliant formé d'une ligne allant de la position courante à
(DOUBLE_VAL, DOBLE_VAL2)#DOUBLE_VAL,DOUBLE_VAL2 cette dernière devenant la nouvelle position courante.
CONTEXT.curve_to #Ajoute aux paths actifs un path ouvert reliant formé d'une courbe allant de la position courante à
( 6 DOUBLE_VAL ) #DOUBLE_VAL5,DOBLE_VAL6, cette dernière devenant la nouvelle position courante.
#DOUBLE_VAL,DOBLE_VAL2 et DOUBLE_VAL3,DOUBLE_VAL4 sont les coordonnées des deux points de contrôle du
#nouveau segment (le point de contrôle attaché au précédent sommet, puis le sien)
CONTEXT.rel_*_to( ... ) #Comme *_to( ... ), sauf que la position est relative par rapport à la position courante.
#Un move_to() ou une opération de dessin doit avoir eu lieu sur le path actif.
CONTEXT.close_path() #Si le dernier path des paths actifs est actuellement ouvert, le ferme en rajoutant une ligne entre
#ses deux bouts.
COTEXT.text_path(STRING)#Ajoute aux paths actifs un ensemble de paths fermés non-reliants tels que formé par l'écriture du
#message STRING, à la position courante, avec la police courante et la taille de police courante.
#La position courante devient la coin inférieur droit de l'ensemble de paths ainsi dessinés.
#Préférer show_text(), plus performant.
CONTEXT.copy_path() #Renvoie le path actif sous forme de PATH_ADR.
CONTXT.append_path(PATH)#Rajoute PATH aux paths actifs.
CONTEXT.
{s,g}et_line_width #La line width de CONTEXT devient DOUBLE_VAL (par défaut 2)
CONTEXT.[un]{s,g}et_dash#Définit des pointillés pour CONTEXT, si stroke() est utilisé. VECTOR<DOUBLE> est une suite de nombre
(VECTOR<DOUBLE>, #positifs, répétée indéfiniment si besoin est, et désignant la longueur de chaque pointillé, vide et
DOUBLE_VAL) #plein de manière alternée.
#DOUBLE_VAL déplace les pointillés sans modifier leur pattern fondamental.
#Marche aussi avec un VALARRAY<DOUBLE>
CONTEXT.{s,g}et_line_cap#Modifie la manière avec laquelle les deux bouts d'un chemin ouvert sont dessinés, parmi :
(LINECAP) #LINE_CAP_{BUTT,SQUARE,ROUND} (sinon BUTT).
CONTXT.{s,g}et_line_join#Modifie la manière avec laquelle les différentes lignes d'un même chemin sont acrochées les unes aux
(LINEJOIN) #autres (si leur pivots (c-a-d les sommets du chemin) sont arrondis ou non), parmi :
#LINE_JOIN_{MITER,ROUND,BEVEL} (sinon MITER)
CONTEXT.select_font_face#Modifie la police courante (son chemin est STRING). FONTSLANT parmi :
(STRING, FONTSLANT, #FONT_SLANT_{NORMAL,ITALIC,OBLIQUE}.
FONTWEIGHT) #FONTWEIGHT parmi : FONT_WEIGHT_{NORMAL,BOLD}
CONTEXT.set_font_size #
(DOUBLE_VAL) #Modifie la taille de police courante (pixels).
CONTXT.{s,g}et_tolerance#Modifie la qualité des courbes de Bézier (défaut 0.1).
(DOUBLE_VAL) # < 0.1 ne change pas grand'chose ; > 0.1 donne de meilleures performances, mais un aspect polygonal
#aux courbes de Bézier.
CONTEXT.{s,g}et_operator#Modifie la manière avec laquelle chaque opération de dessin est imprimée/fusionnée sur la Destination.
(OPERATOR) #OPERATOR parmi (la Dest est l'ancienne SURFACE, la Source est ce qu'on lui ajoute) :
# - OPERATOR_OVER : Source au dessus de Dest (defaut)
# - OPERATOR_SOURCE : Dest supprimé, et Source affichée.
# - OPERATOR_IN : Dest supprimé, et Source affichée, mais gommée par la transparence de Dest.
# - OPERATOR_OUT : Dest supprimé, et Source affichée, mais gommée par l'opacité de Dest.
# - OPERATOR_ATOP : Source affichée au dessus de Dest, mais gommée par la transparence de Dest.
# - OPERATOR_DEST_OVER :
# - OPERATOR_DEST :
# - OPERATOR_DEST_IN :
# - OPERATOR_DEST_OUT :
# - OPERATOR_DEST_ATOP : Comme les cinq précédents, mais avec Source et Dest inversés.
# - OPERATOR_XOR : Source affichée mais, là où ils sont tous deux opaques, cela est gommé.
# - OPERATOR_ADD : Comme mode de fusion Add de Photoshop
# - OPERATOR_SATURATE : Comme mode de fusion Saturate de Photoshop
# - OPERATOR_CLEAR : Source + Dest supprimés.
CONTEXT.save() #Push CONTEXT au sommet d'un stack prévu pour.
CONTEXT.restore() #Pop le dernier CONTEXT du CONTEXT-stack, et remplace CONTEXT par celui-ci.
CONTEXT.translate #
(DOBLE_VAL1, DOBLE_VAL2)
CONTEXT.scale #
(DOBLE_VAL1, DOBLE_VAL2)
CONTEXT.rotate #
(DOBLE_VAL1) #Effectue une translation, mise à l'échelle ou rotation du point de référence des paths actifs, comme
CONTEXT.rotate_degrees #en OpenGL, affectant les prochaines opérations.
(DOBLE_VAL1, DOBLE_VAL2)#rotate() est en radian.
CONTEXT.device_to_user #
(DOBLE_VAL1, DOBLE_VAL2)#Convertit les coordonnées DOBLE_VAL1,DOBLE_VAL2 de world vers user coordonnates (en les modifiant).
CONTEXT.
device_to_user_distance #Même chose, sauf que les paramètres sont un vecteur (distance) et non les coordonnées d'un point (la
(DOBLE_VAL1, DOBLE_VAL2)#translation n'est donc pas prise en compte dans la matrice)
CONTEXT.user_to_device* #Pareil, mais dans l'autre sens.
CONTEXT.{s,g}et_aliasing#Modifie l'antialiasing de CONTEXT parmi : ANTIALIASING_{DEFAULT,NONE,GRAY,SUBPIXEL}. GRAY est normal,
(ANTIALIASING) #SUBPIXEL meilleur, mais pas encore implémenté. DEFAULT est GRAY.
/=+===============================+=\
/ : : \
)==: AUTRES :==(
\ :_______________________________: /
\=+===============================+=/
RefPtr<WVAL> #Réference-counting, shared smart pointer
Region #Permet de faire des union, intersections, xor, soustraction de RectangleInt (comme Rectangle, mais
#utilise des ints, non des doubles)
Region::create
( [RECTANGLEINT] )
Region::create #
( VECTOR<RECTANGLEINT> )#Crée une REFPTR<REGION> à partir de l'union du ou des RECTANGLEINT.
REGION.intersect
( REFPTR<REGION2> )
REGION.intersect #
( RECTANGLEINT ) #REGION devient l'intersection de lui-même et de l'argument.
REGION.substract( ... ) #
REGION.do_union( ... ) #
REGION.do_xor( ... ) #Même chose pour la soustraction, l'union et le xor.
REGION.translate #
( INT_VAL1, INT_VAL2 ) #Déplace REGION.
REGION.
get_num_rectangles() #Renvoie le nombre de RECTANGLEINT de REGION.
REGION.get_rectangle #
( INT_VAL ) #Renvoie le RECTANGLEINT numéro INT_VAL.
REGION.get_extents() #Renvoie la bounding box de REGION sous forme de RECTANGLEINT.
REGION.contains_point #
( INT_VAL, INT_VAL2 ) #Renvoie true si le point désigné par les arguments est compris dans REGION.
REGIN.contains_rectangle#Check si RECTANGLEINT est compris non, partiellement ou totalement dans REGION, et renvoie en
( RECTANGLEINT ) #conséquence REGIONOVERLAP, parmi : REGION_OVERLAP_{IN,OUT,PART}
REGION.empty() #Renvoie true si REGION est vide.
REGION.copy() #Renvoie une copie de REGION sous forme de REFPTR<REGION>
THREAD-SAFETY #Cf classes Device et Device::Lock