cairomm.txt

             
   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