gdkmm.txt

           
   GDKMM   
           

BUT ==>                 #Low-level graphics et events (par exemple sous Linux, interaction avec X)

GTKMM ==>               #Partie intégrante de Gtkmm : cf Gtkmm pour informations.
                        #Séparément :
                        #  - GDK-Pixbuf : pour les Pixbuf :
                        #     - <gdk-pixbuf/gdk-pixbuf.h>
                        #  - reste : <gtk/gdk.h>
                        #  - Pour les deux : $(pkg-config gdk[mm]-VERSION --cflags --libs)

NAMESPACE ==>           #Le namespace de ce chapitre est Gdk::

HIERARCHIE ==>          #Si rien marqué :
                        #  - enfant de rien en C++ et enfant de GBoxed pour C : Rectangle, RGBA, PixbufFormat, Event
                        #  - enfant de rien en C++ et C : Color, Point, TimeCoord
                        #  - enfant de Glib::Object en C++ et enfant de GObject en C

Window                  #Désigne une zone rectangulaire sur l'écran, sous-jacent à tout GTK::WIDGET.
                        #Permet notamment de dessiner avec Cairo sur une fenêtre.
                        #Le parent d'une toplevel WINDOW est le bureau lui-même ("root window")
                        #La WINDOW toplevel n'inclue pas les décorations : donc par exemple, la rendre transparente n'affecte
                        #pas les décorations, et les coordonnées ne les incluent pas non plus.
                        #Pour le drag&drop : cf Gtkmm, chapitre Drag&Drop
Window::get_
default_root_window()   #Renvoie la root REFPTR<WINDOW>
.show()                 #Cf GTK::WINDOW
.hide()                 #Cf GTK::WINDOW
.show_unraised()        #Comme show(), mais n'effectue pas de raise()
.is_visible()           #
.raise()                #
.lower()                #
.stack( REFPTR<WINDOW2>,#
BOOL_VAL )              #Dans le raise-stack, place WINDOW au-dessus (si true) ou en-dessous (si false) de WINDOW2.
.focus( UINT32 )        #Donne le focus quand le timestamp sera UINT32_VAL
.accept_focus([BOOLVAL])#Peut avoir le focus (si false, interaction encore possible avec par exemple les boutons, mais pas 
                        #les Entry).
.set_focus_on_map       #
( [BOOL_VAL] )          #Si true, donne le focus dès que mapped (défaut true) (sinon true)
                        #les Entry).

.beep()                 #Cf DISPLAY.beep()
.[de]iconify()          #
.[un]maximize()         #
.[un]fullscreen()       #
.[un]stick()            #Sur tous les bureaux.
.set_keep_{above,below} #
( [BOOL_VAL] )
.set_skip_taskbar_hint  #
( [BOOL_VAL] )          #Enlève de la taskbar (défaut true) (sinon false)
.set_skip_pager_hint    #
( [BOOL_VAL] )          #Pareil mais pour le pager (par exemple fonction Expose, ou Alt-Tab, etc.)
.set_urgency_hint       #
( [BOOL_VAL] )          #Fait clignotter la fenêtre dans la taskbar.
.get_state()            #Parmi WINDOWSTATE : WINDOW_STATE_{WITHDRAWN,ICONIFIED,MAXIMIZED,STICKY,FULLSCREEN,ABOVE,BELOW}
.{g,s}et_modal_hint     #
( [BOOL_VAL] )          #Défaut true
.{g,s}et_type_hint      #Parmi WINDOWTYPEHINT : WINDOW_TYPE_HINT_{NORMAL,DIALOG,MENU,TOOLBAR,SPLASHSCREEN,UTILITY,DOCK,DESKTOP,
( WINDOWTYPEHINT )      #DROPDOWN_MENU,POPUP_MENU,TOOLTIP,NOTIFICATION,COMBO,DND}

.get_width()            #Renvoie INT_VAL
.get_height()           #
.get_position(2 INT_VAR)#Met dans les références coordonnées x,y locales par rapport à WINDOW parente.
.get_origin( 2 INT_VAR )#Pareil mais avec la root window
.get_root_origin        #
( 2 INT_VAR )           #Pareil, mais prend en compte espace non disponible de la root window.
.get_geometry(4 INT_VAR)#INT_VAR1 et 2 : x et y ; 3 et 4 : width et height. Chaque VAR peut être 0 si on a pas besoin de cette
                        #info. Local à WINDOW parente.
