-
Notifications
You must be signed in to change notification settings - Fork 16
/
gtkmm.txt
4187 lines (3868 loc) · 240 KB
/
gtkmm.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
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
GTKMM
/=+===============================+=\
/ : : \
)==: GENERAL :==(
\ :_______________________________: /
\=+===============================+=/
LIBRAIRIE ET HEADERS ==>#libgtkmm (en C : libgtk)
# - <gtkmm.h> : header général comprenant tout
# - <gtkmm/accelmap.h> : AccelMap
# - <gtkmm/volumebutton.h> : ScaleButton et VolumeButton
# - <gdkmm/devicemanager.h> : DeviceManager et Device
# - <gdkmm/plug.h> : Plug
# - <gdkmm/socket.h> : Socket
#En C : <gtk.h>, <gtk/gtkaccelmap.h>, etc.
#Wrapper c++ de GTK+.
#Utilise libsigc++, cairomm, pangomm, atkmm, glibmm.
#Compiler avec $(pkg-config gtkmm-VERSION --cflags --libs) (en C : gtk+-VERSION)
NAMESPACE ==> #Gtk::
IDEE PRINCIPALE ==> # - initialiser Gtkmm avec Gtk::Main VAR( argc, argv )
# - instantier une WINDOW, et la lancer via Gtk::Main::run( WINDOW_VAR )
# - WINDOW :
# - CONTAINER (WIDGET pouvant contenir d'autres WIDGET via add() ou pack_*())
# - une fois WIDGET placés, les afficher via WINDOW.show_all()
# - mettre des callbacks aux WIDGET via les signaux
Principales classes :
- Principal : Main, Object, Widget, Container
- Window : Window, Dialog, MessageDialog, AboutDialog, Assistant, Plug, Socket
- Button : Button, ToggleButton, CheckButton, RadioButtonGroup, RadioButton, LinkButton, ScaleButton, VolumeButton
- Bin : Bin, Frame, AspectFrame, ScrolledWindow, Viewport, Alignment, Expander, EventBox
- Box : [H|V]Box, [H|V]ButtonBox, Statusbar, InfoBar
- Container : Layout, Fixed, [H|V]Paned, Table, Grid, Notebook
- Menu : MenuShell, MenuBar, Menu, MenuItem, CheckMenuItem, RadioMenuItem, SeparatorMenuItem, ImageMenuItem, UIManager
- Toolbar : ToolShell, Toolbar, ToolPalette, ToolItemGroup, ToolItem, SeparatorToolItem, ToolButton,
ToggleToolButton, RadioToolButton, RadioToolButton, MenuToolButton
- Widgets non-container : Switch, [H|V]Separator, Range, [H|V]Scale, [H|V]Scrollbar, Misc, Label, AccelLabel, Image, Arrow,
Calendar, ProgressBar, Spinner, DrawingArea
- Non-widgets : Orientable, SizeGroup, Editable, Adjustment, Border, Tooltip,
- Entry : Entry, EntryBuffer, SpinButton
- TreeView :
- Action&Accelerators : Activatable, Action, ToggleAction, RadioAction, ActionGroup, AccelGroup, AccelMap, AccelKey
- Chooser : FontChooser, FontChooserWidget, FontChooserDialog, FontButton, FontSelection, FontSelectionDialog,
ColorSelection, ColorSelectionDialog, ColorButton, FileChooser, FileFilter, FileChooserWidget, FileChooserDialog,
FileChooserButton, RecentChooser, RecentFilter, RecentChooserWidget, RecentManager, RecentInfo, RecentChooserMenu,
RecentAction, AppChooser
- Icônes : StockID, StockItem, IconSet, IconSource, IconSize
- TextView : TextView, TextBuffer, TextIter, TagTable, Tag, TextChildAnchor, Mark
- Drag&Drop : SelectionData, DragContext, TargetEntry, TargetList, Clipboard
- Builder&Settings : Builder, Buildable, Settings
Plusieurs classes ne sont pas CopyConstructible, ni instantiable :
- On ne peut donc pas les passer par référence, il faut les passer par adresse.
- Elles sont créées via une static fonction create(), mais des constructors protected avec les mêmes arguments existent si l'on veut dériver cette classe
- Utiliser boost::[c]ref( ) si utilisation avec boost::bind
Définitions :
- PROP :
- désigne Glib::PropertyProxy<T>. PROPW désigne Glib::PropertyProxy_WriteOnly<T> et PROPR Glib::PropertyProxy_ReadOnly<T>
- PROP.set_value( T_VAL ), PROP.reset_value(), PROP.get_value() (Si WriteOnly, pas le dernier ; si ReadOnly, seulement le dernier). reset_value() remet à la valeur initiale. Mais il existe un cast operatorT, donc on peut faire PROP = T_VAL directement ou utiliser PROP comme une T_VAL.
- la plupart des classes définissent des fonctions property_* renvoyant des PROP<T> pour accéder à un membre T de la classe, mais c'est en général redondant avec les setters/getters déjà disponibles. Si ce n'est pas le cas, le property_* est spécifié.
- Cependant quelque utilité possible :
- PROP.signal_changed(), signal <void> émit lors d'une modification.
- USTRING est GLIB::USTRING
- REFPTR : signifie GLIB::REFPTR
- {s,g}et signifie que :
- une fonction set* existe aussi, prenant en argument le type renvoyé par get*.
- Si plusieurs arguments, le get* gardera les mêmes arguments, moins celui renvoyé.
- Si set* prend un *_VAR, get* renverra un *_ADR
- Par ailleurs :
- {g,s}et est l'inverse
- {[un]s,g}et signifie qu'il y a une fonction unset() qui fait un set() mettant à zero
MVC PATTERN ==> #Model-view-controller pattern (architectural pattern)
#Sépare ("Separation de SOLID"):
# - model : data. Modifier le model peut parfois déclencher des signaux modifiant la view.
# - view : ce que l'user voit et interagit avec. Contient aussi le state, qui lors de sa modification,
# peut déclencher des signaux modifiant comportement du controller.
# - controller : modifie model et view en fonction de l'input (donné par la view)
#Utilisation de Glade sépare view des deux autres (sauf les widgets personnalisés à coder)
#Pour séparer ensuite model du controller : avoir une database ou fichier XML avec interface
#indépendante.
#Controller désigne alors ensuite les callbacks dans le code.
/=+===============================+=\
/ : : \
)==: SIGNAUX :==(
\ :_______________________________: /
\=+===============================+=/
PREDIC ==> #Souvent les PREDIC sont en fait des SIGC::SLOT
SIGNAUX ==> #Plusieurs classes définissent les méthodes suivantes :
....signal_*() #Lors de l'évévement *, un callback est déclenchée de manière async (event-driven programming) :
#renvoie ce callback sous forme de Glib::SignalProxyN<...>. Tout événement à un callback par défaut,
#mais celui-ci souvent ne fait rien.
#Glib::SignalProxyN<...> est comme sigc::signal<...>, mais avec comme seuls membres SlotType et
#connect( SLOTTYPE ). Cf libsigc++.
#Le return type du signal est en général void ou bool, et il peut avoir différents arguments (ou pas
#d'arguments), cela dépend du signal : on voit cela dans le template <...>.
EQUIVALENT C ==> # g_signal_connect( GOBJECT_ADR, "signal", G_CALLBACK( FONC_ADR ), NULL );
PROBLEME AVEC FONCTORS #Pour faire un connect( FONCTOR ) d'un FONCTOR retournant une valeur, et n'étant pas un des fonctors
NON LIBSIGC++ ==> #de libsigc++, définir :
# - namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE }
#Préférer utiliser sigc::mem_fun( ), sigc::ptr_fun( ) ou sigc::bind( ) plutôt que leur version boost::
#quand c'est possible.
....on_*( [ARGS] ) #Tout signal_*() a une fonction correspondante on_*() prenant en argument ceux pris par le callback.
#Il s'agit d'une virtual function protected de type void : la redéfinir modifie le callback par défaut
#pour le signal *
#Pour pouvoir le faire, il faut donc être dans la classe même recevant ce signal.
X EVENTS ==> # - Il s'agit des signaux _event() de WIDGET.
# - Ils donnent des infos précises sur l'events (par exemple position de la souris) via des Gdk*Event
# - Callback renvoient bool : si true, mettre un callback fait que le callback par défaut ne se
# produit pas (sauf event_after()). Par exemple, focus_out n'enlevera plus le focus.
# - parfois impossible d'override le callback par défaut et d'intercepter l'event pour un widget
# donné : par exemple, signal clicked de Button empêche interception du signal button_pressed_event.
# Solution : mettre "false" comme dernier argument à connect(). Cependant, cela peut provoquer
# effets inattendus.
# - plupart des containers, Separator, enfant de Misc ne peuvent pas recevoir des X Events : les
# mettre dans une EventBox, et attacher le signal à l'EventBox (non à son enfant)
# - set_events et add_events modifient X events possibles, mais semble-t-il pas besoin (sauf pour
# limiter les X events possibles pour questions de performance)
Ensemble des signaux (si pas de <...>, <void> par défaut) (en général const&, sauf type fondamental et sauf précisé) :
- PRINCIPAL :
- WIDGET :
- show : show()
- hide : hide()
- [un]realize : quand le WIDGET a fini d'être instantié
- [un]map : quand le WIDGET a fini d'être dessiné à l'écran
- draw <bool, CAIRO::REFPTR<CAIRO::CONTEXT> > : à chaque fois que WIDGET est dessiné à l'écran, c'est-à-dire à chaque
changement d'apparence. Permet de dessiner dessus. Doit renvoyer false si REFPTR est un smart pointer vide.
- size_allocate <void,Gdk::Rectangle&> : émit lors du calcul de la taille requise pour le Widget. Modifier Rectangle
pour désigner cette taille via appel à WIDGET.set_allocation( GDK::RECTANGLE ).
A ne redéfinir que lors d'un Widget personnalisé.
- delete_event <void,GdkEventAny*> : quand le WIDGET est supprimé. Utile pour une toplevel fenêtre (ex : "Voulez-vous
sauvegarder ?"). Penser à faire hide() à la fin.
- state_changed <void, StateType> : quand le state change (focus, survol, désélection, etc.)
- focus <bool,DirectionType>
- grab_focus <void>
- {parent,hierarchy}_changed <void,Widget*>
- direction_changed <void,TextDirection>
- screen_changed <void,RefPtr<Gdk::Screen> >
- popup_menu : popmenu (clic droit par exemple)
- quiery_tooltip <bool,int,int,bool,RefPtr<Tooltip> > : les deux int sont les coordonnées du pointeur, locales à
WIDGET.
Tooltip est à modifier, et est affiché si l'on renvoie true. Le bool argument indique que le tooltip vient d'un
mouvementent initié par le clavier, non la souris. Il faut que WIDGET ait indiqué set_has_tooltip() auparavant.
- X Events (cf plus haut) :
- event <bool,GdkEvent*> : tout event
- event_after <void,GdkEvent*> : tout event
- button_{press,release}_event <bool,GdkEventButton*>
- scroll_event <bool,GdkEventScroll*>
- {enter,leave}_notify_event <bool,GdkEventCrossing*> : entrée/sortie du survol
- key_{press,release}_event <bool,GdkEventKey*>
- focus_{in,out}_event <bool,GdkEventFocus*>
- visibility_notify_event <bool,GdkEventVisibility*>
- configure_event <bool,GdkEventConfigure*> : redimensionnement de la fenêtre (ne marche que sur une WINDOW)
- motion_notify_event <bool,GdkEventMotion*> : déplacement en survol (ne marche que sur Entry et TextView)
- [un]map_event <bool,GdkEventAny*> (ne marche que sur WINDOW ?)
- selection_{clear,request,notify}_event <bool,GdkEventSelection*> (ne parvient pas à faire marcher)
- property_notify_event <bool,GdkEventProperty*> : ajout ou suppression (ne parvient pas à faire marcher)
- WIDGET->DRAGNDROP-RELATED :
- drag_begin <void,RefPtr<Gdk::DragContext> > : début du drag. Cf plus bas.
- drag_data_get <void,RefPtr<Gdk::DragContext>,SelectionData&,uint,uint> : fin du drag, successful. Cf plus bas.
- drag_failed <bool,RefPtr<Gdk::DragContext>,DragResult> : fin du drag, si non successful. Cf plus bas.
- drag_data_delete <void,RefPtr<Gdk::DragContext> > : fin du drag, si successful et ACTION_MOVE. Cf plus bas.
- drag_end <void,RefPtr<Gdk::DragContext> > : fin du drag, successful ou non. Cf plus bas.
- drag_motion <bool,RefPtr<Gdk::DragContext>,int,int,uint> : drag bouge d'un pixel dans la zone du drop. Cf plus bas.
- drag_leave <void,RefPtr<Gdk::DragContext>,uint> : drag quitte la zone du widget après l'avoir survoler. Cf plus
bas.
- drag_data_received <void,RefPtr<Gdk::DragContext>,int,int,SelectionData&,uint,uint> : drop. Cf plus bas.
- drag_drop <bool,RefPtr<Gdk::DragContext>,int,int,uint> : drop. Cf plus bas.
- CONTAINER :
- add <Widget*> : add()
- remove <Widget*> : remove()
- WINDOW :
- WINDOW :
- set_focus <vois,Widget*> : lorsque le focus est donné à un nouveau WIDGET
- DIALOG : response <void,GtkResponseType> : clic sur un BUTTON ajouté via add_button()
- ASSISTANT :
- apply : clic sur un bouton "Apply"
- cancel : clic sur un bouton "Cancel"
- close : clic sur un bouton "Close"
- prepare <void,Widget*> : changement de page. WIDGET_ADR est le widget principal de la page.
- PLUG :
- embedded : lors d'une connection de SOCKET
- SOCKET :
- plug_added
- plug_removed <bool>
- BUTTON :
- BUTTON :
- clicked, pressed
- released
- enter : mouse over
- leave : mouse out
- activate : déclenché par clicked
- TOGGLEBUTTON : toggled
- RADIOBUTTON : group_changed
- LINKBUTTON : activate_link <bool>
- SCALEBUTTON : value_changed <void,double>
- BOX :
- STATUSBAR :
- text_pushed <uint,ustring> : uint est le stack id
- text_popped <uint,ustring>
- INFOBAR : response <void,GtkResponseType> : clic sur un BUTTON ajouté via add_button()
- CONTAINER :
- NOTEBOOK :
- switch_page <WIDGET*, UINT> : chaque changement de tab (dont tout début)(UINT est le numéro du nouvel onglet, WIDGET son WIDGET)
- page_added <WIDGET*, UINT>
- page_removed <WIDGET*, UINT>
- page_reordered <WIDGET*, UINT>
- WIDGETS NON-CONTAINERS :
- CALENDAR :
- month_changed
- {prev,next}_{month,year}
- day_selected
- day_selected_double_click
- MENU :
- MENUSHELL :
- deactivate : deactivate()
- selection_done : choix + validation d'un MenuItem sans submenus
- UIMANAGER :
- add_widget <void,Widget*>
- actions_changed
- pre_activate <void,RefPtr<Action> > : avant l'émission d'un signal activate
- post_activate <void,RefPtr<Action> >
- TOOLBAR :
- TOOLSHELL :
- orientation_changed <void,Orientation>
- toolbar_style_changed <void,ToolbarStyle>
- ENTRY :
- ENTRY :
- activate : touche entrée
- icon_{press,release} <void,EntryIconPosition,GdkEventButton const*> : clic sur l'un des icônes
- ENTRYBUFFER :
- inserted_text <uint, STR, uint> : comme signal insert_text, sauf que premier UINT est position du premier
caractère
- deleted_text <void,uint,uint> : comme signal delete_text
- SPINBUTTON :
- value_changed
- wrapped : dépasse une limite, si get_wrap()
- TREEVIEW :
- TREEVIEW :
- cursor_changed : changement de la sélection courante
- TREEVIEWCOLUMN :
- clicked : clic sur colonne (si set_headers_clickable())
- CELLRENDERER :
- editing_started <void,CellEditable*,ustring>
- editing_canceled
- TREESELECTION :
- changed
- TREESORTABLE :
- sort_column_changed
- TREEMODEL :
- row_changed <void, TreePath, TreeIter>
- row_inserted <void, TreePath, TreeIter>
- row_deleted <void, TreePath>
- row_has_child_toggled <void, TreePath, TreeIter>
- row_reordered <void, TreePath, TreeIter, int*>
- NON-WIDGET :
- EDITABLE :
- changed : chaque insertion ou suppression (dont multicaractère, via sélection, copier/coller, etc.)
- insert_text <void, ustring, int*> : chaque insertion (USTRING : texte inséré, INT_ADR : position du dernier
caractère inséré)
- delete_text <void,int,int> : chaque suppression (INT1 : position du premier caractère supprimé - 1, INT2 :
position du dernier caractère supprimé)
- ADJUSTMENT :
- value_changed : value modifiée
- changed : modification (autre que valeur)
- RANGE :
- value_changed : value modifiée
- LABEL :
- activate_link <bool,ustring>
- ACTION&ACCELERATOR-RELATED :
- ACCELGROUP :
- accel_activate <bool, RefPtr<Glib::Object>, uint, Gdk::ModifierType> : activation de l'un des accelerators
de l'AccelGroup. guint et ModifierType est la touche, Object l'objet activated. Ne semble pas marcher.
- accel_changed <void, uint, Gdk::ModifierType, GClosure*> : changement de l'AccelGroup
- ACTION :
- activate : activate() de l'ACTIVATABLE associé
- TOGGLEACTION :
- toggled : toggled() de l'ACTIVATABLE associé
- RADIOACTION :
- changed
- CHOOSER :
- FONTBUTTON : font_set : quand une police est sélectionnée
- COLORSELECTION : color_changed : nouvelle couleur sélectionnée (clic pressed, clic maintenu en bougeant la souris, et clic released)
- COLORBUTTON : color_set : quand une couleur est sélectionnée
- FILECHOOSER :
- file_activated : choix d'un fichier non-répertoire + validation (touche Entrée, double clic)
- current_folder_changer : changement de répertoire courante (le déclenche parfois plusieurs fois)
- selection_changed : current_folder_changer ou clic sur un nouveau fichier (dont fichier régulier)
- confirm_overwrite : confirmation d'un overwrite
- update_preview : émis quand le preview widget devrait être updaté
- FILECHOOSERBUTTON : file_set : quand un fichier est sélectionné
- RECENTCHOOSER :
- item_activated : choix d'un fichier + validation (touche Entrée, double clic)
- selection_changed : changement de sélection
- RECENTMANAGER :
- changed : toute modification
- MENUITEM : activate : lors de la validation (ouverture du submenu si MenuItem avec submenu)
- CHECKMENUITEM : toggled
- TOOLBUTTON : clicked
- TOGGLETOOLBUTTON : toggled
- MENUTOOLBUTTON : show_menu
- TEXTVIEW
- TEXTVIEW :
- set_anchor : add_child_at_anchor()
- TEXTBUFFER :
- {begin,end}_user_action : cf begin_user_action(). Utile pour mettre un undo-historique.
- insert <void,TextIter,ustring,int> : INT_VAL est le nombre de caractères insérés
- erase <void,TextIter,TextIter>
- changed : insert ou erase
- modified_changed : premier changed
- apply_tag <void,RefPtr<Tag>,TextIter,TextIter>
- remove_tag <void,RefPtr<Tag>,TextIter,TextIter>
- insert_pixbuf <void,TextIter,RefPtr<Gdk::Pixbuf> >
- insert_child_anchor <void,TextIter,RefPtr<TextChildAnchor> >
- mark_set <void,TextIter,RefPtr<TextBuffer::Mark> >
- mark_deleted <void,RefPtr<TextBuffer::Mark> >
- TAGTABLE :
- tag_changed <void, REFPTR<TAG>, bool> : bool est ... ?
- tag_added <void, REFPTR<TAG> >
- tag_removed <void, REFPTR<TAG> >
/=+===============================+=\
/ : : \
)==: MEMORY MANAGEMENT :==(
\ :_______________________________: /
\=+===============================+=/
GENERAL ==> #Il est préférable de déclarer les WIDGET contenus par une CLASS comme CLASSDT.
#Cependant, on a parfois besoin de pointeurs : notamment dans un handler si l'on veut créer des
#WIDGET runtime.
#On ne peut pas déclarer des WIDGET non-pointeurs dans le scope d'une fonction (dont constructor), si
#ces WIDGET doivent survivre au-delà de cette fonction. En effet, si le WIDGET doit survivre, réduire
#sa lifetime à une fonction provoque des crashs.
#Solution : utiliser des pointeurs, mais sans problème de leak memory :
# - CLASS( void )
# {
# WIDGET* WIDGET_ADR( Gtk::manage( new WIDGET( ARGS ) ) );
# add( *WIDGET_ADR );
# }
#Problème : les fonctions de la classe ne peuvent pas référer à ce pointeur sans le passer comme
#argument.
#Grâce à manage, dès que WIDGET_ADR est attaché à un container via add(), pack*, etc., il sera détruit
#lors de la destruction de ce container. Et comme il s'agit d'un pointeur : la lifetime de ce
#qu'il pointe dépasse celle de la fonction où le pointeur a été déclaré.
#Pour les non-WIDGET, souvent :
# - ou ils peuvent être temporaires (ex : StockID)
# - ou il s'agit de base classe qu'on manipule via leur enfant (ex : Editable)
# - ou il faut les instantier via des factory methods et RefPtr : dès que ce RefPtr est assigné à un
# WIDGET du container, ce WIDGET extend la lifetime de ce REFPTR.
/=+===============================+=\
/ : : \
)==: PRINCIPAL :==(
\ :_______________________________: /
\=+===============================+=/
ObjectBase #Parent d'Object et Interface. Enfant de sigc::trackable
Glib::Object #Wrapper autour de GObject (hors interfaces), parent direct de toutes les classes n'étant pas enfant
#d'Interface ou de Gtk::Object (donc essentiellement n'étant pas un Widget ni une Interface), à
#l'exception de Main, qui n'est enfant que de sigc::trackable.
Object #Enfant de Glib::Object.
#Parent de Widget, CellRenderer et TreeViewColumn.
Interface #Wrapper autour d'un parent GObject interface. Parent d'Activatable, AppChooser, Buildable,
#CellEditable, CellLayout, Editable, FileChooser, FontChooser, Orientable, PrintOperationPreview,
#RecentChooser, Scrollable, StyleProvider, ToolShell, TreeDragDest, TreeDragSource, TreeModel,
#TreeSortable.
Main #Enfant de sigc::trackable. Son instantiation effectue un init(). L'instantier avant toute autre
#opération. Singleton.
MAIN( argc, argv # - effectue un init()
[, BOOL_VAL] ) # - parse les command-line arguments relatifs à GTK et les enlève d'argv
# - si true (défaut true), effectue un setlocale( LC_ALL, "" ). Cependant, pour le C++, il faut faire
# soi-même aussi un std::locale::global( std::locale( "" ) ) *après* MAIN().
#En C : gtk_init( &argc, &argv )
Main::run( WINDOW ) #Lance la main loop en instantiant WINDOW et tous ses membres (mais ne les montre pas : il faut faire
MAIN.run( WINDOW ) #un show_all() pour les non-WINDOW et un WINDOW.show() pour les WINDOW membres.
#On peut invoquer Main::run() à l'intérieur d'une GTK main loop, faisant une main loop récursive.
#En C : gtk_main()
Main::quit() #Quitte la main loop.
#En C : doit le lier au signal "delete-event" de la main Window.
Main::level() #Renvoie le nombre de main loops récursives sous forme d'UINT_VAL.
Widget #Enfant de Buildable et Object. Base classe abstraite pour tous les widgets.
WIDGET.show() #Montre le WIDGET. Tout WIDGET est construit à l'instantiation, mais pas montré : faire show().
#Un WIDGET n'est pas montré si son container parent ne l'est pas.
WIDGET.show_all() #Montre le WIDGET et ses enfants.
WIDGET.hide() #Contraire de show()
WIDGET.set_visible #
( [BOOL_VAL] ) #Si true (défaut true), effectue show(), sinon effectue hide().
WIDGET.get_visible() #Renvoie true si show() a été appelé, et qu'aucun hide() n'a eu lieu entre temps.
WIDGET.grab_focus() #WIDGET prend le focus. Certains WIDGET ne peuvent pas avoir le focus (par exemple Label)
WIDGET.is_focus() #Renvoie true si WIDGET a le focus dans sa fenêtre.
WIDGET.has_focus() #Pareil, mais en plus la fenêtre doit elle-même avoir le focus.
WIDGET.{g,s}et_can_focus#Si false (défaut true), WIDGET ne peut plus avoir le focus (et donc on ne peut plus non plus agir
( [BOOL_VAL] ) #avec)
WIDGET.grab_default() #Fait que WIDGET emettra signal activate (clicked pour un Button) à toute pression de Entrée sur cette
#fenêtre. Si focus est dans une ENTRY, set_activates_default() doit être à true (défaut false) en plus.
#Pour pouvoir faire grab_default(), il faut avoir fait un set_can_default avant.
#Par défaut, aucun WIDGET n'est default.
WIDGET.hash_default() #
WDGT.{g,s}et_can_default#
( [BOOL_VAL] ) #(défaut true) (sinon false)
WIDGET.{g,s}et_receives_#
default( [BOOL_VAL] ) #Fait que grab_default() est appelé tant que WIDGET a le focus (défaut true) (sinon false)
WIDGET.{add,remove}_
modal_grab() #Fait que WIDGET et ses enfants deviennent seules WIDGETS avec lesquels on peut interagir.
WIDGET.{g,s}et_state #Parmi (or'd) :
( STATETYPE ) # - STATE_NORMAL : non-sélectionné, aucun des autres
# - STATE_ACTIVE : effectue une action
# - STATE_PRELIGHT : survol du widget, avec un clic pouvant faire action
# - STATE_SELECTED : sélectionné
# - STATE_INSENSITIVE : non-sensitive
# - STATE_INCONSISTENT : problème
# - STATE_FOCUSED : a le focus
WIDGET. #STATEFLAG : comme STATETYPE, mais STATE_FLAG_*
{g,s}et_state_flags #Fait que ce STATE est ajouté aux STATE courants du WIDGET. Si true, clear les anciens STATE.
( STATEFLAG[, BOOL_VAL])#A ne faire que sur des WIDGET dérivés user-defined, pour permettre bon fonctionnement d'autres
#fonctions.
WIDGET.{g,s}et_sensitive#Si false (défaut true) (sinon true), WIDGET est visible, mais mis en gris et pas d'interaction
( [BOOL_VAL] ) #possible.
WIDGET.is_sensitive() #Comme get_sensitive, mais en prenant en compte les parents.
WIDGET.
get_preferred_height #Renvoie dans les références : dans INT_VAR1 la taille minimale, même après redimensionnement, dans
( 2 INT_VAR ) #INT_VAR2 la taille que GTK choisira, en dehors de toute autre contrainte.
WIDGET.get_preferred_ #
width( 2 INT_VAR ) #Même chose pour largeur.
WIDGET.
get_preferred_*_for_* #* est "height" si le second est "width", et inversement. Comme get_preferred_*, mais choisit une
( INT_VAL, ... ) #taille INT_VAL pour le premier *, et calcule le résultat pour le second *
WIDGT.get_request_mode()#Renvoie le SIZEREQUESTMODE parmi : SIZE_REQUEST_{HEIGHT_FOR_WIDTH,WIDTH_FOR_HEIGHT,CONSTANT_SIZE}
#décidant si l'on utiliser get_preferred_height_for_width() ou le contraire.
WIDGET.{g,s}et_size_
request( 2 INT_VAL ) #Cf WINDOW.set_size_request()
WIDGET.get_width() #
WIDGET.get_height() #
WIDGET.get_allocated_* #Comme get_*, ne voit pas la différence.
WIDGT.{g,s}et_allocation#
( GDK::RECTANGLE ) #Modifie coordonnées locales par rapport à la toplevel WINDOW.
WIDGET.{g,s}et_
{h,v}expand( [BOOL_VAL])#Modifie le fait que le WIDGET prend tout l'espace disponible horizontalement/verticalement.
WIDGET.{g,s}et_{h,v}
expand_set( [BOOL_VAL] )#Modifie le fait que {h,v}expand() sera utilisé
WIDGT.{g,s}et_{h,v}align#
( ALIGN ) #Modifie l'alignement.
WIDGET.{g,s}et_margin_
{top,bottom,left,right} #
( INT_VAL ) #Modifie le padding interne.
WIDGET.get_window() #Renvoie la GDK::WINDOW sous-jacente à WIDGET, sous forme de REFPTR<GDK::WINDOW>.
#Renvoie smart pointer null si WIDGET n'est pas realized : à mettre donc dans un handler du signal
#realize de WIDGET (et non d'un de ses parents, sinon c'est la WINDOW de ce parent qui est renvoyée
#si WIDGET pas encore realized).
WIDGET.get_parent() #Renvoie le CONTAINER parent, sous forme de CONTAINER_ADR (NULL si pas de parent)
WIDGET.{g,s}et_
parent_window() #Equivaut à WIDGET.get_parent()->get_window(), sauf qu'il y a un set*
WIDGET.reparent #
( WIDGET2_VAR ) #WIDGET2 devient le nouveau parent de WIDGET.
WIDGET.set_parent #
( WIDGET_VAR ) #A faire seulement lorsque l'on définit son propre Container
WIDGET.unparent() #Pareil.
WIDGET.is_ancestor #
( WIDGET2_VAR ) #Renvoie true s'il est son enfant ou dans sa descendance.
WIDGET.get_toplevel() #Renvoie le toplevel CONTAINER_ADR
WIDGET.get_root_window()#Renvoie la root REFPTR<GDk::WINDOW>
WIDGET.get_is_toplevel()#Renvoie true si WINDOW, INVISIBLE ou PLUGS.
WINDOW.get_visual() #Renvoie REFPTR<VISUAL>
WINDW.{get,has}_screen()#Sous REFPTR<SCREEN>
WINDOW.get_display() #Renvoie REFPTR<DISPLAY>
WIDGET.
translate_coordinates #
( WIDGET2_VAR, 2 INTVAL,#Traduit les coordonnées INT_VAL1,INT_VAL2 locaux à WIDGET en coordonnées INT_VAR1,INT_VAR2 locaux à
2 INT_VAR ) #WIDGET2.
WIDGET.intersect #
( GDK::RECTANGLE1 #Si GDK::RECTANGLE2, renvoie l'intersection (coordonnées locales selon window principale ?) de
[, GDK::RECTANGLE2_VAR])#WIDGET et de GDK::RECTANGLE1. Si intersection, renvoie true.
WIDGET.region_intersect #
(REFPTR<CAIRO::REGION> )#Même chose, mais avec une CAIRO::REGION
WIDGET.get_pointer #
( 2 INT_VAR ) #Cf GDK::WINDOW
WIDGET.{input_,}shape_
combine_region( CAIRO:: #
REFPTR<CAIRO::REGION> ) #Cf GDK::WINDOW.
WIDGET.is_composited() #Renvoie true si l'on peut utiliser l'alpha channel (true sous Windows en général, true sous Linux si
#Compiz ou autre)
WIDGET.get_is_drawable()#
WIDGET.get_realized() #
WIDGET.get_mapped() #
WIDGET.{g,s}et_app_
paintable( [BOOL_VAL] ) #Intention de peindre sur WIDGET dans un handler du signal draw
WIDGET.{g,s}et_child_
visible( [BOOL_VAL] ) #Si true, les enfants de WIDGET sont show(), si WIDGET est show()
WIDGET.[un]map() #A utiliser seulement par des WIDGET personnalisés.
WDGT.create_pango_layout#
( USTRING ) #Cf GDK::WINDOW. En plus, le PANGO::LAYOUT retourné doit pouvoir afficher USTRING.
WIDGET.
create_pango_context() #Pareil mais pour un PANGO::CONTEXT et ne met pas à jour WIDGET.
WDGT.get_pango_context()#Pareil mais met à jour WIDGET.
WIDGET.{g,s}et_events
( GDK::EVENTMASK ) #Cf GDK::WINDOW
WIDGET.add_events
( GDK::EVENTMASK ) #Pareil, mais en add() (ne fait pas de clear)
WIDGET.*_device_events* #Cf GDK::WINDOW
WIDGET.{g,s}et_
device_enabled #
( REFPTR<GDK::DEVICE>
[, BOOL_VAL] ) #Si false, DEVICE ne peut plus interagir avec WIDGET.
WIDGET.override_font #
(PANGO::FONTDESCRIPTION)#Modifie la FONTDESCRIPTION utilisée par défaut pour ce WIDGET (non-récursif)
WIDGET.override_color
(GDK::RGBA[, STATEFLAG])#Pareil mais pour la couleur de police, et peut limiter à un STATEFLAG (par défaut tous)
WIDGET.override_
background_color
(GDK::RGBA[, STATEFLAG])#Pareil mais pour la couleur d'arrière-plan de police.
WIDGET.override_cursor
(GDK::RGBA1, GDK::RGBA2)#Pareil mais pour la couleur du curseur primaire et secondaire d'un Entry ou TextView.
WIDGET.unset_*() #Supprime l'effet d'override_*()
WIDGET.set_accel_path #
( USTRING,
REFPTR<ACCELGROUP> ) #Modifie l'accel path et l'AccelGroup.
WIDGET.add_accelerator #
( USTRING, #Modifie l'AccelGroup et attribue un raccourci, pour activer le signal USTRING de WIDGET (sans avoir
REFPTR<ACCELGROUP>, #à définir d'accel path). Le signal doit activer lui-même "activate", par exemple "clicked".
UINTVAL,GDK::MODIFIRTYP,#Utiliser get_accel_group()
ACCELFLAGS ) #ACCELFLAGS parmi : ACCEL_{VISIBLE,LOCKED,MASK}
WIDGT.remove_accelerator#
( REFPTR<ACCELGROUP>,
GDk::MODIFIERTYPE )
WIDGET.activate() #Emet le signal activate si le WIDGET enfant l'a défini.
WIDGET.{g,s}et_tooltip_ #
{text,markup}( USTRING )#Modifie le tooltip, avec ou sans markup HTML.
WDGT.{g,s}et_has_tooltip#
( [BOOL_VAL] )
WIDGET.
{g,s}et_tooltip_window #
( WINDOW_VAR ) #Remplace la WINDOW d'arrière-plan des tooltips par défaut (sinon WINDOW vide et jaune)
Widget::{push,pop}_ #Si on définit un Widget perso, et que celui-ci contient lui-même des WIDGET, mais qu'on ne veut pas
composite_child() #les exposer, faire entre un push* et un pop*
WIDGET.{g,[un]s}et_
composite_name( USTRING)#Nom d'un tel WIDGET
WIDGET.{g,s}et_direction#
( TEXTDIRECTION ) #
Widget::{g,s}et_default_
direction(TEXTDIRECTION)#
WIDGET.get_accessible() #Renvoie le REFPTR<ATK::OBJECT> associé.
Container #Enfant de Widget. Base classe abstraite pour les containers : widgets pouvant contenir d'autres
#widgets.
#Il est possible pour un container de contenir un WIDGET déjà contenu par un autre container.
CONTAINER.add(WIDGET) #Ajoute WIDGET dans le CONTAINER
CONTAINER.remove(WIDGET)#Supprime WIDGET dans le CONTAINER
CONTAINER.{s,g}et_
border_width(UINTVAL) #Fait que CONTAINER a une inner marge de UINT_VAL pixels par rapport au widget qu'il contient
CONTAINER.
show_all_children
([BOOL_VAL]) #Comme show_all(), sauf que si false (par défaut true), n'est pas récursif.
CONTAINER.{g,[un]s}et_
focus_chain #
( VECTOR<WIDGET_ADR> ) #Modifie tab order.
CONTANR.property_child()#PROPW <Widget*>
/=+===============================+=\
/ : : \
)==: WINDOW :==(
\ :_______________________________: /
\=+===============================+=/
Window #Enfant de Bin. Fenêtre. Il s'agit du container "top level" en général.
#Ne pas oublier de faire un show_all_children() pour tout WINDOW, donc DIALOG.
#Pour ouvrir une WINDOW membre d'une autre WINDOW, suffit de faire un show() (non-bloquant), car déjà
#instantiée. Pour fermer celle-ci, faire hide().
#Pour mettre un handler sur la fermeture : signal delete_event().
Window::{g,s}et_
default_icon_* #Equivaut à set_icon_*, mais agit au cas où aucun set_icon_* n'a été appelé (default taskbar icon)
Window::set_auto_
startup_notification #Mettre false pour un splash screen, puis remettre à true quand la fenêtre principale est prête à être
( [BOOL_VAL] ) #affichée.
Window::list_toplevels()#Renvoie toutes les WINDOW toplevel, sous forme de VECTOR<WINDOW_ADR>
WINDOW( [WINDOWTYPE] ) #WINDOWTYPE est par défaut WINDOW_TOPLEVEL. Si WINDOW_POPUP, quelques changements : notamment pas de
#bordure, pas de prise en charge de nombreuses choses. Utilisé non pour les popups, mais pour les
#tooltips et MenuItem.
WINDOW.get_window_type()#Renvoie le WindowType de WINDOW : cf GDK::WINDOWTYPE
WINDOW.move( 2 INT_VAL )#Cf GDK::WINDOW
WINDOW.get_position
( INT_VAR1, INT_VAR2 ) #Cf GDK::WINDOW
WINDOW.get_size #
( 2 INT_VAR )
WINDOW.{g,s}et_default_ #
size(INT_VAL1, INT_VAL2)#Taille à l'ouverture (si -1 : laissé tel quel).
WINDOW.{g,s}et_geometry_
hints( WIDGET_VAR, #Comme GDK::WINDOW.set_geometry_hints(), mais pour un WIDGET de la WINDOW (peut être la WINDOW elle-
GEOMETRY, WINDOWHINTS ) #même)
WINDOW.{g,s}et_size_ #
request( 2 INT_VAL ) #Taille minimale (si -1 : pas de minimum)
WINDOW.resize(INT_VAL1, #
INT_VAL2) #Une valeur de -1 signifie : laisser tel quel.
WINDOW.reshow_ #
with_initial_size() #hide(), puis show() avec la taille et position initiale.
WINDOW.{g,s}et_resizable#
( BOOL_VAL ) #Si false, impossible de Redimensionner, dont par set_default_size ou autre.
WINDOW.
{g,s}et_has_resize_grip
( [BOOL_VAL] ) #Si false, pas de corner resize grip (mais supprime pas possibilité de redimensionner)
WINDOW.set_position #Modifie la position de WINDOW parmi l'enum WindowPosition :
( WINDOWPOSITION ) # - WIN_POS_NONE : position par défaut.
# - WIN_POS_CENTER[, ALWAYS] : centre de l'écran
# - WIN_POS_CENTER_ON_PARENT : au-dessus de la fenêtre parente, pour une popup
# - WIN_POS_ON_MOUSE : endroit courant de la souris
WINDOW.activate_focus() #Emet signal activate() du WIDGET ayant le focus dans WINDOW, et renvoie true si ok.
WINDOW.{g,s}et_accept_
focus( [BOOL_VAL] ) #Cf GDK::WINDOW
WINDOW.{g,s}et_focus_
on_map( [BOOL_VAL] ) #Cf GDK::WINDOW
WINDOW.{g,[un]s}et_focus#
( WIDGET_VAR ) #WIDGET devient celui ayant le focus dans WINDOW.
WINDW.activate_default()#Comem activate_focus(), mais pour WIDGET default (cf WIDGET.is_default())
WINDOW.[un]set_default #
( WIDGET_VAR )
WINDOW.{g,s}et_modal #
( [BOOL_VAL] )
WINDOW.raise() #
WINDOW.[un]stick() #
WINDOW.[de]iconify() #
WINDOW.[un]maximize() #
WINDOW.[un]fullscreen() #
WINDOW.set_keep_{above,
below}( [BOOL_VAL] ) #
WINDOW.present() #Fait deiconify(), raise(), show(), déplace WINDOW sur bureau courant et/ou focus() pour que l'user
#voit la WINDOW et aie le focus.
WINDOW.{s,g}et_title #
(USTRING) #Cf GDK::WINDOW.
WINDOW.{g,s}et_opacity #
( DOUBLE_VAL ) #Cf GDK::WINDOW
WINDOW.{g,s}et_decorated#
( BOOL_VAL ) #Si false, pas de bordure de fenêtre.
WINDOW.{g,s}et_type_hint#
( GDK::WINDOWTYPEHINT ) #Cf GDK::WINDOW
WINDOW.{g,s}et_skip_
taskbar_hint([BOOL_VAL])#Cf GDK::WINDOW
WINDOW.{g,s}et_skip_
pager_hint( [BOOL_VAL] )#Cf GDK::WINDOW
WINDOW.{g,s}et_urgency_
hint( [BOOL_VAL] ) #Cf GDK::WINDOW
WINDW.{g,s}et_mnemonics_#
visible( [BOOL_VAL] ) #(défaut true) (sinon true)
WINDOW.{g,s}et_screen #
( REFPTR<SCREEN> ) #Modifie le SCREEN.
WINDOW.get_group() #Renvoie le REFPTR<WINDOWGROUP> auquel appartient WINDOW. Permet de grouper les WINDOW à des fins
#logiques. Un WindowGroup a seulement des fonctions {add,remove}_window( WINDOW_VAR ), et est créé
#via WindowGroup::create().
WINDOW.{g,s}et_icon_list
(VECTOR<REFPTR<PIXBUF>>)
WINDOW.{g,s}et_icon
( REFPTR<PIXBUF> )
WINDW.{g,s}et_icon_name
( USTRING )
WNDW.set_icon_from_file #
( STRING ) #Modifie icône de la taskbar. icon_list : choisit en fonction de la taille.
Dialog #Enfant de Window, désigne une pop-up window.
#Est composé à l'initialisation d'une VBox vide et d'une ButtonBox, séparés par un HSeparator.
#Ne communique qu'un RESPONSETYPE à la fenêtre parente. Pour communiquer un autre objet, le passer
#par référence au constructor d'un enfant user-defined de DIALOG.
#Pour ouvrir un DIALOG : run() (pas bloquant mais modal), show() (pas bloquant et non modal)
#Pour fermer un DIALOG : hide()
DIALOG(USTRING #Instantie un DIALOG avec le titre STRING, et désigne WINDOW (par défaut aucune) comme son parent.
[,WINDOW][, BOOL_VAL]) #Si true, fenêtre "modale" : la fenêtre parent devient bloquée tant que DIALOG est ouvert.
#Eviter fenêtres modales.
DIALOG.run() #Lance DIALOG et bloque jusqu'à sa fermeture, et renvoie le RESPONSETYPE émit.
DIALOG.response #Emet le signal "response", avec ResponseType en paramètre, parmi :
( RESPONSETYPE ) #RESPONSE_{NONE,REJECT,ACCEPT,DELETE_EVENT,OK,CANCEL,CLOSE,YES,NO,APPLY,HELP} (namespace global)
#On peut aussi utiliser un autre INT_VAL.
DIALOG.add_button #Rajoute un BUTTON dans la BUTTONBOX principale, instantié avec USTRING, et le renvoie sous forme de
( USTRING, #BUTTON_ADR. Une fois cliqué, ce bouton émettra un signal "response", avec RESPONSE_TYPE en
RESPONSETYPE ) #paramètre. DIALOG sera parfois fermé, en fonction du RESPONSETYPE.
DIALOG.add_button #
(STOCKID,RESPONSTYPE) #Même chose, mais avec un STOCKID remplissant le BUTTON d'un label + image.
DIALOG.add_action_widget#
(WIDGET, RESPONSTYPE) #Même chose, mais avec un WIDGET.
DIALOG.
set_default_response #Le WIDGET avec RESPONSETYPE devient celui par défaut appelé lors d'un Entrée. Ne marche pas sur
( RESPONSETYPE ) #certains enfants prédéfinis de Dialog.
DIALOG.
get_widget_for_response #
( RESPONSETYPE ) #Renvoie le WIDGET ayant RESPONSETYPE.
DIALOG.
get_response_for_widget #
( WIDGET ) #Renvoie le RESPONSETYPE de WIDGET.
DIALOG.set_alternative_
button_order_from_array #
(VECTOR<RESPONSETYP>) #Modifie ordre des boutons.
DIALOG.
set_response_sensitive #
( RESPONSETYPE #Appelle set_sensitive( BOOL_VAL ) (défaut true) (sinon true) sur les WIDGET ayant RESPONSETYPE,
[, BOOL_VAL] ) #les désactivant ou non.
DIALG.get_content_area()#Renvoie la VBOX_ADR principale.
DIALOG.get_action_area()#Renvoie la BUTTONBOX_ADR principale.
MessageDialog #Enfant de Dialog, désigne une popup affichant un message.
#La VBOX principale est composée d'un WIDGET principal (en général une image) et de deux LABEL (le
#deuxième LABEL est vide par défaut).
#La BUTTONBOX ainsi que la VBOX dépendent de l'instantiation.
MESSAGEDIALOG #Instantie un MESSAGEDIALOG : le premier LABEL est USTRING, l'image dépend de GTK::MESSAGETYPE, les
( [WINDOW_VAR, ]USTRING # - WINDOW_VAR est le parent
[,BOOL_VAL1[,MESSAGETYPE# - USTRING le premier LABEL
[, BUTTONSTYPE # - Si BOOL_VAL1 est true, on peut utiliser du Pango markup (défaut false)
[, BOOL_VAL2]]]]) # - MESSAGETYPE change l'image, parmi MESSAGE_{INFO,WARNING,QUESTION,ERROR,OTHER}. OTHER n'a pas
# d'image. (défaut MESSAGE_INFO)
# - BUTTONSTYPE change les boutons, parmi BUTTONS_{NONE,OK,CLOSE,CANCEL,YES_NO,OK_CANCEL}. Instantie
# un bouton avec ce même nom, émettant un RESPONSE_* en fonction du nom. NONE : pas de bouton.
# (défaut MESSAGE_OK)
# - Si BOOL_VAL2 est true : fenêtre modale (défaut false)
MESSAGEDIALOG.
set_message #
( USTRING[, BOOL_VAL] ) #Modifie le premier LABEL. BOOL_VAL est même que BOOL_VAL1 de l'instantiation.
MESSAGEDIALOG.
set_secondary_text #
( USTRING ) #Pareil pour le second LABEL
MESSAGEDIALOG.
{s,g}et_image
(WIDGET_VAR) #Modifie le widget principal.
MESSAGEDIALOG.
get_message_area() #Renvoie la BOX_ADR principale.
AboutDialog #Enfant de Dialog. About dialog : en général afficher après clic sur "About MyProgram", en bas de la
#teardown list du menu "Help", à droite de la menu bar.
#Par défaut juste Button "Close".
#Définit une série de {g,s}et_*() :
# - program_name ( USTRING ) : "Stego++"
# - version ( USTRING ) : "1.0.1"
# - logo ( REFPTR<GDK::PIXBUF> )
# - logo_icon_name ( USTRING ) : utilise un icon name au lieu de PIXBUF
# - comments ( USTRING ) : "A high-quality steganographic library"
# - website ( USTRING ) : "http://www.stegopp.com"
# - website_label ( USTRING ) : "Homepage"
# - copyright ( USTRING ) : "Copyright © 2001-2006 Joaquin Abela, Paolo Borelli, et al."
# - license ( USTRING ) : "Stego++ ... texte de la LGPL". Affiché dans un bouton "License"
# - wrap_license ( BOOL_VAL ): si true, wrap le texte : le faire
# - license_type ( LICENSE ) : Parmi : LICENSE_{UNKNOWN,CUSTOM,GPL_2_0,GPL_3_0,LGPL_2_1,
# LGPL_3_0,BSD,MIT_X11,ARTISTIC}. Annule license(). Préférer
# license()
#Affiché dans un bouton "Credits" :
# - authors ( VECTOR<USTRING> ) : "Adrien Amo http://www.aamo.com" "Benabar Bono
# http://bbono.com"
# - documenters ( VECTOR<USTRING> ) : Pareil
# - artists ( VECTOR<USTRING> ) : Pareil
# - translation_credits( USTRING ) : "Win Yi (中文)\nHans Mühlen (Deutsch)"
Assistant #Désigne une fenêtre avec un ensemble de steps.
#Avant d'afficher l'ASSISTANT, ne pas oublier de :
# - mettre bien toutes les pages
# - faire un ASSISTANT.show_all_children()
#La page index est le numéro du step courant : -1 si ASSISTANT pas lancé, 0 au début, puis 1, 2, etc.
#Un step est composé :
# - d'un WIDGET principal : cf *page(), get_nth_page()
# - un titre USTRING affiché à gauche : cf *et_page_title()
#Chaque step a des boutons par défaut en fonction de l'ASSISTANTPAGETYPE
# - "Go back" : revient à dernière page. Bouton apparaissant automatiquement si dernière action a
# été un "Continue"
# - "Continue" : invoque next_page(), est grisé si get_page_complete() == false (défaut). Permet
# de bloquer le flow tant qu'une condition sur la page n'est pas remplise.
# - "Cancel", "Apply" et "Close" : ne fait rien sans handler, mais invoque chacun un signal
#L'assistant garde toutes les pages en mémoire => il y a un historique en cas de retour en arrière.
#Les différents ASSISTANTPAGETYPE sont :
# - ASSISTANT_PAGE_INTRO : "Cancel" + "Continue" (défaut pour première page)
# - ASSISTANT_PAGE_CONTENT : "Cancel" + "Continue" (défaut pour autres pages)
# - ASSISTANT_PAGE_CONFIRM : "Cancel" + "Apply" (pas défaut pour dernière page -> le faire)
# - ASSISTANT_PAGE_SUMMARY : "Close" (peut aussi servir de dernière page)
# - ASSISTANT_PAGE_PROGRESS : "Cancel"
# - ASSISTANT_PAGE_CUSTOM : rien
ASSISTANT.insert_page #
( WIDGET_VAR, INT_VAL ) #Rajoute un step avant le step INT_VAL, dont le WIDGET principal est WIDGET_VAR.
ASSISTANT.append_page #
( WIDGET_VAR )
ASSISTANT.prepend_page #
( WIDGET_VAR )
ASSISTANT.remove_page #
( INT_VAL )
ASSISTANT.get_n_pages() #Renvoie nombre de pages, sous forme d'INT_VAL
ASSISTANT.get_nth_page #
( INT_VAL ) #Renvoie le WIDGET_ADR principal du step numéro INT_VAL
ASSISTANT.
{g,s}et_current_page #
( INT_VAL )
ASISTANT.previous_page()#
ASSISTANT.next_page() #Modifie le page index courant, et montre le step du nouveau page index.
ASSISTANT. #Modifie le fait que le bouton principal ("Continue", "Apply" ou "Cancel" selon ASSISTANTPAGETYPE,
{g,s}et_page_complete #mais pas "Close") soit sensitive (défaut true) (sinon false) pour la page dont le WIDGET principal
( WIDGETVAR[, BOOL_VAL])#est WIDGET_VAR. *get prend un WIDGET_VAR en argument.
ASSISTANT.
{g,s}et_page_title #
( WIDGET_VAR, USTRING ) #Modifie le titre de la page dont WIDGET_VAR est le widget principal.
ASSISTANT.
{g,s}et_page_type #
( WIDGET_VAR #Modifie les boutons de la page dont WIDGET_VAR est le widget principal, en fonction
[, ASSISTANTPAGETYPE] ) #d'ASSISTANTPAGETYPE.
ASSISTANT.{add,remove}_
action_widget(WIDGETVAR)#Ajoute/Supprime un WIDGETVAR (en général un bouton) dans la zone à boutons.
ASSISTANT.
set_forward_page_func #Change la fonction invoquée par bouton "Continue" : invoque PREDIC, prenant un INT_VAL comme
( PREDIC ) #argument (numéro de page courante), et renvoyant un INT_VAL (numéro de page où aller)
Plug #Enfant de Window. La WINDOW est invisible, mais si l'on instantie un SOCKET avec son window id, elle
#est affichée dans SOCKET.
# - Stocker window id de PLUG.
# - Lancer PLUG via Gtk::Main::run( PLUG ) : cela est bloquant.
# - Instantier dans un autre process une SOCKET avec le window id du PLUG, qui est alors affiché dans
# SOCKET.
# - lors de la fermeture de SOCKET, PLUG ferme et Gtk::main::run( PLUG ) quitte.
#Pas possible de mettre plus d'un PLUG par SOCKET.
#Les window id sont des INT_VAL stockés dans des typedefs nommés WINDOW, namespace global :
# ::WINDOW_VAL (différent de GTK::WINDOW et de GDK::WINDOW)
#A noter que Qt a le même principe avec le même protocole, ce qui permet de mettre des widgets Qt dans
#Gtkmm, et inversement.
PLUG( [[REFPTR<GDK::
DISPLAY>,]::WINDOW_VAL])#Instantie un PLUG dont le window id est ::WINDOW_VAL (par défaut l'id de la fenêtre courante)
PLUG.get_id() #Renvoie le ::WINDOW_VAL
PLUG.is_embedded() #Renvoie true si une SOCKET est actuellement connectée.
PLUG.get_socket_window()#Renvoie cette SOCKET sous forme de REFPTR<GDK::WINDOW>, ou 0 si pas connecté.
Socket #Enfant de Container. Affiche le contenu d'un PLUG.
SOCKET.add_id #
( ::WINDOW_VAL ) #Connecte à la plug dont le window id est ::WINDOW_VAL
SOCKET.get_id() #
SOCKET.get_plug_window()#Comme PLUG.get_socket_window()
/=+===============================+=\
/ : : \
)==: BUTTON :==(
\ :_______________________________: /
\=+===============================+=/
Button #Enfant de Bin et d'Activatable. Bouton.
#A un enfant, souvent un label, mais peut aussi avoir un WIDGET (souvent une IMAGE) en plus ou à la
#place.
#Pour avoir à la fois un label et un WIDGET, mettre gtk_button_images des default Settings à true.
BUTTON(USTRING
[, BOOL_VAL]) #USTRING est le label. Si true (défaut false) (sinon false), mnemotechnics.
BUTTON.{g,s}et_label #
( USTRING ) #Modifie le label.
BUTTON.{g,s}et_relief #Modifie le relief du bouton, hors mouse over : RELIEF_NORMAL (normal), RELIEF_HALF (accentué),
( RELIEFSTYLE ) #RELIEF_NONE (pas de relief)
BUTTON.{g,s}et_image
( WIDGET ) #Modifie le WIDGET.
BUTTON.{g,s}et_use_stock#Si true, set_label() utilise StockID( USTRING ).get_label(), sans le "_", et non USTRING (sinon false)
( [BOOL_VAL] ) #pour le label, et rajoute l'icône associé à ce STOCKID comme WIDGET (défaut true)
BUTTON.set_alignment #
( FLOAT_VAL1,FLOAT_VAL2)#Modifie l'alignement de l'enfant.
BUTON.set_image_position
( POSITIONTYPE ) #Modifie position du WIDGET par rapport au label.
BUTTON.get_alignment #
( FLOAT_VAR1,FLOAT_VAR2)#Utilise les références.
ToggleButton #Enfant de Button : bouton restant activé après relâchement du clic si était désactivé.
TOGGLEBUTTON.{g,s}et_
active([BOOL_VAL]) #TOGGLEBUTTON devient pressé si BOOL_VAL est true (défaut), ou non-pressé sinon.
TOGGLEBUTTON.toggled() #Toggle le bouton.
CheckButton #Enfant de ToggleButton, même chose, seule l'apparence change (check box)
RadioButtonGroup #Groupe de RadioButton. Par défaut un RadioButton créé vient avec son propre groupe.
RadioButton #Enfant de CheckButton. Cliquer sur l'un décoche les autres du même RadioButton::group
RADIOBUTTON
( RADIOBUTTONGROUP_VAR
[, USTRING[, BOOL_VAL]])#Rajoute RADIOBUTTON à RADIOBUTTONGROUP_VAR
RADIOBUTON.
{g,[re]s}et_group #
(RADIOBUTTONGROUP_VAR) #Rajoute RADIOBUTTON à RADIOBUTTONGROUP_VAR
RADIOBUTTON.join_group
( RADIOBUTTON2 ) #Rajoute RADIOBUTTON au GROUP_VAR de RADIOBUTTON2
LinkButton #Enfant de Button. Bouton avec lien hypertexte + label.
LINKBUTTON( [USTRING1
[, USTRING2]] ) #USTRING1 est l'URI du lien, USTRING2 le label.
LINKBUTTON.{g,s}et_uri #
( USTRING )
LINKBUTTON.
{s,g}et_visited() #Renvoie true si déjà cliqué dessus.
ScaleButton #Bouton qui affiche une Scale avec un icône "+" en haut et un icône "-" en bas.
#Instantiation semble provoquer un bug avec Gtkmm. Solution : utiliser un VolumeButton, ou Glade.
SCALEBUTTON( ICONSIZE, #ICONSIZE est celui du Bouton. Les DOUBLE_VAL sont le min, max puis step de l'ADJUSTMENT sous-jacent.
3 DOUBLE_VAL, #Les USTRING sont les icon names de l'icône du bouton : l'icône changera en fonction de la value, de
VECTOR<USTRING> ) #manière uniforme entre le premier icon name et le dernier.
SCALEBUTTON.set_icons #
( VECTOR<USTRING> )
SCALEBUTON.{g,s}et_value#
( DOUBLE_VAL ) #Value de l'ADJUSTMENT sous-jacent.
SCALEBUTTON.
{g,s}et_adjustment #
( REFPTR<ADJUSTMENT> )
SCALEBUTTON.get_
{plus,minus}_button() #Renvoie les icônes "+" ou "-" sous forme de WIDGET_ADR.
SCALEBUTTON.get_popup() #Renvoie le WIDGET_ADR contenant le SCALE.
VolumeButton #Enfant de ScaleButton, avec un min de 0, max de 100, step de 2, et un ensemble d'icônes de volume
#(je crois "audio-volume*")
/=+===============================+=\
/ : : \
)==: BIN :==(
\ :_______________________________: /
\=+===============================+=/
Bin #Enfant de Container. Base classe abstraite, désignant les containers ne pouvant contenir qu'un seul
#WIDGET.
BIN.remove() #Supprime le WIDGET du CONTAINER
BIN.get_child() #Renvoie le WIDGET du CONTAINER, sous forme de WIDGET_ADR.
Frame #Enfant de Bin. Encerclant le widget qu'il contient d'un rectangle avec titre
FRAME([USTRING]) #Effectue un set_label( USTRING ) (par défaut "")
FRAME.[un]{g,s}et_label #
(USTRING) #Modifie le titre de FRAME.
FRAME.set_label_align #
(ALIGN1, ALIGN2) #Modifie l'alignement horiz. et vert. du label, parmi ALIGN_{FILL,START,CENTER,END}
FRAME.set_label_align
(DOUBLE_VAL1,DOBLE_VAL2)#Même chose, avec des DOUBLE (0 à 1). Si passage par référence, possibilité de modifier après.
FRAM.{g,s}et_shadow_type
(SHADOWTYPE) #Modifie le type d'ombre parmi : SHADOW_{NONE,IN,OUT,ETCHED_IN,ETCHED_OUT}
AspectFrame #Enfant de Frame.
#Frame dont le ratio hauteur / largeur est toujours le même (par exemple pour ne pas étirer une image)
#Si enfants ne tiennent pas, ils sont tronqués, pas de scrollbars.
ASPECTFRAME([USTRING
[, ALIGN1[, ALIGN2 #Construit un ASPECTFRAME, avec le titre USTRING (par défaut ""), l'alignement horizontal et vertical
[, FLOAT_VAL #ALIGN1 et ALIGN2 et le rapport largeur / hauteur FLOAT_VAL. Le ratio est ignoré si BOOL_VAL == false.
[, BOOL_VAL]]]]]) #On peut aussi utiliser des FLOAT_VAL au lieu des ALIGN.
ASPECTFRAME.set( ARGS ) #Comme constructor, même argument, sauf pas d'USTRING.
property_*() #PROP <float> : xalign, yalign, ratio ; PROP <bool> : obey_child
ScrolledWindow #Enfant de Bin et de Scrollable. Ajoute des scrollbars horizontale et verticale à son enfant.
#Si enfant n'est pas Scrollable lui-même, il faut mettre un VIEWPORT dans SCROLLEDWINDOW, et l'enfant
#dans le VIEWPORT.
SCROLLEDWINDOW() #Constructor vide
SCROLLEDWINDOW
(REFPTR<ADJUSTMENT1>,
REFPTR<ADJUSTMENT2>) #Constructor avec deux ADJUSTMENT pour la barre horizontale et verticale.
SCROLLEDWINDOW.
{g,s}et_*adjustment #
( REFPTR<ADJUSTMENT> ) #Pour hadjustment ou vadjustment.
SCROLLEDWINDOW.
{g,s}et_shadow_type #
(SHADOWTYPE) #Modifie le type d'ombre parmi : SHADOW_{NONE,IN,OUT,ETCHED_IN,ETCHED_OUT} (défaut : NONE)
SCROLLEDWINDOW.
{g,s}et_policy
(POLICYTYPE1,POLICYTYP2)#Modifie l'apparition des Scrollbars parmi : POLICY_{NEVER,AUTOMATIC,ALWAYS} (défaut : AUTOMATIC)
SCROLLEDWINDOW.
[un]{g,s}et_placement #Modifie l'endroit d'apparition des Scrollbars horiz. et vert. pami : CORNER_{BOTTOM,TOP}_{LEFT,RIGHT}
( CORNERTYPE ) #(défaut : BOTTOM_RIGHT)
SCROLLEDWINDOW.
{s,g}et_minimum_content_#Définie une taille minimale pour le WIDGET contenu. Le getter renvoie -1 si pas de taille minimale
{height,width} #définie.
SCROLLEDWINDOW.
get_{v,h}scrollbar() #Renvoie la SCROLLBAR_ADR vert. ou horiz. associée.
Viewport #Enfant de Bin et de Scrollable. Comme un ScrolledWindow, sauf qu'il n'y a pas de scrollbars et qu'il
#faut utiliser les ADJUSTMENT pour scroller.
VIEWPORT
(REFPTR<ADJUSTMENT1>,
REFPTR<ADJUSTMENT2>) #Constructor avec deux ADJUSTMENT pour la barre horizontale et verticale.
VIEWPORT.
{g,s}et_shadow_type #
(SHADOWTYPE) #Modifie le type d'ombre parmi : SHADOW_{NONE,IN,OUT,ETCHED_IN,ETCHED_OUT} (défaut : NONE)
Alignment #Enfant de Bin, alignant, rescalant et paddant son enfant.
ALIGNMENT #Construit un ALIGNMENT, avec un alignement horizontal de FLOAT_VAL1 (de 0 à 1, gauche à droite, par
([[[[FLOAT_VAL1], #défaut 0.5), un alignement vertical de FLOAT_VAL2, un fill horizontal de FLOAT_VAL3 (de 0 à 1, 1 le