.get_root_coords(4 ITVR)#Pareil, mais avec la root window.
.get_frame_extents      #
( RECTANGLE_VAR )       #Pareil
.coords_to_parent       #Transforme coordonnées locales à WINDOW DOUBLEVAL1,DOUBLEVAL2 en coordonnées locales à son parent,
(2 DOUBLEVL,2 DOUBLEVAR)#et met le résultat dans les DOUBLE_VAR.
.coords_from_parent     #
(2 DOUBLEVL,2 DOUBLEVAR)#Inverse.
.get_pointer( 2 INT_VAR,#Met dans références coordonnées MODIFIERTYPE éventuellement pressé, et coordonnnées du curseur locales
MODIFIERTYPE_VAR )      #à la fenêtre qu'il pointe, qui est renvoyée sous forme de REFPTR<WINDOW>
.get_device_position    #
( REFTR<DEVICE>, ARGS ) #Comme get_pointer( ARGS ), mais pour DEVICE.

.get_parent()           #Renvoie REFPTR<WINDOW> parente
.get_toplevel()         #Renvoie REFPTR<WINDOW> toplevel de WINDOW (!= root window)
.get_children()         #Renvoie WINDOW enfants sous forme de VECTOR<REFPTR<WINDOW> >

.move( 2 INT_VAL )      #Déplace WINDOW (coordonnées locales au parent, position absolue, coin supérieur gauche)
.resize( 2 INT_VAL )    #Redimensionne
.move_resize( 4 INT_VAL)#
.reparent(REFPTR<WINDW>,
2 INT_VAL )             #Change la WINDOW parente, mais aussi fait un move().
.scroll( 2 INT_VAL )    #Déplace contenu de WINDOW (et non WINDOW elle-même) : produit des effets inattendus.
.move_region(CAIR::RFPTR
<CAIRO::REGION>,2 INTVL)#Pareil mais avec une CAIRO::REGION
.set_geometry_hints     #Modifie paramètres désignés par WINDOWHINTS parmi : HINT_{MIN_SIZE,MAX_SIZE,BASE_SIZE,ASPECT,
( GEOMETRY, WINDOWHINTS)#RESIZE_INC}, et paramétrés par GEOMETRY, qui est une struct dont les membres sont :
                        #  - min_{width,height}  : taille min possible
                        #  - max_{width,height}  : taille max possible
                        #  - base_{width,height} : semble identique à min
                        #  - {min,max}_aspect    : ratio largeur/hauteur min./max.
                        #  - {width,height}_inc  : tout redimensionnement doit être divisible par ce nombre (par exemple pour
                        #                          un terminal dont la taille doit être divisible par taille d'un char)
                        #Il faut faire un resize pour que ça prenne effet. Attention, *_SIZE font utiliser les valeurs de
                        #height + width, même si l'on veut que l'un des deux. Pareil pour les autres.

.get_window_type()      #Parmi : WINDOW_ROOT (ensemble de l'écran, mis par le window compositer au début du démarrage
                        #graphique), WINDOW_TOPLEVEL (ex: GTK::WINDOW), WINDOW_CHILD (GTK::WIDGET enfants),
                        #WINDOW_OFFSCREEN (???)
.get_visual()           #Renvoie le REFPTR<VISUAL>
.get_screen()           #Renvoie le REFPTR<SCREEN>
.get_display()          #Renvoie le REFPTR<DISPLAY>
.{g,s}et_composited     #
( [BOOL_VAL] )          #Cf GTK::WINDOW.is_composited()
.{g,s}et_group_leader   #WINDOW2 devient le nouveau group leader du groupe de WINDOW (utilisé par certains window managers
( REFPTR<WINDOW2> )     #pour désigner un groupe de fenêtres appartenant à la même application)

.set_title( USTRING )   #Modifie titre de la Title bar

.create_cairo_context() #Renvoie un CAIRO::REFPTR<CAIRO::CONTEXT>, avec un CAIRO::CONTEXT associé (dessiner sur CAIRO::CONTEXT 
                        #dessine donc sur WINDOW).
                        #Celui-ci est redrawed à chaque changement d'apparence de WINDOW : si l'on veut dessiner sur
                        #WINDOW, préférer donc signal draw de GTK::WINDOW, sauf pour un WIDGET personnalisé via
                        #DRAWINGAREA (qui par défaut ne change pas d'apparence)
.get_clip_region()      #Renvoie la CAIRO::REFPTR<CAIRO::REGION> où l'on peut dessiner.
.get_visible_region()   #Renvoie la CAIRO::REFPTR<CAIRO::REGION> actuellement visible.
.create_similar_surface #
( CAIRO::CONTENT,       #Renvoie une CAIRO::REFPTR<CAIRO::SURFACE> noire, opaque ou transparente selon CAIRO::CONTENT parmi
2 INT_VAL )             #CAIRO::CONTENT_{COLOR,ALPHA,COLOR_ALPHA}, avec mêmes paramètres (résolution, etc.) que WINDOW.
.begin_paint_rect       #
( RECTANGLE )
.begin_paint_region     #
( CAIRO::REFPTR         #Fait que les opérations de dessins via Cairo entre begin et end, sur la zone désigné en argument à
<CAIRO::REGION> )       #begin, ne seront affichés que lors du end_paint(), permettant d'éviter un clignottement lors du
.end_paint()            #dessin.
.flush()                #
.set_opacity(DOUBLE_VAL)#Modifie la transparence de l'ensemble de WINDOW. Le window manager de l'OS doit le supporter :
                        #cf GTK::WINDOW.is_composited()
.shape_combine_region   #Fait que ce qui n'est pas dans REGION (coordonnées locales à WINDOW) sera transparent et considérer
( CAIRO::REFPTR         #comme inexistant pour l'input. Il faudra aussi penser à enlever les bordures de fenêtres
<CAIRO::REGION>         #(set_decorated()) et les ombres. Ignore si c'est portable.
[, 2 INT_VAL] )         #Les INT_VAL (défaut 0) décalent REGION
.input_shape_combine_   #
region*                 #Pareil, mais ne considère que le fait que pas d'input, pas la transparence
.set_background( ARGS ) #Modifie la CAIRO::SOURCE (arrière-plan) sous-jacent, ARGS étant RGBA, COLOR ou
                        #CAIRO::REFPTR<CAIRO::PATTERN>
.get_background_        #
pattern()               #Renvoie CAIRO::REFPTR<CAIRO::PATTERN>

.{g,s}et_cursor         #
( REFPTR<CURSOR> )      #Pour la souris maître.
.{g,s}et_device_cursor  #
( REFPTR<DEVICE>, 
REFPTR<CURSOR> )        #Comme *et_cursor(), mais pour une DEVICE particulière.
.set_icon_list( VECTOR  #Modifie l'icône de la minimization (les différents PIXBUF sont choisis en fonction de la taille
<REFPTR<GDK::PIXBUF> > )#demandée)
.unset_icon()           #
.set_icon_name( USTRING)#Modifie titre de la fenêtre dans la minimization (sinon même titre que titlebar)

.{g,s}et_events         #Modifie X events possibles parmi (or'd): {EXPOSURE,POINTER_MOTION_HINT,{POINTER,BUTTON,BUTTON{1..3}
( EVENTMASK )           #BUTTON_PRESS}_MOTION,BUTTON_RELEASE,KEY_{PRESS,RELEASE},{ENTER,LEAVE}_NOTIFY,FOCUS_CHANGE,
                        #STRUCTURE,PROPERTY_CHANGE,VISIBILITY_NOTIFY,PROXIMITY_{IN,OUT},SUBSTRUCTURE,SCROLL,ALL_EVENTS}_MASK
.{g,s}et_device_events  #
( REFPTR<DEVICE>,       
EVENTMASK )             #Pareil mais seulement pour DEVICE
.{g,s}et_source_events  #
(INPUTSOURCE, EVENTMASK)#Pareil mais seulement pour une INPUTSOURCE

Visual                  #Informations sur les couleurs des pixels, pour un SCREEN donné.
Visual::get_system()    #Renvoie le REFPTR<VISUAL> par défaut.
Visual::get_best        #Renvoie le meilleur REFPTR<VISUAL> pour une depth de INT_VAL (défaut celui par défaut) et un
([INTVAL[,VISUAL_TYPE]])#VISUAL_TYPE (défaut celui par défaut)
VISUAL.get_depth()      #Nombre de bits/pixels, sous forme d'INT_VAL.
Visual::get_best_depth()#Renvoie la meilleure depth du système.
VSUAL.get_bits_per_rgb()#Nombre de bits par channel, sous forme d'INT_VAL.
VISUAL.get_byte_order() #Parmi : LSB_FIRST et MSB_FIRST 
VISUAL.get_visual_type()#Parmi : VISUAL_{STATIC_GRAY,GRAYSCALE,STATIC_COLOR,PSEUDO_COLOR,TRUE_COLOR,DIRECT_COLOR} (j'ai
                        #TRUE_COLOR)
Visual::get_best_type() #Renvoie le meilleur VISUAL_TYPE du système.
VSAL.get_colormap_size()#Sous forme d'INT_VAL (j'ai 256)
VISUAL.get_screen()     #Renvoie le REFPTR<SCREEN> associé.

Screen                  #Window compositing settings. Par exemple sous Compiz == un bureau de Compiz.
SCREEN.get_display()    #Renvoie le REFPTR<DISPLAY>
SCRN.get_system_visual()#Renvoie le REFPTR<VISUAL> par défaut de ce SCREEN.
SCREEN.list_visuals()   #Renvoie liste des VISUAL disponibles sous forme de VECTOR<REFPTR<VISUAL> >
SCREEN.is_composited()  #Renvoie true si alpha channel possible pour les fenêtres.
SCREEN.get_
{width_height}{,mm}()   #Renvoie taille en pixels ou millimètres (fonctionne). Changement de taille émet signal size_changed
SCREN.{g,s}et_resolution#
( INT_VAL )             #Défaut 96 (dpi). Seulement pour les polices. Et ne semble affecter que la WINDOW courante.

SCREEN.get_root_window()#Renvoie la GDK::WINDOW root du window manager.
SCREEN.
get_active_window()     #Renvoie la GDK::WINDOW ayant le focus sur SCREEN
SCREEN.                 #Renvoie ensemble des toplevel WINDOW de ce SCREEN, sous forme de VECTOR<WINDOW>
get_toplevel_windows()  #Ne comprends que ceux connus du programme (+1 invisible semble-t-il), pas les autres applications.
SCREEN.
get_window_stack()      #Renvoie vraiment les toplevel WINDOW de tous les programmes de SCREEN sous forme de VECTOR<WINDOW>
SCREEN.get_number()     #Renvoie le numéro de SCREEN (par exemple si plusieurs bureaux)

SCREEN.get_n_monitors() #Renvoie nombre d'écrans.
SCREEN.
get_primary_monitor()   #Renvoie index de l'écran principal.
SCREEN.
get_monitor_plug_name() #
SCREEN.
get_monitor_geometry    #
( INT_VAL, RECTANGLE_VAR )
SCREEN.get_monitor_at_  #
point( 2 INT_VAL )
SCREEN.get_monitor_at_  #
window( REFPTR<WINDOW> )
SCREEN.get_monitor_
{width,height}_mm(INTVL)

Display                 #Comme Screen, mais plus centré sur l'input. Sous X, fait référence aux X Displays.
                        #Sert à recevoir les GDKEVENT. Par exemple sous Compiz == 1 X display attaché à un bureau.
Display::get_default()  #Renvoie le default REFPTR<DISPLAY>
DISPLAY.
get_device_manager()    #Renvoie le REFPTR<DEVICEMANAGER>
DISPLAY.get_name()      #Renvoie le nom sous USTRING. Pour moi ":0.0"
DISPLAY.get_n_screens() #Renvoie nombre de SCREEN associés.
DISPLAY.get_screen()    #Renvoie l'un des REFPTR<SCREEN>
DISPLAY.                
get_default_screen()    #Renvoie le default REFPTR<SCREEN>
DISPLAY.
get_default_group()     #Renvoie la top REFPTR<WINDOW>
DISPLAY.beep()          #Sensé émettre un beep.
DISPLAY.sync()          #
DISPLAY.flush()         #Flush DISPLAY.
DISPLAY.close()         #Ferme DISPLAY (provoque un SegFault pour moi)
DISPLAY.is_closed()     #
DISPLAY.supports_
cursor_{alpha,color}()  #Renvoie true si curseurs peuvent avoir de l'alpha / de la couleur.
DISPLAY.get_
default_cursor_size()   #Sous UINT_VAL.
DISPLAY.get_maximal_
cursor_size( 2 INT_VAR )#
DISPLAY.
set_double_click_time   #
( UINT_VAL )            #Change threshold pour un double clic, en millisecondes.

DeviceManager           #Ensemble de DEVICE. Pour moi ensemble de DEVICE :
                        #  - MASTER : keyboard, souris
                        #  - SLAVE  : touchpad, "virtual" keyboard, camera, sleep bouton, power bouton, écran?, "virtual" 
                        #             souris
DVICMANAGR.get_display()#Renvoie le REFPTR<DEVICE> associé
DEVICEMANAGER.
get_client_pointer()    #Renvoie le principal REFPTR<DEVICE>
DEVICEMANAGER.          #Renvoie tous les DEVICE de type DEVICETYPE, sous forme de VECTOR<REFPTR<DEVICE> >, parmi
list_devices(DEVICETYPE) #DEVICE_TYPE_{MASTER,SLAVE,FLOATING}

Device                  #Input périphérique, tel que souris, clavier, touchpad, tablette graphique ou écran tactile (dont 
                        #multiscreen)
DEVICE.get_display()    #Renvoie le REFPTR<DISPLAY> associé.
DEVICE.get_name()       #Sous USTRING.
DEVICE.get_has_cursor() #
DEVICE.get_source()     #Renvoie le type sous forme d'INPUTSOURCE parmi SOURCE_{MOUSE,PEN,ERASER,CURSOR,KEYBOARD}
DEVICE.{g,s}et_mode     #
( INPUTMODE )           #Parmi : MODE_DISABLED (input disabled), MODE_SCREEN (normal), MODE_WINDOW (circonscrit à une WINDOW)
DEVICE.get_n_keys()     #Renvoie nombre de touches, pour un clavier.
DEVICE.get_n_axis()     #Renvoie nombre d'angle (joystick, styler de tablette graphique, molette de souris)
DEVICE.{g,s}et_axis_use #
( UINT_VAL, AXISUSE )   #Renvoie type de l'axis numéro UINT_VAL parmi : AXIS_{IGNORE,X,Y,PRESSURE,XTILT,YTILT,WHEEL}
DEVICE.get_axis         #
( DOUBLE_VAR1, AXISUSE, 
DOUBLE_VAR2 )
DEVICE.get_history      #Renvoie ensemble des valeurs de DEVICE entre les 2 UINT32_VAL (timestamps) sous forme de
( REFPTR<WINDOW>,       #VECTOR<TIMECOORD>. TimeCoord a deux méthodes : get_time() (renvoie UINT32_VAL), et 
2 UINT32_VAL )          #get_value_at_axis( UINT_VAL ) (renvoie DOUBLE_VAL)
DEVICE.get_device_type()#Renvoie DEVICETYPE
DVC.list_slave_devices()#Si DEVICE_TYPE_MASTER, renvoie VECTOR<REFPTR<DEVICE> >, sinon 0.
DEVICE.
get_associated_device() #Renvoie REFPTR<DEVICE> associé, ou 0.
DEVICE.get_position
( [REFPTR<SCREEN>, ]    
2 INT_VAR )             #Met la position x,y de DEVICE, par rapport à SCREEN (défaut sa propre SCREEN)
DEVICE.
get_window_at_position  #
( [2 INT_VAR] )         #Renvoie la REFPTR<WINDOW> à la position de DEVICE, et si INT_VAR, met sa position dedans.

Cursor                  #Désigne un curseur.
                        #GDK mis à jour automatiquement le curseur : en fonction de la situation, il va chercher un fichier
                        #image en fonction du basename dans le thème courant, dans même répertoire que pour les icônes.
Cursor::create
( [REFPTR<DISPLAY>, ] 
CURSORTYPE )
Cursor::create          #
( REFPTR<DISPLAY>, 
REFPTR<PIXBUF>, 2 INTVL)
Cursor::create
( REFPTR<DISPLAY>, 
USTRING )               #USTRING est le basename du fichier dans le thème. Renvoie tous un REFPTR<CURSOR>
CURSOR.get_display()    #Renvoie le REFPTR<DISPLAY> associé
CURSOR.get_image()      #Renvoie la REFPTR<PIXBUF> associé
CURSOR.get_cursor_type()#Renvoie le CURSORTYPE parmi : {X_CURSOR,ARROW,BASED_ARROW_DOWN,BASED_ARROW_UP,BOAT,BOGOSITY,
                        #BOTTOM_LEFT_CORNER,BOTTOM_RIGHT_CORNER,BOTTOM_SIDE,BOTTOM_TEE,BOX_SPIRAL,CENTER_PTR,CIRCLE,CLOCK,
                        #COFFEE_MUG,CROSS,CROSS_REVERSE,CROSSHAIR,DIAMOND_CROSS,DOT,DOTBOX,DOUBLE_ARROW,DRAFT_LARGE,
                        #DRAFT_SMALL,DRAPED_BOX,EXCHANGE,FLEUR,GOBBLER,GUMBY,HAND1,HAND2,HEART,ICON,IRON_CROSS,LEFT_PTR,
                        #LEFT_SIDE,LEFT_TEE,LEFTBUTTON,LL_ANGLE,LR_ANGLE,MAN,MIDDLEBUTTON,MOUSE,PENCIL,PIRATE,PLUS,
                        #QUESTION_ARROW,RIGHT_PTR,RIGHT_SIDE,RIGHT_TEE,RIGHTBUTTON,RTL_LOGO,SAILBOAT,SB_DOWN_ARROW,
                        #SB_H_DOUBLE_ARROW,SB_LEFT_ARROW,SB_RIGHT_ARROW,SB_UP_ARROW,SB_V_DOUBLE_ARROW,SHUTTLE,SIZING,SPIDER,
                        #SPRAYCAN,STAR,TARGET,TCROSS,TOP_LEFT_ARROW,TOP_LEFT_CORNER,TOP_RIGHT_CORNER,TOP_SIDE,TOP_TEE,TREK,
                        #UL_ANGLE,UMBRELLA,UR_ANGLE,WATCH,XTERM,LAST_CURSOR,BLANK_CURSOR,CURSOR_IS_PIXMAP}

GdkEvent                #Union très longue, comprenant tout pour un évévement : type, timestamps, position, etc.

Color                   #Couleur RGB.
COLOR(USTRING)          #Effectue COLOR.set( USTRING )
COLR.set([USTRING])     #Modifie la couleur avec USTRING, sous la forme "#RRRRGGGGBBBB", "#RRGGBB" ou un nom tel que ceux 
                        #dans /etc/X11/rgb.txt : "DarkGray", etc. Par défaut noir.
COLOR.to_string()       #Renvoie couleur sous forme d'une USTRING composé d'hexs : "#RRRRGGGGBBBB" (couleur 16 bits/channel)
COLOR.{s,g}et_red()     #
CLR.{s,g}et_green()     #
COLR.{s,g}et_blue()     #Renvoie la valeur de R, G ou B sous forme de USHORT_VAL (couleur 16 bits / channel)
COLOR.get_red_p()       #
COLOR.get_green_p()     #
COLOR.get_blue_p()      #Renvoie la valeur de R, G ou B sous forme de DOUBLE_VAL ( 0 à 1 )
COLOR.set_rgb           #
( 3 USHORT_VAL )        #Effectue set_red(), set_green() puis set_blue()
COLOR.set_rgb_p         #
( 3 DOUBLE_VAL )        #Effectue set_red_p(), set_green_p() puis set_blue_p()
COLOR.set_grey          #
( USHORT_VAL )          #Comme set_rgb(), mais avec 3 fois la même valeur
COLOR.set_grey_p        #
( DOUBLE_VAL )          #Même chose, mais avec set_rgb_p()
COLOR.set_hsv           #
( 3 DOUBLE_VAL )        #Modifie couleur en fonction de Hue / Saturation / Value
COLOR.set_hsl           #
( 3 DOUBLE_VAL )        #Modifie couleur en fonction de Hue / Saturation / Lightness
COLOR.swap( COLOR2 )    #

RGBA                    #Couleur RGBA.
                        #Comme Color, sauf que : 
                        #  - on doit utiliser "rgb( 3 SHORT_VAL )" à l'instantiation, et to_string() renvoie 
                        #    "rgba ( 4 SHORT_VAL )"
                        #  - set_rgb*() -> set_rgba*() et utilise un quatrième argument pour l'alpha. Même chose pour 
                        #    set_grey*
                        #  - il y a {s,g}et_alpha[_u]()
                        #  - *_p() devient *() pour les DOUBLE_VAL et *() devient *_u() pour les SHORT_VAL
                        #  - pas de get_pixel()

Pixbuf                  #Enfant de Gio::Icon. Représente les pixels d'une image (pixmap).
                        #Non-instantiable : utiliser factory method.
Pixbuf::
create_from_file(STRING 
[, INT_VAL1, INT_VAL2   #Renvoie un REFPTR<PIXBUF> pour l'image dont le chemin est STRING. Cf dessous les formats reconnus.
[, BOOL_VAL]])          #Resize l'image à INT_VAL1 * INT_VAL2 pixels en gardant les proportions, sauf si BOOL_VAL est false.
Pixbuf::create          #
( COLORSPACE, BOOL_VAL, 
INT_VAL1, INT_VAL2,     #Renvoie un REFPTR<PIXBUF> remplis de pixels noirs, complètement transparents si true, de taille 
INT_VAL3 )              #INT_VAL2 * INT_VAL3 pixels. INT_VAL1 est le nombre de bits par channel : forcément 8.
Pixbuf::
create_subpixbuf        #Renvoie un REFPTR<PIXBUF> représentant une zone précise d'un autre PIXBUF, partant des coordonnées
(REFPTR<PIXBF>,4 INTVAL)#INT_VAL1,INT_VAL2, et de taille INT_VAL3 * INT_VAL4.
Pixbuf::create
( CAIRO::REFPTR
<CAIRO::SURFACE>,       #Renvoie un REFPTR<PIXBUF> représentant un CAIRO::SURFACE, partant des coordonnées INT_VAL1,INT_VAL2
4 INT_VAL )             #et de taille INT_VAL3 * INT_VAL4.
Pixbuf::
create_from_data        #
( GUINT8_ADR, ARGS      #Renvoie un REFPTR<PIXBUF> associé à un array de pixels commençant à GUINT8_ADR. ARGS sont les mêmes
[, SIGC::SLOT<VOID,     #que Pixbuf::create( ... ). Le fonctor du SLOT est invoqué lors de la destruction de PIXBUF : doit
GUINT8_ADR>] )          #donc désallouer GUINT8_ADR.
Pixbuf::
create_from_xpm_data    #
( CHAR_ADR )            #Renvoie un REFPTR<PIXBUF> associé à un array au format .xpm

PIXBUF.copy()           #Renvoie une copie de PIXBUF sous forme de REFPTR<PIXBUF>
PIXBUF.get_colorspace() #Renvoie le COLORSPACE de PIXBUF, parmi : COLORSPACE_RGB.
PIXBUF.get_n_channels() #Renvoie le nombre de channels (3 pour RGB, 4 pour RGBA)
PIXBUF.get_has_alpha()  #Renvoie true si channel alpha présent.
PIXBUF.add_alpha        #Rajoute un channel alpha si absent. Si true, les pixels ayant exactement la valeur 0xRRGGBB des 
( BOOL_VAL, 3 UINT8_VAL)#trois derniers arguments seront complètement transparents.
PIXBUF.
get_bits_per_sample()   #Renvoie nombre de bits par channel.
PIXBUF.get_width()      #Renvoie la largeur en pixels de PIXBUF.
PIXBUF.get_height()     #Renvoie la hauteur en pixels de PIXBUF.
PIXBUF.get_rowstride()  #Renvoie get_width() * nombre d'octets par pixel.
PIXBUF.get_pixels()     #Renvoie le PIXBUF sous forme d'array de UINT8_VAL (UINT8_ADR)
PIXBUF.fill( UINT32_VAL)#Remplis PIXBUF de pixels de couleur UINT32_VAL, soit 0xRRGGBBAA.
PIXBUF.
saturate_and_pixelate   #
( REFPTR<PIXBUF2>,      #PIXBUF = PIXBUF2, après multiplication de la saturation par DOUBLE_VAL. Si true, la modification de
DOUBLE_VAL, BOOL_VAL )  #la saturation se fait via l'application d'un quadrillage de carré en niveaux de gris.
PIXBUF.flip( [BOOL_VAL])#Renvoie un REFPTR<PIXBUF> avec PIXBUF flipped horizontalement si true, verticalement sinon.
PIXBUF.rotate_simple    #Renvoie un REFPTR<PIXBUF> avec PIXBUF rotated parmi :
( PIXBUFROTATION )      #PIXBUF_ROTATE_{NONE,{COUNTER,}CLOCKWISE,UPSIDEDOWN} (0°, 270°, 90°, 180°)
PIXBUF.scale_simple     #
( INT_VAL1, INT_VAL2,   #Renvoie un REFPTR<PIXBUF> avec PIXBUF scaled à une taille de INT_VAL1 * INT_VAL2 pixels, avec un
INTERPTYPE )            #algorithme de scaling parmi : INTERP_{NEAREST,TILES,BILINEAR,HYPER} (du pire au mieux).

Pixbuf::                #Renvoie un VECTOR<PIXBUFFORMAT> des formats d'images supportés. PIXBUFFORMAT a des membres tels que
get_formats()           #  - get_name(), get_description() : STRING désignant nom et description
                        #  - is_writable(), is_scalable() : BOOL_VAL si le format est lisible, mais non writable ; et si l'on
                        #    peut le scale sans perte de données (seulement .svg à l'heure actuelle)
                        #  - is_disabled(), set_disable( BOOL_VAL ) : on peut disable un format
                        #  - get_license() : STRING désignant la license (LPGL pour tous, sauf .icns GPL, et .wmf, proprio)
                        #  - get_extensions() et get_mime_types() : renvoie les extensions reconnues et mime types sous forme 
                        #    de VECTOR<USTRING>
                        #Formats reconnus pour ma version :
                        #  - readable only : .ani, .gif, .icns, {.jp2, .jpc, .jpx, .j2k, .jpf}, .pcx, {.pnm, .pbm, .pgm, .ppm},
                        #    {.qtif, .qif}, .ras, {.svg, .svgz, .svg.gz}, .tga, .wbmp, .xbm, .xpm, .wmf
                        #  - readable pour writable : .bmp, {.ico, .cur}, {.jpg, .jpeg, .jpe}, .png, .tiff

Rectangle               #Rectangle.
RECTANGLE
( 4 INT_VAL )           #x, y, width et height
RECTANGLE.
{s,g}et_x( INT_VAL )    #
RECTANGLE.
{s,g}et_y( INT_VAL )    #
RECTANGLE.
{s,g}et_height( INT_VAL)#
RECTANGLE.
{s,g}et_width( INT_VAL )#
RECTANGLE.
has_zero_area()         #Renvoie true si width ou height est == 0
RECTANGLE.join          #
( RECTANGLE2 )          #Renvoie un RECTANGLE pouvant comprendre les deux RECTANGLE
RECTANGLE.intersect     #
( RECTANGLE2
[, BOOL_VAR] )          #Renvoie un RECTANGLE pour l'intersection et, si BOOL_VAR, BOOL_VAR = true s'il y a intersection.

Gdk::ModifierType       #Représente une touche modifier (or'd possible), parmi : 
                        #  - tout : MODIFIER_MASK
                        #  - rien : RELEASE_MASK
                        #  - shift : SHIFT_MASK
                        #  - control : CONTROL_MASK
                        #  - alt : META_MASK, MOD1_MASK
                        #  - super : SUPER_MASK, HYPER_MASK
                        #  - caps lock : LOCK_MASK
                        #  - clic gauche : BUTTON1_MASK
                        #  - clic droit : BUTTON2_MASK
                        #  - clic central : BUTTON3_MASK
                        #  - clic 4 et 5 (sur certains souris) : BUTTON_{4,5}_MASK
                        #  - ne sait pas : MOD{2..5}_MASK