B,2Y<d][\[c%Bڇ2
PHӌ>Aٍ`I|Ǝ\

U
\.3h[pT-C[`cg KԜzkQ
XâIC2-SCB`q:YAuR0
1;'m=Pӧ.$(S(|\3Id8
M4
6IagɯLI7rPN5
ճ
õĶB
PƸAYHj^̹+
:EwY]4Swzl*AT
la
#/>
nl
&Y
-
:
e
TF

a
,
FF*
q	v
z8P


a:
wUw
pzZc79
0\
:Zm
-




C

P
q
(
m

 
	
)



j

,







O
I
^
Z
=S
R
=
s"
2


ep


]




3


~C!

!
E#
$
@$
4e%
U
%
s&
Cd'
2'
'
(

C)

*
+
+z,
h,
$-
4-
-
.
Q
l/
h0
'1
+
2
392
.m2
T4
Y4
K5
5
q6
n7
u7
8
o8
l.9
9
):
S:
G=
_K=
-=
f=
O@>
>
dA
}A
/rB
vB

C

D
'E
4E
OF

cF
 vG
G

H
s
I

 K
]
M
pN
UBO
]O
jO
aP
z\Q
;Q
R
R
S
q
T

V
W
pX
ZY
]
Z

y[
I\
w
\


Q^
t
S_
H`
~
a
b
Fb
b
b
b
c


c
c
c
'd
d
(Ee
ne
ze
e
e
{f
f
}5g
g
g


g
h
k
G
l
V
m
Mo
o
`p
81q
jq

*r

s
t
	w
9
w
>
y
]
Xz
{
1
D|

v}
s




+

τ
M




G
h
F

;



3
h
A
,

ב
	

=
ݒ

@
ɔ




c-


Y



o

	(
&2
Y
q
I
a
;

+

$
8
O
[
8
b
M

x
b
D

M

B-

p

~

2
^ū
$



ƭ
	p
z

g


X
X
ٰ
	2
u
<

4

J
a
<
X





;


I
L

 
-
D
_
 v
.




4
$
8
E
W
j






(

@
L
i
#

	










'





`
9
U
l


T
e

w


+

2

=
R!
t


=






!
a












(
7
O
f
s

!
`
*(
&S

z
{

A
H




0
#P
$t
:
>


*
C
V
b
q

X
h




0







/
9F

:
@


^(


c
\,
@
B
C

Q
o

9
G
Ef
I
F
J=
J
w
GK
C
F
I
Fh
B
C
C6

z

-
=


e
f
V
I
Y










U


7
R
+o


[MRlA
\
NTZ
XY|X/m
aY		
	 	\	X
B
B
M
c4;7"
ZH:	 
*][Dg3 t
B
v<oTfZ
wm/.H
w
/7(  _X!#!!t"@#)E%4o%C%B%e+&$&
&'$'#
(_/)'
+,4
Z-$.o.!
$/F0
L0Q1`1)
92Q
c34o
F56
G7P8
(9r:W='>@
A@
A)[Cj
EFG
JLcL^`MMNj
dOP-Q6Q%RRmbS
ST
UFWXXgY0Z^'[.]
]_bcckdd,
e7e?e5fDfSQffHf"
g(h%;h%ahhh\
h=

j1
?kqllmno	ooobod!pp
pqqq'qbqHZrr]sAt

uv	vvv,w3
<w	pxzxxx
xHzz{
{{{||
|
||||}
(}6}}"~#~2~*~!~
(قxσ
HEJ
`!(7=߈We
u2ی=L
iM
3pb
ӓ
EG,
)
V
֚
ŝGQ6
wQcɢ'-U


O



r
]
Y'
ʰ	
Q
R
	
ȸ۹zk
xt"3
/
+
*
H@I	5
HSfra-6YH1vo


z
'\


	


	
	!!+
M[?m	vL=b{i][


6"
-#
8\?\s/
!
QV1
v
~
Fy
l(

=9#BNg
m

qY
dmr`.
v{S
j

R*
}aP=

bPSEN_.`N

>?@*

]`p
Hn !##{X$&'U((eb)z-9
C0}1f2a=5z56
9
9:
:
\<j<	<<
<<Z<!=
*=?>
>?@@C9
CD6E4E
EpGwG<fHH
SLM
NpP	SAS
SjUW
(VW
eX@vYmYm%Z
Z
#\/]R&^y^
)_`waz,bd>ee|
chijhkkgl{
lBsn=n
n4
p	qr0rr
rnt
tVv7;ycsyy
zC
w|U}
~@
1G
riuJrCφn
J
͈j
z

|
(r36{
j&j

x
e
B{j$DԞ]
a
?r9
A
Ԥ5
0ק9
m.

cƬi
*
FD8
'0
	2N<k
:

JH
^T


C
SD98
r
Osm@[


:
/cjR!}1n3Dx
C6`2X8#
\Ld
@U7
;3o{&~na

.9G
[=p
k}n
OrM Vh
w3
wq8M;
/
/
e
8w*%"|t	8
	7*bijY?


7
3
$r=8
r(0B
K'	8RgiN
@	  9, f$u$(
(
)*?*YT*
*~,v-G_..N/000/0
11%'19M1
1@3
456-
78*
Y9,:
:f;+<
<=>?
A}C%DEyE
2F{G@
oHIU
xJ
KLO(
OP9xQQQQQLQKT iWW
0Z!0\R\j\\W
\]^]_e_iM``axbr
@c
dUfggh0i
Pi\
k/rln7oop
Fq	ss
3t[
u?wwxoyJz{{~>~;

S

y

~.&
Urّ
L
3U[eT
M
I
H[R- N$]SUL_pXX`
Ҥ	1$/>n)7!3/B7r3ަ


4O'f)ǧ:ԧp:ըިs
x!

K[a i
YP
]
AIVc
+.?nu{C7+{	>
"'
,:CRct
P\b^kʷηTj>y
θܸ4; %\9a4eS2ͺiFǽ

$D/tp
g7k{	)'2Zb{8N ^0
D
	

r
Q_$qPsX0Y
]K[^%F@
c!>A'`iI"
o4
UV
Q\S3+lK!C[cJoKjz+QQ
S5I2-5ScC:AR0D1u'=P
.^((\<3O_V
D
=q6\
$aBT>7!rYP5"'
9	a
g
*PA%
H?

^

y]4"&;
*
f)y

2#'K"K#
^#C`%(<+
+1-x
-"0/
S2o
B4]5
6
8
9
P;g<h
T@A
IDWF8IIBJL
M
N2OQ~
R<T 
T
V
XyZc[[

^_aP`s
`
&b
)c*
d
f
f
g
zi
{j
l^
m
-oI
=p#q
st
umwWxy
yh~{h{JP|\|E|q>}}
q
Ʉ
|zV
Ћ
[$
iu
>}
C}Q?<Γ
x@
?:O*I2(
Оe:P7à^lbˣ.ʤlrxߥXkw$\e0vv\V{ұ{2>4
B

7@:[{C
׷+
GG
V
UT

[Vshv3K
=y#



-
s
`
k

 d
mJFV Bt4\	
h-
[.

M
-
Hkv4
	

c
n

D

I

{
@j	
%m


+K

y
	8B{
2\
	!

 )($R&	f&8p&&!
&
'a
)H
*3B,v,
,,
,k
7./
G0H15Q1-3J344:4:B4}455@
577788
8t[:
:aV<
>a@3
A
>C7
Db
E]G	eGoG~GLJYJjJqJcM[N$yNN$N+N(O45OjOyOOO*lRRRR(RSSS9S%VS6|SSPS+T%HT;
nT	UUU
U UVV!V'V
DV
W
Y3["^6^ V^w^^u__!_$__`3`bJblccc`cd
 de'f(f%gDgn
g
7i-Eisiiiiiiij$j6jGj1bj jwj+-k'Yk
k
Rmn
q%
Msstt0t#t$tB
uCMuuu u(u
v  v+Av
mvw wwwwCw&x/xAx/[x(x(xxAx>y z|
z'A|qi||~\DPFG܂$D*7GUKHL2L̅PbLGJHGCۇDDd

:ǩ
8
Ix
d{
!,˔

Ɩ.ŗ1;&
bxZ&Ӛf&u*ek
rX|vXL
٠amϢY
Ĥ\AB
+nu}M
O4>ҫ7
I7)	
ֱj	tD3Ų tY
<o&Tl
wXmз>R"Y|72
Ը+3
?/M}JW?j)&ؾHɿ+D>BDf&rf
(S
D
c#
$~o"
6
=WC
r

R
spG
0

x
zs	
e[ox
'Dl

,

n)

,
K8I
{
xVI#

9%+



n9	N
,X9"Qx
)+
s
R
k%
.
(FR[dcx
At
L )s*Q

 !!!#	$$$=$7Z$
$&*&D&Y&
w&F(!0)R)	X)
b)s*o+++++++,3,D,),."-+Q-}-0.E.052&
23Y4x4W7d787999:dp=c
=9?EA'"BLJB
D

:F<G
G>INKJLI
M+aNP1
0SbTt'UUqV	MW
WWXYhlZ(ZZL
]
&_
a9
b
c
e|gg8hijC
jlr
lm
p
%rF
3tzuvvvvww3z4zz3z1{{{{6
|9}1?}q} x}#}}	̀
( :[rr!
$/zC(
33)*ƅҊH


S%o
ȏ$
	*()S+}xj$vtIwf
Rәg
*̛6Ɯ
%p>\w@
Sw


!:S/W;
0x
_#

)<H`,'7
?
ǻ0

8"*	d%)zOP8

	9
.


qfpl
D~Xw,v34
O.~)
5W
_1}g

,#~	q*
e`f
3
C>w	m$
O
	
$
,7
V"dc3

&
2WRtx
S>=. `
l |!
J"FS#3#
')MF*,	0p 0
0{2
v3
4
6X4778
8?
z:

;Y<"=
=?@}ADREgE
FH.
I!KKLi8M
MJ~O[O
%Pp
0R
SS1T
TgV6 WWYF[k*\\z]
`{a
2b
cw
]e4
f
hhisjlKl
lXn
opK
p
Gr_
s9
0u
jv

xyyy7z
{|i/

,
'8M=	y

4DK<Y?E
"ht
@S
	
%D
.g
sxۚ
T
mll
e}
tv:
u<?
	
IQӮo%(

\:
X5ɶ
`P

u
"}f~~YJ#E
Z>ZCg>E&T
nj
$>n`Hmi

V
F_
3Z


Q}x
Ef%A
V
b;
6V
A
[d{
&5
Qe*p


		
H	
T	l	
E	X	= 	^
	7	
	\I
	
	p	'
	m	
	/
i			\
	#	

$	&	i
									#	-	
D	O	!	!	!		!	'"	0"	L"	l"	"	"	r"	$#	d#	;$	4%	g4&		&	/&	-&	
,	,	
0	r
-1	2	2	H2	^3	
t3	(
q5	&
6	V7	8	
8	:	:	-:	E;	H;	-a;	6;	A;	
<	K
=	
*?	
)A	BB	O
C	mD	k
4E	0F	P
F	c"H	H	M
I	6
J	3
L	t8M	
O	Q	i
*R	S	u@T	T	V	o
PW	X	v
Y	F
[	b\	&`	>
`	Fa	*Db	ob	%b	+b	b	Ge	$h	$i	S1l	+n	$n	1n	o	
#o	p	tq	Yr	r	s	5
t	
;u	Qv	
:w	dx	h`{	{	

|	}	A_~	M~	
		/	ޅ	φ	{	
e	:		0	
؍	i	.	'			
			e	
	Eǚ	
	
	
	
		:_	
	e			s	
	P
	C	
	
	
	2ϴ			Z	8
	
%	(	
	
		
			R		-	>	$M	r	S		U	<	O	`			X			
"	0		8	1B	t	/		)	7	!<	3^	/	7	3	.	
:	
E	P	]	4j		'		)		:$	p_		Y	D	I	V		3
	
	
4				 		
	P
	
T					
	+	.		!	0	?	H	e	C7	+{			>			
			"	'	
,	:	C	R	c	t		
	n	z		[			o		>			
		4	;I	%	9	a	4G	e|		;	2	iL				[	U	
X	c	v	D		pJ	
	7	{		|		*					y	g	N	'<	Td	H
		h	
		
1	;	
	r
	_h		q			|	
		0	



>{
5g
R4
N[$I+s
Q1
ZP
L
lb-cC UX3

h

w

Dv
c6NS4
I8
s Ou&i
QE
k2)j!kKz
q3
.
c|
1<Y*
^r(+^
	@
	Ni
B
=nphV)Lzft
UcP

.S&

WM]Y

8
1
i?Q
J hS
s:Ov
d
?y
}ae9ff
x

d
PTH0)
T2XZ6P
X	V
q4

Gx,T	$uH=
G(
e]yPxIn`7
	
:6
e
d
!
k
)B`{


_i O]%
fpX

/W^
"o
6
V
o'/Q
gbA
2!"}5
X

N

p
@
84
QICh@
Z	LzMbU
:
b
$

n
l0
D9
F@x
[Cte't\-
D

66
*%3pF/KD
AT

-2J*Y:c>lK
O
;;
Ban
>

&
v

,wVyF
`k



qJ
G0

f
&vtY

_


5<
z
#
`0
>1m%
;
t~^
Z
b
"Kc
E%
*am
7^'I
	L3


$
_#


Rv0^H
u

)
1j>
<
~;
+
,

DBi

.xU@Ufo]$
?
l5-?
R7
+Cw%
~
)#"M
Z!O

bp#j<
{
_\C
`9
!:[F



9m|
G&

~*
`
ya#r
s@<uA
e

:v.=q,+ME~mHpK=
FAK
/
77
-

B
NFE
j
3*S.
j


2
}V

Lqe

,

7gW
9
rB
+

J<3G
98g
[=m((
|}

dN zT
1
&gDG!H>l
@{'
E S
_
#k_5"h

$

t
A\z*}AXsy

h
'0!}\
d8iR8
U

BMYwr(~
\.
{


/|$Y
'S
l
:2;xM>=
u
W"
w(5;=[

Z
,
]84w
7uR
a
9d
?W
|\J5
-
%
 
|/
o6I(4+R

m
?AL
a
y{E
W?3)rs4gk
T
r."

n'
V,
Q]
Po
<

CO/j;1q
J
-

%[n2
H
&
#o0
    ...
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
    ...

  $ git clone git://git.gnome.org/mm-common
  $ cp -a mm-common/skeletonmm libsomethingmm

  _CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)

  _CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)

 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+

# ./configure
# make
# make install

#include &lt;gtkmm/bin.h&gt;
#include &lt;gtkmm/stockid.h&gt;
_DEFS(gtkmm,gtk)
_PINCLUDE(gtkmm/private/bin_p.h)

namespace Gtk
{

class Button : public Bin
{
  _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
public:

  _CTOR_DEFAULT
  explicit Button(const Glib::ustring&amp; label, bool mnemonic = false);
  explicit Button(const StockID&amp; stock_id);

  _WRAP_METHOD(void set_label(const Glib::ustring&amp; label), gtk_button_set_label)

  ...

  _WRAP_SIGNAL(void clicked(), "clicked")

  ...

  _WRAP_PROPERTY("label", Glib::ustring)
};

} // namespace Gtk

#include &lt;gtkmm/button.h&gt;

class OverriddenButton : public Gtk::Button
{
protected:
    virtual void on_clicked();
}

void OverriddenButton::on_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;

    // call the base class's version of the method:
    Gtk::Button::on_clicked();
}

#include &lt;gtkmm/button.h&gt;

void on_button_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;
}

main()
{
    Gtk::Button button("Hello World");
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
}

#include &lt;gtkmm/button.h&gt;
class Foo
{
private:
  Gtk::Button theButton;
  // will be destroyed when the Foo object is destroyed
};

#include &lt;libsomething.h&gt;

int main(int, char**)
{
  something_init();

  std::cout &lt;&lt; get_defs(EXAMPLE_TYPE_SOMETHING)
            &lt;&lt; get_defs(EXAMPLE_TYPE_THING);
  return 0;
}

$ ./enum.pl /usr/include/gtk-2.0/gtk/*.h &gt; gtk_enums.defs

$ ./h2def.py /usr/include/gtk-2.0/gtk/*.h &gt; gtk_methods.defs

$ cd gtk/src
$ /usr/lib/glibmm-2.4/proc/gmmproc -I ../../tools/m4 --defs . button . ./../gtkmm

$ cd tools/extra_defs_gen
$ ./generate_extra_defs &gt; gtk_signals.defs

$ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
    d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
  done

// in a class that inherits from Gtk::Window...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...set up op...
op-&gt;run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);

// in class ExampleWindow's method...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...set up op...
op-&gt;signal_done().connect(sigc::bind(sigc::mem_fun(*this, &amp;ExampleWindow::on_printoperation_done), op));
// run the op

//Within a class that inherits from Gtk::Window and keeps m_refPageSetup and m_refSettings as members...
Glib::RefPtr&lt;Gtk::PageSetup&gt; new_page_setup = Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);
m_refPageSetup = new_page_setup;

Button::Button(const Glib::ustring&amp; label, bool mnemonic)
:
  _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
{}

DerivedDialog* pDialog = 0;
builder-&gt;get_widget_derived("DialogBasic", pDialog);

DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject)
{
}

DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject),
  m_builder(builder),
  m_pButton(0)
{
  //Get the Glade-instantiated Button, and connect a signal handler:
  m_builder-&gt;get_widget("quit_button", m_pButton);
  if(m_pButton)
  {
    m_pButton-&gt;signal_clicked().connect( sigc::mem_fun(*this, &amp;DerivedDialog::on_button_quit) );
  }
}

Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap = Gdk::Bitmap::create(window, data, width, height);

Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap2 = bitmap.

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Gdk::Bitmap* underlying = *refBitmap; //Syntax error - will not compile.

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap2 = refBitmap;

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
int depth = refBitmap-&gt;get_depth();

Glib::RefPtr&lt;Gtk::Builder&gt; builder = Gtk::Builder::create_from_file("basic.glade");

Glib::RefPtr&lt;Gtk::Builder&gt; builder = Gtk::Builder::create_from_file("basic.glade", "treeview_products");

Glib::RefPtr&lt;Gtk::PrintOperation&gt; op = Gtk::PrintOperation::create();
// ...set up op...
op-&gt;set_export_filename("test.pdf");
Gtk::PrintOperationResult res = op-&gt;run(Gtk::PRINT_OPERATION_ACTION_EXPORT);

Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = m_TreeView.get_model();
if(refModel)
{
  int cols_count = refModel-&gt;get_n_columns();
  ...
}

Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_dynamic(refModel);
Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore2 =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_static(refModel);

Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore = Gtk::TreeStore::create(columns);
Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = refStore;

Glib::SignalProxy1&lt;bool, Gtk::DirectionType&gt; signal_focus()

Glib::SignalProxy3&lt;void, const Glib::ustring&amp;, int, int*&gt; signal_insert_text()


Gtk::Button* button = new Gtk::Button("example");
gtk_button_do_something_new(button-&gt;gobj());

Gtk::Button* pButton = new Gtk::Button("Test");

// do something useful with pButton

delete pButton;

Gtk::Dialog* pDialog = 0;
builder-&gt;get_widget("DialogBasic", pDialog);

Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Big"));
button-&gt;set_tooltip_text("Big Brush);
group_brushes-&gt;insert(*button);

Gtk::ToolItemGroup* group_brushes =
  Gtk::manage(new Gtk::ToolItemGroup("Brushes"));
m_ToolPalette.add(*group_brushes);

Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
{
  set_custom_tab_label("My custom tab");

  Gtk::HBox* hbox = new Gtk::HBox(false, 8);
  hbox-&gt;set_border_width(6);

  Gtk::Label* label = Gtk::manage(new Gtk::Label("Enter some text: "));
  hbox-&gt;pack_start(*label, false, false);
  label-&gt;show();

  hbox-&gt;pack_start(m_Entry, false, false);
  m_Entry.show();

  return hbox;
}

void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
{
  Glib::ustring user_input = m_Entry.get_text();
  //...
}

GtkButton* cbutton = get_a_button();
Gtk::Button* button = Glib::wrap(cbutton);

GtkWidget* example_widget_new(int something, const char* thing)
{
        ExampleWidget* widget;
        widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
        example_widget_construct(widget, "something", something, "thing", thing);
}

void example_widget_construct(ExampleWidget* widget, int something, const char* thing)
{
        //Do stuff that uses private API:
        widget-&gt;priv-&gt;thing = thing;
        do_something(something);
}

GtkWidget* example_widget_new(int something, const char* thing)
{
        return g_object_new (EXAMPLE_TYPE_WIDGET, "something", something, "thing", thing, NULL);
}

MyWidget::MyWidget()
{
  Gtk::Button* pButton = manage(new Gtk::Button("Test"));
  add(*pButton); //add aButton to MyWidget
}

_CLASS_BOXEDTYPE(Color, GdkColor, NONE, gdk_color_copy, gdk_color_free)

_CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

_CLASS_GENERIC(AttrIter, PangoAttrIterator)

_CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)

_CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)

_CLASS_OPAQUE_COPYABLE(Region, GdkRegion, gdk_region_new, gdk_region_copy, gdk_region_destroy)

_CLASS_OPAQUE_REFCOUNTED(Coverage, PangoCoverage, pango_coverage_new, pango_coverage_ref, pango_coverage_unref)

_CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')

_CONVERSION(`PrintSettings&amp;',`GtkPrintSettings*',__FR2P)
_CONVERSION(`const PrintSettings&amp;',`GtkPrintSettings*',__FCR2P)
_CONVERSION(`const Glib::RefPtr&lt;Printer&gt;&amp;',`GtkPrinter*',__CONVERT_REFPTR_TO_P($3))

_IGNORE(gtk_button_box_set_spacing, gtk_button_box_get_spacing,

_MEMBER_GET_GOBJECT(offscreen_pixmap, offscreen_pixmap, Gdk::Pixmap, GdkPixmap*)

_MEMBER_GET_PTR(vbox, vbox, VBox*, GtkWidget*)

_WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags)

_WRAP_ENUM(WindowType, GdkWindowType)

_WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

_WRAP_METHOD(void set_text(const Glib::ustring&amp; text), gtk_entry_set_text)

_WRAP_METHOD_DOCS_ONLY(gtk_container_remove)

_WRAP_PROPERTY("label", Glib::ustring)

_WRAP_SIGNAL(void clicked(),"clicked")

bool MyCallback() { std::cout &lt;&lt; "Hello World!\n" &lt;&lt; std::endl; return true; }

bool idleFunc();

bool input_callback(Glib::IOCondition condition);

bool on_button_press(GdkEventButton* event);
Gtk::Button button("label");
button.signal_button_press_event().connect( sigc::ptr_fun(&amp;on_button_press) );

button.signal_button_press_event().connect( sigc::ptr_fun(&amp;on_mywindow_button_press), false );

class ActionGroup : public Glib::Object
{
  _CLASS_GOBJECT(ActionGroup, GtkActionGroup, GTK_ACTION_GROUP, Glib::Object, GObject)

protected:
  _WRAP_CTOR(ActionGroup(const Glib::ustring&amp; name = Glib::ustring()), gtk_action_group_new)

public:
  _WRAP_CREATE(const Glib::ustring&amp; name = Glib::ustring())

class Server
{
public:
  //signal accessor:
  typedef sigc::signal&lt;void, bool, int&gt; type_signal_something;
  type_signal_something signal_something();

protected:
  type_signal_something m_signal_something;
};

Server::type_signal_something Server::signal_something()
{
  return m_signal_something;
}

example-widget.h:56: error: using typedef-name 'ExampleWidget' after 'struct'
../../libexample/libexamplemm/example-widget.h:34: error: 'ExampleWidget' has a previous declaration here
make[4]: *** [example-widget.lo] Error 1

example-widget.h:60: error: '_ExampleWidget ExampleWidget' redeclared as different kind of symbol
../../libexample/libexamplemm/example-widget.h:34: error: previous declaration of 'typedef struct _ExampleWidget ExampleWidget'

if(bitmap)
{
  int depth = bitmap-&gt;get_depth().
}

m_button1.signal_clicked().connect( sigc::bind&lt;Glib::ustring&gt;( sigc::mem_fun(*this, &amp;HelloWorld::on_button_clicked), "button 1") );

my_connection.disconnect();

server.signal_something().connect(
  sigc::mem_fun(client, &amp;Client::on_server_something) );

sigc::connection  Glib::SignalIdle::connect(const sigc::slot&lt;bool&gt;&amp; slot, int priority = Glib::PRIORITY_DEFAULT_IDLE);

sigc::connection Glib::SignalInput::connect(const sigc::slot&lt;bool,Glib::IOCondition&gt;&amp; slot,
                                    int fd, Glib::IOCondition condition,
                                    int priority = Glib::PRIORITY_DEFAULT);

sigc::connection Glib::SignalTimeout::connect(const sigc::slot&lt;bool&gt;&amp; slot, unsigned int interval, int priority = Glib::PRIORITY_DEFAULT);

sigc::signal&lt;void, bool, int&gt; signal_something;

sigc::signal&lt;void,int&gt;::iterator signal&lt;void,int&gt;::connect( const sigc::slot&lt;void,int&gt;&amp; );

std::list&lt; Glib::RefPtr&lt;Gdk::Pixmap&gt; &gt; listPixmaps;
Glib::RefPtr&lt;Gdk::Pixmap&gt; refPixmap = Gdk::Pixmap::create(window,
width, height, depth);
listPixmaps.push_back(refPixmap);

typedef struct _ExampleWidget ExampleWidget;

struct _ExampleWidget
{
  ...
};

virtual void on_button_clicked(Glib::ustring data);

void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr&lt;PrintOperation&gt;&amp; op)
{
  if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
    //notify user
  else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
    //Update PrintSettings with the ones used in this PrintOperation

  if (! op-&gt;is_finished())
    op-&gt;signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this, &amp;ExampleWindow::on_printoperation_status_changed), op));
}

void ExampleWindow::on_printoperation_status_changed(const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; op)
{
  if (op-&gt;is_finished())
    //the print job is finished
  else
    //get the status with get_status() or get_status_string()

  //update UI
}

void init()
{
  Gtk::Main::init_gtkmm_internals(); //Sets up the g type system and the Glib::wrap() table.
  wrap_init(); //Tells the Glib::wrap() table about the libsomethingmm classes.
}

void on_button_clicked();

class some_class
{
    void on_button_clicked();
};

some_class some_object;

main()
{
    Gtk::Button button;
    button.signal_clicked().connect( sigc::ptr_fun(&amp;on_button_clicked) );
    button.signal_clicked().connect( sigc::mem_fun(some_object, &amp;some_class::on_button_clicked) );
}

void on_insert_text(const Glib::ustring&amp; text, int length, int* position);

{
  Gtk::Button aButton;
  aButton.show();
  ...
  kit.run();
}
"Hidden" Columns# keep this file sorted alphabetically, one language code per line
de
ja#include &lt;gtkmm.h&gt;#m4 _CONVERSION(`GSList*', `Glib::SListHandle&lt;Widget*&gt;', `$2($3, Glib::OWNERSHIP_NONE)')$ ./plug &amp;$ ./socket(An aside: <application>GTK+</application> calls this scheme "signalling"; the sharp-eyed reader with GUI toolkit experience will note that this same design is often seen under the name of "broadcaster-listener" (e.g., in Metrowerks' PowerPlant framework for the Macintosh). It works in much the same way: one sets up <literal>broadcasters</literal>, and then connects <literal>listeners</literal> to them; the broadcaster keeps a list of the objects listening to it, and when someone gives the broadcaster a message, it calls all of its objects in its list with the message. In <application>gtkmm</application>, signal objects play the role of broadcasters, and slots play the role of listeners - sort of. More on this later.)(In addition, you'd have the files <literal>ja.po</literal> and <literal>de.po</literal> in your <literal>po</literal> directory which contain the German and Japanese translations, respectively.)./docextract_to_xml.py -s /gnome/head/cvs/gtk+/gtk/ -s /gnome/head/cvs/gtk+/docs/reference/gtk/tmpl/ &gt; gtk_docs.xml
// creates its own adjustments
Gtk::TextView textview;
// uses the newly-created adjustment for the scrollbar as well
Gtk::VScrollbar vscrollbar (*(textview.get_vadjustment()));// note to translators: don't translate the "[noun]" part - it is
// just here to distinguish the string from another "jumps" string
text = strip(gettext("jumps[noun]"), "[noun]");//compiler error - no conversion from ustring to int.
int number = row[m_Columns.m_col_text];2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010<application>Gtk::Builder</application> checks for a null pointer, and checks that the widget is of the expected type, and will show warnings on the command line about these.<application>gtkmm</application> allows the programmer to control the lifetime (that is, the construction and destruction) of any widget in the same manner as any other C++ object. This flexibility allows you to use <literal>new</literal> and <literal>delete</literal> to create and destroy objects dynamically or to use regular class members (that are destroyed automatically when the class is destroyed) or to use local instances (that are destroyed when the instance goes out of scope). This flexibility is not present in some C++ GUI toolkits, which restrict the programmer to only a subset of C++'s memory management features.<application>gtkmm</application> allows you to write code using normal C++ techniques such as encapsulation, derivation, and polymorphism. As a C++ programmer you probably already realise that this leads to clearer and better organized code.<application>gtkmm</application> also provides the <methodname>set_manage()</methodname> method for all widgets. This can be used to generate the same result as <function>manage()</function>, but is more tedious:<application>gtkmm</application> and Win32<application>gtkmm</application> applications can easily support multiple languages, including non-European languages such as Chinese and right-to-left languages such as Arabic. An appropriately-written and translated <application>gtkmm</application> application will use the appropriate language at runtime based on the user's environment.<application>gtkmm</application> applications consist of windows containing widgets, such as buttons and text boxes. In some other systems, widgets are called "controls". For each widget in your application's windows, there is a C++ object in your application's code. So you just need to call a method of the widget's class to affect the visible widget.<application>gtkmm</application> arranges widgets hierarchically, using <emphasis>containers</emphasis>. A Container widget contains other widgets. Most <application>gtkmm</application> widgets are containers. Windows, Notebook tabs, and Buttons are all container widgets. There are two flavours of containers: single-child containers, which are all descendants of <classname>Gtk::Bin</classname>, and multiple-child containers, which are descendants of <classname>Gtk::Container</classname>. Most widgets in <application>gtkmm</application> are descendants of <classname>Gtk::Bin</classname>, including <classname>Gtk::Window</classname>.<application>gtkmm</application> classes are designed with overriding in mind; they contain virtual member methods specifically intended to be overridden.<application>gtkmm</application> compared to Qt<application>gtkmm</application> currently works with the <ulink url="http://mingw.org/">MingW/GCC3.4 compiler</ulink> and Microsoft Visual C++ 2005 or later (including the freely available express editions) on the Windows platform. There is an <ulink url="ftp://ftp.gnome.org/pub/GNOME/binaries/win32/gtkmm"> installer</ulink> available for gtkmm on Microsoft Windows. Refer to <ulink url="http://live.gnome.org/gtkmm/MSWindows/"> http://live.gnome.org/gtkmm/MSWindows</ulink> for instructions how to use it.<application>gtkmm</application> developers tend to prefer <application>gtkmm</application> to Qt because <application>gtkmm</application> does things in a more C++ way. Qt originates from a time when C++ and the standard library were not standardised or well supported by compilers. It therefore duplicates a lot of stuff that is now in the standard library, such as containers and type information. Most significantly, Trolltech modified the C++ language to provide signals, so that Qt classes cannot be used easily with non-Qt classes. <application>gtkmm</application> was able to use standard C++ to provide signals without changing the C++ language. See the FAQ for more detailed differences.<application>gtkmm</application> has various widgets that can be visually adjusted using the mouse or the keyboard, such as the <classname>Range</classname> widgets (described in the <link linkend="chapter-range-widgets">Range Widgets</link> section). There are also a few widgets that display some adjustable part of a larger area, such as the <classname>Viewport</classname> widget. These widgets have <classname>Gtk::Adjustment</classname> objects that express this common part of their API.<application>gtkmm</application> involves less code compared to GTK+, which uses prefixed function names and lots of cast macros.<application>gtkmm</application> is a C++ wrapper for <ulink url="http://www.gtk.org/">GTK+</ulink>, a library used to create graphical user interfaces. It is licensed using the LGPL license, so you can develop open software, free software, or even commercial non-free software using <application>gtkmm</application> without purchasing licenses.<application>gtkmm</application> is a wrapper<application>gtkmm</application> is more type-safe, so the compiler can detect errors that would only be detected at run time when using C. This use of specific types also makes the API clearer because you can see what types should be used just by looking at a method's declaration.<application>gtkmm</application> is not a native C++ toolkit, but a C++ wrapper of a C toolkit. This separation of interface and implementation has advantages. The <application>gtkmm</application> developers spend most of their time talking about how <application>gtkmm</application> can present the clearest API, without awkward compromises due to obscure technical details. We contribute a little to the underlying GTK+ code base, but so do the C coders, and the Perl coders and the Python coders, etc. Therefore GTK+ benefits from a broader user base than language-specific toolkits - there are more implementers, more developers, more testers, and more users.<application>gtkmm</application> makes it very easy to derive new widgets by inheriting from an existing widget class, either by deriving from a container and adding child widgets, or by deriving from a single-item widget, and changing its behaviour. But you might occasionally find that no suitable starting point already exists. In this case, you can implement a widget from scratch.<application>gtkmm</application> provides an easy way to manage recently used documents. The classes involved in implementing this functionality are <classname>RecentManager</classname>, <classname>RecentChooserDialog</classname>, <classname>RecentChooserMenu</classname>, <classname>RecentChooserWidget</classname>, and <classname>RecentFilter</classname>.<application>gtkmm</application> provides four basic types of buttons:<application>gtkmm</application> provides the <function>manage()</function> function and <methodname>add()</methodname> methods to create and destroy widgets. Every widget except a top-level window must be added or packed into a container in order to be displayed. The <function>manage()</function> function marks a packed widget so that when the widget is added to a container, the container becomes responsible for deleting the widget.<application>gtkmm</application> signal handlers are strongly-typed, whereas <application>GTK+</application> C code allows you to connect a callback with the wrong number and type of arguments, leading to a segfault at runtime. And, unlike <application>Qt</application>, <application>gtkmm</application> achieves this without modifying the C++ language.<application>gtkmm</application> uses the <command>gmmproc</command> tool to generate most of its source code, using .defs files that define the APIs of <classname>GObject</classname>-based libraries. So it's quite easy to create additional gtkmm-style wrappers of other glib/GObject-based libraries.<application>gtkmm</application> uses the libsigc++ library to implement signals. Here is an example line of code that connects a Gtk::Button's "clicked" signal with a signal handler called "on_button_clicked": <placeholder-1/><application>gtkmm</application> uses the packing system to solve these problems. Rather than specifying the position and size of each widget in the window, you can arrange your widgets in rows, columns, and/or tables. <application>gtkmm</application> can size your window automatically, based on the sizes of the widgets it contains. And the sizes of the widgets are, in turn, determined by the amount of text they contain, or the minimum and maximum sizes that you specify, and/or how you have requested that the available space should be shared between sets of widgets. You can perfect your layout by specifying padding distance and centering values for each of your widgets. <application>gtkmm</application> then uses all this information to resize and reposition everything sensibly and smoothly when the user manipulates the window.<application>gtkmm</application> was originally named gtk-- because GTK+ already has a + in the name. However, as -- is not easily indexed by search engines the package generally went by the name <application>gtkmm</application>, and that's what we stuck with.<application>gtkmm</application> widget classes have signal accessor methods, such as <methodname>Gtk::Button::signal_clicked()</methodname>, which allow you to connect your signal handler. Thanks to the flexibility of <application>libsigc++</application>, the callback library used by <application>gtkmm</application>, the signal handler can be almost any kind of function, but you will probably want to use a class method. Among <application>GTK+</application> C coders, these signal handlers are often named callbacks.<application>gtkmm</application>, like most GUI toolkits, is <emphasis>event-driven</emphasis>. When an event occurs, such as the press of a mouse button, the appropriate signal will be <emphasis>emitted</emphasis> by the Widget that was pressed. Each Widget has a different set of signals that it can emit. To make a button click result in an action, we set up a <emphasis>signal handler</emphasis> to catch the button's "clicked" signal.<application>intltool</application> / <application>xgettext</application> script extracts the strings and puts them in a <filename>mypackage.pot</filename> file. The translators of your application create their translations by first copying this <filename>.pot</filename> file to a <filename>localename.po</filename> file. A locale identifies a language and an encoding for that language, including date and numerical formats. Later, when the text in your source code has changed, the <literal>msmerge</literal> script is used to update the <filename>localename.po</filename> files from the regenerated <filename>.pot</filename> file.<classname>ButtonBox</classname>es help to make applications appear consistent because they use standard settings, such as inter-button spacing and packing.<classname>Glib::ListHandle&lt;Gtk::Widget*&gt;</classname>: Use <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.<classname>Glib::RefPtr</classname> is a smartpointer. Specifically, it is a reference-counting smartpointer. You might be familiar with <literal>std::auto_ptr&lt;&gt;</literal>, which is also a smartpointer, but <literal>Glib::RefPtr&lt;&gt;</literal> is much simpler, and more useful. We expect a future version of the C++ Standard Library to contain a reference-counting shared smartpointer, and a future version of <application>gtkmm</application> might possibly use that instead.<classname>Glib::SListHandle&lt;Gtk::Widget*&gt;</classname>: Use <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.<classname>Glib::StringArrayHandle</classname> or <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname>: Use <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <type>const char*[]</type>, etc.<classname>Grid</classname> allows us to place widgets in a grid. The grid dynamically lays out child widgets, so the dimensions of the grid do not need to be specified in the constructor.<classname>Gtk::Builder</classname> must be used via a <classname>Glib::RefPtr</classname>. Like all such classes, you need to use a <methodname>create()</methodname> method to instantiate it. For instance, <placeholder-1/> This will instantiate the windows defined in the .glade file, though they will not be shown immediately unless you have specified that via the <guilabel>Properties</guilabel> window in <application>Glade</application>.<classname>Gtk::Button</classname> is also a container so you could put any other widget, such as a <classname>Gtk::Image</classname> into it.<classname>Gtk::CheckButton</classname> inherits from <classname>Gtk::ToggleButton</classname>. The only real difference between the two is <classname>Gtk::CheckButton</classname>'s appearance. You can check, set, and toggle a checkbox using the same member methods as for <classname>Gtk::ToggleButton</classname>.<classname>Gtk::Clipboard</classname> is a singleton. You can get the one and only instance with <methodname>Gtk::Clipboard::get()</methodname>.<classname>Gtk::Grid</classname> arranges its child widgets in rows and columns. Use <methodname>attach()</methodname>, <methodname>attach_next_to()</methodname> and <methodname>add()</methodname> to insert child widgets.<classname>Gtk::Scale</classname> and <classname>Gtk::Scrollbar</classname> both inherit from <classname>Gtk::Range</classname> and share much functionality. They contain a "trough" and a "slider" (sometimes called a "thumbwheel" in other GUI environments). Dragging the slider with the pointer moves it within the trough, while clicking in the trough advances the slider towards the location of the click, either completely, or by a designated amount, depending on which mouse button is used. This should be familiar scrollbar behaviour.<classname>Gtk::Scale</classname> widgets (or "sliders") allow the user to visually select and manipulate a value within a specific range. You might use one, for instance, to adjust the magnification level on a zoomed preview of a picture, or to control the brightness of a colour, or to specify the number of minutes of inactivity before a screensaver takes over the screen.<classname>Gtk::Table</classname> arranges its widgets in a grid. Use <methodname>attach()</methodname> to insert widgets.<classname>Gtk::TargetEntry</classname> objects contain this information: <placeholder-1/><classname>Gtk::TextBuffer</classname> is a model containing the data for the <classname>Gtk::TextView</classname>, like the <classname>Gtk::TreeModel</classname> used by <classname>Gtk::TreeView</classname>. This allows two or more <classname>Gtk::TextView</classname>s to share the same <classname>TextBuffer</classname>, and allows those TextBuffers to be displayed slightly differently. Or you could maintain several <classname>Gtk::TextBuffer</classname>s and choose to display each one at different times in the same <classname>Gtk::TextView</classname> widget.<classname>Gtk::TextView</classname> has various <methodname>scroll_to_*()</methodname> methods. These allow you to ensure that a particular part of the text buffer is visible. For instance, your application's Find feature might use <methodname>Gtk::TextView::scroll_to_iter()</methodname> to show the found text.<classname>Gtk::ToggleButton</classname> is most useful as a base class for the <classname>Gtk::CheckButton</classname> and <classname>Gtk::RadioButton</classname> classes.<classname>Gtk::ToolItem</classname>s can then be added to the group. For instance, like so:<classname>Gtk::TreeModel</classname> provides a C++ Standard Library-style container of its children, via the <methodname>children()</methodname> method. You can use the familiar <methodname>begin()</methodname> and <methodname>end()</methodname> methods iterator incrementing, like so:<classname>Gtk::TreeStore</classname> models can have child items. Add them with the <methodname>append()</methodname>, <methodname>prepend()</methodname>, or <methodname>insert()</methodname> methods, like so:<classname>Gtk::TreeView</classname> already implments simple drag-and-drop when used with the <classname>Gtk::ListStore</classname> or <classname>Gtk::TreeStore</classname> models. If necessary, it also allows you to implement more complex behaviour when items are dragged and dropped, using the normal <link linkend="chapter-draganddrop">Drag and Drop</link> API.<classname>Gtk::VBox</classname> and <classname>Gtk::HBox</classname> arrange their child widgets vertically and horizontally, respectively. Use <methodname>pack_start()</methodname> and <methodname>pack_end()</methodname> to insert child widgets.<classname>Gtk::Widget</classname> has several methods and signals which are prefixed with "drag_". These are used for Drag and Drop.<classname>Menus</classname> are normally just added to a window, but they can also be displayed temporarily as the result of a mouse button click. For instance, a context menu might be displayed when the user clicks their right mouse button.<classname>MessageDialog</classname> is a convenience class, used to create simple, standard message dialogs, with a message, an icon, and buttons for user response. You can specify the type of message and the text in the constructor, as well as specifying standard buttons via the <literal>Gtk::ButtonsType</literal> enum.<classname>RadioButtons</classname> are "off" when created; this means that when you first make a group of them, they will all be off. Don't forget to turn one of them on using <methodname>set_active()</methodname>:<classname>Range</classname> widgets typically connect a handler to this signal, which changes their appearance to reflect the change - for example, the size of the slider in a scrollbar will grow or shrink in inverse proportion to the difference between the <parameter>lower</parameter> and <parameter>upper</parameter> values of its <classname>Adjustment</classname>.<classname>RecentChooser</classname> is an interface that can be implemented by widgets displaying the list of recently used files. <application>gtkmm</application> provides three built-in implementations for choosing recent files: <classname>RecentChooserWidget</classname>, <classname>RecentChooserDialog</classname>, and <classname>RecentChooserMenu</classname>.<classname>RecentChooserWidget</classname> is a simple widget for displaying a list of recently used files. <classname>RecentChooserWidget</classname> is the basic building block for <classname>RecentChooserDialog</classname>, but you can embed it into your user interface if you want to.<classname>RecentManager</classname> acts as the central database of recently used files. You use this class to register new files, remove files from the list, or look up recently used files.<classname>Scale</classname> widgets can display their current value as a number next to the trough. By default they show the value, but you can change this with the <methodname>set_draw_value()</methodname> method.<classname>ScrolledWindow</classname> widgets create a scrollable area. You can insert any type of widget into a <classname>ScrolledWindow</classname> window, and it will be accessible regardless of its size by using the scrollbars. Note that <classname>ScrolledWindow</classname> is not a <classname>Gtk::Window</classname> despite the slightly misleading name.<classname>SpinButton</classname>s use an <link linkend="chapter-adjustment">Adjustment</link> object to hold information about the range of values. These Adjustment attributes are used by the Spin Button like so: <placeholder-1/><classname>TextBuffer</classname> iterators are generally invalidated when the text changes, but you can use a <classname>Gtk::TextBuffer::Mark</classname> to remember a position in these situations. For instance,<classname>TextView</classname> has various methods which allow you to change the presentation of the buffer for this particular view. Some of these may be overridden by the <classname>Gtk::TextTag</classname>s in the buffer, if they specify the same things. For instance, <methodname>set_left_margin()</methodname>, <methodname>set_right_margin()</methodname>, <methodname>set_indent()</methodname>, etc.<classname>ToggleButton</classname>s are like normal <classname>Button</classname>s, but when clicked they remain activated, or pressed, until clicked again.<classname>ToolItemGroup</classname>s should be added to the tool pallete via the base class's <function>Gtk::Container::add()</function> method, for instance like so:<classname>Widgets</classname> can be identified as sources or destinations using these <classname>Gtk::Widget</classname> methods:<command>gmmproc</command> will warn you on stdout about functions that you have forgotten to wrap, helping to ensure that you are wrapping the complete API. Buf if you don't want to wrap some functions or if you chose to hand-code some methods then you can use the _IGNORE() macro the make <command>gmmproc</command> stop complaining.<filename>libsomething</filename>: Contains the main include file and the pkg-config .pc file.<filename>libsomethingmm</filename>: Contains generated and hand-written .h and .cc files.<filename>libsomethingmm</filename>: The top-level directory.<filename>private</filename>: Contains generated <filename>*_p.h</filename> files.<filename>src</filename>: Contains .hg and .ccg source files.<function>_WRAP_METHOD()</function>, <function>_WRAP_SIGNAL()</function>, and <function>_WRAP_PROPERTY()</function><function>sigc::bind()</function> is not commonly used, but you might find it helpful sometimes. If you are familiar with <application>GTK+</application> programming then you have probably noticed that this is similar to the extra <literal>gpointer data</literal> arguments which all GTK+ callbacks have. This is generally overused in <application>GTK+</application> to pass information that should be stored as member data in a derived widget, but widget derivation is very difficult in C. We have far less need of this hack in <application>gtkmm</application>.<function>sigc::ptr_fun()</function> generates a <classname>sigc::slot</classname>. A slot is an object which looks and feels like a function, but is actually an object. These are also known as function objects, or functors. <function>sigc::ptr_fun()</function> generates a slot for a standalone function or static method. <function>sigc::mem_fun()</function> generates a slot for a member method of a particular instance.<literal>$3</literal> will be replaced by the parameter name when this conversion is used by gmmproc.<literal>Gtk::UPDATE_CONTINUOUS</literal> - This is the default. The <literal>value_changed</literal> signal is emitted continuously, i.e. whenever the slider is moved by even the tiniest amount.<literal>Gtk::UPDATE_DELAYED</literal> - The <literal>value_changed</literal> signal is emitted when the user releases the mouse button, or if the slider stops moving for a short period of time.<literal>Gtk::UPDATE_DISCONTINUOUS</literal> - The <literal>value_changed</literal> signal is only emitted once the slider has stopped moving and the user has released the mouse button.<literal>LINGUAS</literal> contains an alphabetically sorted list of codes identifying the languages for which your program is translated (comment lines starting with a <literal>#</literal> are ignored). Each language code listed in the <literal>LINGUAS</literal> file must have a corresponding <literal>.po</literal> file. So, if your program has German and Japanese translations, your <literal>LINGUAS</literal> file would look like this:<literal>PACK_EXPAND_PADDING</literal>: Extra space is filled with padding. The widgets will be spaced out evenly, but their sizes won't change - there will be empty space between the widgets instead.<literal>PACK_EXPAND_WIDGET</literal>: Extra space is taken up by increasing the child widget size, without changing the amount of space between widgets.<literal>PACK_SHRINK</literal>: Space is contracted to the child widget size. The widget will take up just-enough space and never expand.<literal>POTFILES.in</literal> is a list of paths to all files which contain strings marked up for translation, starting from the project root directory. So for example, if your project sources were located in a subdirectory named <literal>src</literal>, and you had two files that contained strings that should be translated, your <literal>POTFILES.in</literal> file might look like this:<literal>actions</literal> indicates the Drag and Drop actions which this destination can receive - see the description above.<literal>actions</literal> is an ORed combination of values, which specified which Drag and Drop operations will be possible from this source - for instance, copy, move, or link. The user can choose between the actions by using modifier keys, such as <keycap>Shift</keycap> to change from <literal>copy</literal> to <literal>move</literal>, and this will be shown by a different cursor.<literal>begin_print</literal>: You must handle this signal, because this is where you create and set up a <classname>Pango::Layout</classname> using the provided <classname>Gtk::PrintContext</classname>, and break up your printing output into pages.<literal>done</literal>: This signal is emitted when printing is finished, meaning when the print data is spooled. Note that the provided <literal>Gtk::PrintOperationResult</literal> may indicate that an error occurred. In any case you probably want to notify the user about the final status.<literal>drag_begin</literal>: Provides DragContext.<literal>drag_data_received</literal>: Provides <literal>info</literal> about the dragged data format, and a <literal>GtkSelectionData</literal> structure which contains the dropped data. You should call the <methodname>drag_finish()</methodname> method of the <literal>DragContext</literal> to indicate whether the operation was successful.<literal>drag_delete</literal>: Gives the source the opportunity to delete the original data if that's appropriate.<literal>drag_drop</literal>: Provides DragContext and coordinates.<literal>drag_end</literal>: Provides DragContext.<literal>drag_get</literal>: Provides <literal>info</literal> about the dragged data format, and a <literal>GtkSelectionData</literal> structure, in which you should put the requested data.<literal>drag_motion</literal>: Provides DragContext and coordinates. You can call the drag_status() method of the DragContext to indicate which target will be accepted.<literal>draw_page</literal>: You must handle this signal, which provides a <classname>PrintContext</classname> and a page number. The <classname>PrintContext</classname> should be used to create a <classname>Cairo::Context</classname> into which the provided page should be drawn. To render text, iterate over the <classname>Pango::Layout</classname> you created in the <literal>begin_print</literal> handler.<literal>end_print</literal>: A handler for it is a safe place to free any resources related to a <classname>PrintOperation</classname>. If you have your custom class that inherits from <classname>PrintOperation</classname>, it is naturally simpler to do it in the destructor.<literal>flags</literal> is an ORed combination of values which indicates how the widget will respond visually to Drag and Drop items.<literal>lower</literal>: lower range value<literal>page_increment</literal>: value to increment/decrement when pressing mouse button 2 on a button<literal>page_size</literal>: unused<literal>paginate</literal>: Pagination is potentially slow so if you need to monitor it you can call the <methodname>PrintOperation::set_show_progress()</methodname> method and handle this signal.<literal>request_page_setup</literal>: Provides a <classname>PrintContext</classname>, page number and <classname>Gtk::PageSetup</classname>. Handle this signal if you need to modify page setup on a per-page basis.<literal>start_button_mask</literal> is an ORed combination of values, which specify which modifier key or mouse button must be pressed to start the drag.<literal>status_changed</literal>: Emitted whenever a print job's status changes, until it is finished. Call the <methodname>PrintOperation::set_track_print_status()</methodname> method to monitor the job status after spooling. To see the status, use <methodname>get_status()</methodname> or <methodname>get_status_string()</methodname>.<literal>step_increment</literal>: value to increment/decrement when pressing mouse button 1 on a button<literal>targets</literal> is a container of <classname>Gtk::TargetEntry</classname> (<classname>std::list&lt;Gtk::TargetEntry&gt;</classname> or <classname>std::vector&lt;Gtk::TargetEntry&gt;</classname>, for instance) elements.<literal>upper</literal>: upper range value<literal>value</literal>: value for the Spin Button<methodname>Gtk::Widget::show()</methodname> lets <application>gtkmm</application> know that we have finished setting the attributes of the widget, and that it is ready to be displayed. You can use <methodname>Gtk::Widget::hide()</methodname> to make it disappear again. The order in which you show the widgets is not important, but we do suggest that you show the top-level window last; this way, the whole window will appear with its contents already drawn. Otherwise, the user will first see a blank window, into which the widgets will be gradually drawn.<methodname>child_type_vfunc()</methodname>: Return what type of child can be added.<methodname>forall_vfunc()</methodname>: Call the same callback for each of the children.<methodname>get_preferred_height_for_width_vfunc()</methodname>: Calculate the minimum and natural height of the container, if it would be given the specified width.<methodname>get_preferred_height_for_width_vfunc()</methodname>: Calculate the minimum and natural height of the widget, if it would be given the specified width.<methodname>get_preferred_height_vfunc()</methodname>: Calculate the minimum and natural height of the container.<methodname>get_preferred_height_vfunc()</methodname>: Calculate the minimum and natural height of the widget.<methodname>get_preferred_width_for_height_vfunc()</methodname>: Calculate the minimum and natural width of the container, if it would be given the specified height.<methodname>get_preferred_width_for_height_vfunc()</methodname>: Calculate the minimum and natural width of the widget, if it would be given the specified height.<methodname>get_preferred_width_vfunc()</methodname>: Calculate the minimum and natural width of the container.<methodname>get_preferred_width_vfunc()</methodname>: Calculate the minimum and natural width of the widget.<methodname>get_request_mode_vfunc()</methodname>: (optional) Return what <literal>Gtk::SizeRequestMode</literal> is preferred by the widget.<methodname>get_request_mode_vfunc()</methodname>: Return what <literal>Gtk::SizeRequestMode</literal> is preferred by the container.<methodname>get_widget()</methodname> returns child widgets that are <function>manage()</function>ed (see the <link linkend="chapter-memory">Memory Management</link> chapter), so they will be deleted when their parent container is deleted. So, if you get only a child widget from <application>Gtk::Builder</application>, instead of a whole window, then you must either put it in a <classname>Container</classname> or delete it. <classname>Windows</classname> (such as <classname>Dialogs</classname>) cannot be managed because they have no parent container, so you must delete them at some point.<methodname>on_add()</methodname>: Add a child widget to the container.<methodname>on_draw()</methodname>: Draw on the supplied <classname>Cairo::Context</classname>.<methodname>on_map()</methodname>: (optional)<methodname>on_realize()</methodname>: Associate a <classname>Gdk::Window</classname> with the widget.<methodname>on_remove()</methodname>: Remove a child widget from the container.<methodname>on_size_allocate()</methodname> receives the actual height and width that the parent container has decided to give to your widget. This might be more than the minimum, or even more than the natural size, for instance if the top-level window has been expanded. You might choose to ignore the extra space and leave a blank area, or you might choose to expand your child widgets to fill the space, or you might choose to expand the padding between your widgets. It's your container, so you decide. Don't forget to call <methodname>set_allocation()</methodname> inside your <methodname>on_size_allocate()</methodname> implementation to actually use the allocated space that has been offered by the parent container.<methodname>on_size_allocate()</methodname>: Position the child widgets, given the height and width that the container has actually been given.<methodname>on_size_allocate()</methodname>: Position the widget, given the height and width that it has actually been given.<methodname>on_unmap()</methodname>: (optional)<methodname>on_unrealize()</methodname>: (optional) Break the association with the <classname>Gdk::Window</classname>.<methodname>run()</methodname> may return <literal>PRINT_OPERATION_RESULT_IN_PROGRESS</literal>. To track status and handle the result or error you need to implement signal handlers for the <literal>done</literal> and <literal>status_changed</literal> signals:<methodname>set_row_spacing()</methodname> and <methodname>set_col_spacing()</methodname> set the spacing between the rows at the specified row or column. Note that for columns, the space goes to the right of the column, and for rows, the space goes below the row.<parameter>xoptions</parameter> and <parameter>yoptions</parameter> are used to specify packing options and may be bitwise ORed together to allow multiple options. These options are:<placeholder-1/> (or <placeholder-2/> for filenames)<placeholder-1/> Here, the programmer deletes pButton to prevent a memory leak.<placeholder-1/> Now, when objects of type <classname>MyWidget</classname> are destroyed, the button will also be deleted. It is no longer necessary to delete pButton to free the button's memory; its deletion has been delegated to the <classname>MyWidget</classname> object.<placeholder-1/> example package<type>GdkEventButton</type> is a structure containing the event's parameters, such as the coordinates of the mouse pointer at the time the button was pressed. There are several different types of <type>GdkEvent</type> structures for the various events.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. Standard buttons, usually marked with a label or picture. Pushing one triggers an action. See the <link linkend="sec-pushbuttons">Button</link> section.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>. These act like ToggleButtons, but show their state in small squares, with their label at the side. They should be used in most situations which require an on/off setting. See the <link linkend="sec-checkboxes">CheckBox</link> section.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>. Named after the station selectors on old car radios, these buttons are used in groups for options which are mutually exclusive. Pressing one causes all the others in its group to turn off. They are similar to CheckBoxes (a small widget with a label at the side), but usually look different. See the <link linkend="sec-radio-buttons">RadioButton</link> section.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>. Unlike a normal Button, which springs back up, a ToggleButton stays down until you press it again. It might be useful as an on/off switch. See the <link linkend="sec-toggle-buttons">ToggleButton</link> section.<varname>app_exec</varname>: The command line to be used to launch this resource. This string may contain the "f" and "u" escape characters which will be expanded to the resource file path and URI respectively<varname>app_name</varname>: The name of the application that registered the resource<varname>description</varname>: A short description of the resource as a UTF-8 encoded string<varname>display_name</varname>: The name of the resource to be used for display as a UTF-8 encoded string<varname>groups</varname>: A list of groups associated with this item. Groups are essentially arbitrary strings associated with a particular resource. They can be thought of as 'categories' (such as "email", "graphics", etc) or tags for the resource.<varname>is_private</varname>: Whether this resource should be visible only to applications that have registered it or not<varname>mime_type</varname>: The MIME type of the resourceA .hg file will typically include some headers and then declare a class, using some macros to add API or behaviour to this class. For instance, gtkmm's <filename>button.hg</filename> looks roughly like this: <placeholder-1/>A <classname>ComboBox</classname> may contain an <classname>Entry</classname> widget for entering of arbitrary text, by specifying true for the constructor's <literal>has_entry</literal> parameter.A <classname>Entry</classname> widget can offer a drop-down list of pre-existing choices based on the first few characters typed by the user. For instance, a search dialog could suggest text from previous searches.A <classname>Notebook</classname> has a set of stacked <literal>pages</literal>, each of which contains widgets. Labelled <literal>tabs</literal> allow the user to select the pages. <classname>Notebook</classname>s allow several sets of widgets to be placed in a small space, by only showing one page at a time. For instance, they are often used in preferences dialogs.A <classname>Plug</classname> is a special kind of Window that can be plugged into a <classname>Socket</classname>. Besides the normal properties and methods of <classname>Gtk::Window</classname>, a <classname>Plug</classname> provides a constructor that takes the ID of a <classname>Socket</classname>, which will automatically embed the <classname>Plug</classname> into the <classname>Socket</classname> that matches that ID.A <classname>ProgressBar</classname>is horizontal and left-to-right by default, but you can change it to a vertical progress bar by using the <methodname>set_orientation()</methodname> method.A <classname>RecentInfo</classname> object is essentially an object containing all of the metadata about a single recently-used file. You can use this object to look up any of the properties listed above. FIXME - add cross-reference.A <classname>Socket</classname> is a special kind of container widget that provides the ability to embed widgets from one process into another process in a way that is transparent to the user.A <classname>SpinButton</classname> allows the user to select a value from a range of numeric values. It has an Entry widget with up and down arrow buttons at the side. Clicking the buttons causes the value to 'spin' up and down across the range of possible values. The <classname>Entry</classname> widget may also be used to enter a value directly.A <classname>ToolPalette</classname> is similar to a <classname>Toolbar</classname> but can contain a grid of items, categorized into groups. The user may hide or expand each group. As in a toolbar, the items may be displayed as only icons, as only text, or as icons with text.A child widget can be added to the <classname>EventBox</classname> using:A little example follows. To use the example just execute it from a terminal; it doesn't create a window. It will create a pipe named <literal>testfifo</literal> in the current directory. Then start another shell and execute <literal>echo "Hello" &gt; testfifo</literal>. The example will print each line you enter until you execute <literal>echo "Q" &gt; testfifo</literal>.A nifty feature of Glib (one of the libraries underlying <application>gtkmm</application>) is the ability to have it check for data on a file descriptor for you. This is especially useful for networking applications. The following method is used to do this:A properly internationalized application will not make assumptions about the number of bytes in a character. That means that you shouldn't use pointer arithmetic to step through the characters in a string, and it means you shouldn't use <classname>std::string</classname> or standard C functions such as <function>strlen()</function> because they make the same assumption.A smartpointer acts much like a normal pointer. Here are a few examples.A target can be in a variety of binary formats. This chapter, and the examples, assume that the data is 8-bit text. This would allow us to use an XML format for the clipboard data. However this would probably not be appropriate for binary data such as images. <classname>Gtk::Clipboard</classname> provides overloads that allow you to specify the format in more detail if necessary.AM_CPPFLAGSAM_CPPFLAGS = ... -DPROGRAMNAME_LOCALEDIR=\"${PROGRAMNAME_LOCALEDIR}\"AM_CXXFLAGSATKAccessing widgetsActionsActivity ModeAdd <literal>INTLTOOL_FILES</literal> to the <literal>EXTRA_DIST</literal> list of files. This ensures that when you do a <command>make dist</command>, these commands will be included in the source tarball.Add <literal>po</literal> to the <literal>SUBDIRS</literal> variable. Without this, your translations won't get built and installed when you build the programAdd methods to wrap parts of the C API.Add rows to the model with the <methodname>append()</methodname>, <methodname>prepend()</methodname>, or <methodname>insert()</methodname> methods.Adding Items to the List of Recent FilesAdding RowsAdding View ColumnsAdding child rowsAdding properties, and ensuring that they interact properly with each other, is relatively difficult to correct in the C library, but it is possible, so do file a bug and try to send a patch to the relevant maintainer.Adding widgetsAdditional command-line flags passed to the <filename>generate_wrap_init.pl</filename> script, such as the C++ namespace and the parent directory prefix of include files.Additionally, mouse button 3 can be used to jump directly to the <literal>upper</literal> or <literal>lower</literal> values.Adjustment InternalsAdjustmentsAfter a <classname>Socket</classname> or <classname>Plug</classname> object is realized, you can obtain its ID with its <methodname>get_id()</methodname> function. This ID can then be shared with other processes so that other processes know how to connect to eachother.After appending rows to this model, you should provide the model to the <classname>ComboBox</classname> with the <methodname>set_model()</methodname> method. Then use the <methodname>pack_start()</methodname> or <methodname>pack_end()</methodname> methods to specify what methods will be displayed in the ComboBox. As with the TreeView you may either use the default cell renderer by passing the <classname>TreeModelColumn</classname> to the pack methods, or you may instantiate a specific <classname>CellRenderer</classname> and specify a particular mapping with either <methodname>add_attribute()</methodname> or <methodname>set_cell_data_func()</methodname>. Note that these methods are in the <classname>CellLayout</classname> base class.After building and running this program, try resizing the window to see the behaviour. Also, try playing with the options to <methodname>pack_start()</methodname> while reading the <link linkend="sec-boxes">Boxes</link> section.After drawing the outline, we go around the clock and draw ticks for every hour, with a larger tick at 12, 3, 6, and 9. Now we're finally ready to implement the time-keeping functionality of the clock, which simply involves getting the current values for hours, minutes and seconds, and drawing the hands at the correct angles.After putting the source code in <literal>simple.cc</literal> you can compile the above program with gcc using: <placeholder-1/> Note that you must surround the <literal>pkg-config</literal> invocation with backquotes. Backquotes cause the shell to execute the command inside them, and to use the command's output as part of the command line.After selecting the <guimenuitem>Recent Files Dialog</guimenuitem> menu item, you should see something similar to the following window.After setting the correct moduleset, you need to tell <application>jhbuild</application> which module or modules to build. To build <application>gtkmm</application> and all of its dependencies, set <varname>modules</varname> like so: <placeholder-1/>After starting <filename>socket</filename>, you should see the following output in the terminal:After which you should see something like the following:After you've created and set up the filter to match only the items you want, you can apply a filter to a chooser widget with the <methodname>RecentChooser::add_filter()</methodname> function.After you've finished creating your path, you still haven't drawn anything visible yet. To make the path visible, you must use the function <methodname>stroke()</methodname> which will stroke the current path with the line width and style specified in your <classname>Cairo::Context</classname> object. After stroking, the current path will be cleared so that you can start on your next path.After you've installed all of the dependencies, download the <application>gtkmm</application> source code, unpack it, and change to the newly created directory. <application>gtkmm</application> can be built and installed with the following sequence of commands:After you've installed the git version of <application>gtkmm</application>, you're ready to start using and experimenting with it. In order to use the new version of <application>gtkmm</application> you've just installed, you need to set some environment variables so that your <filename>configure</filename> script knows where to find the new libraries. Fortunately, <application>jhbuild</application> offers an easy solution to this problem. Executing the command <command>jhbuild shell</command> will start a new shell with all of the correct environment variables set. Now if you re-configure and build your project just as you usually do, it should link against the newly installed libraries. To return to your previous environment, simply exit the <application>jhbuild</application> shell.AlignmentAll <application>gtkmm</application> programs must include certain <application>gtkmm</application> headers; <literal>gtkmm.h</literal> includes the entire <application>gtkmm</application> kit. This is usually not a good idea, because it includes a megabyte or so of headers, but for simple programs, it suffices.All container widgets derive from <classname>Gtk::Container</classname>, not always directly. Some container widgets, such as <classname>Gtk::Table</classname> can hold many child widgets, so these typically have more complex interfaces. Others, such as <classname>Gtk::Frame</classname> contain only one child widget.All mentions of <varname>skeleton</varname> should be replaced by the correct name of the C library you are wrapping, such as "something" or "libsomething". In the same manner, all instances of <varname>SKELETON</varname> should be replaced by "SOMETHING" or "LIBSOMETHING", and all occurrences of <varname>Skeleton</varname> changed to "Something".Also, the value can be drawn in different positions relative to the trough, specified by the <methodname>set_value_pos()</methodname> method.Alternatively, if a complete list of possible entries would be too large or too inconvenient to generate, a callback slot may instead be specified with <methodname>set_match_func()</methodname>. That callback function. This is also useful if you wish to match on a part of the string other than the start.Alternatively, you can let a widget's container control when the widget is destroyed. In most cases, you want a widget to last only as long as the container it is in. To delegate the management of a widget's lifetime to its container, first create it with <function>manage()</function> and pack it into its container with <methodname>add()</methodname>. Now, the widget will be destroyed whenever its container is destroyed.Although <application>gtkmm</application> widget instances have lifetimes and scopes just like those of other C++ classes, <application>gtkmm</application> has an optional time-saving feature that you will see in some of the examples. <function>Gtk::manage()</function> allows you to say that a child widget is owned by the container into which you place it. This allows you to <function>new</function> the widget, add it to the container and forget about deleting it. You can learn more about <application>gtkmm</application> memory management techniques in the <link linkend="chapter-memory">Memory Management chapter</link>.Although Cairo can render text, it's not meant to be a replacement for Pango. Pango is a better choice if you need to perform more advanced text rendering such as wrapping or ellipsizing text. Drawing text with Cairo should only be done if the text is part of a graphic.Although the <literal>custom_widget_apply</literal> signal provides the widget you previously created, to simplify things you can keep the widgets you expect to contain some user input as class members. For example, let's say you have a <classname>Gtk::Entry</classname> called <literal>m_Entry</literal> as a member of your <classname>CustomPrintOperation</classname> class: <placeholder-1/>Although the name <classname>EventBox</classname> emphasises the event-handling method, the widget can also be used for clipping (and more; see the example below).Although we have shown the compilation command for the simple example, you really should use the automake and autoconf tools, as described in "Autoconf, Automake, Libtool", by G. V. Vaughan et al. The examples used in this book are included in the <application>gtkmm</application> package, with appropriate build files, so we won't show the build commands in future. You'll just need to find the appropriate directory and type <literal>make</literal>.Although you can specify the layout and appearance of windows and widgets with C++ code, you will probably find it more convenient to design your user interfaces with <literal>Glade</literal> and load them at runtime with <literal>Gtk::Builder</literal>. See the <link linkend="chapter-builder">Glade and Gtk::Builder</link> chapter.Although you can theoretically implement your own Model, you will normally use either the <classname>ListStore</classname> or <classname>TreeStore</classname> model classes.Although you can use C++ code to instantiate and arrange widgets, this can soon become tedious and repetitive. And it requires a recompilation to show changes. The <application>Glade</application> application allows you to layout widgets on screen and then save an XML description of the arrangement. Your application can then use the <application>Gtk::Builder</application> API to load that XML file at runtime and obtain a pointer to specifically named widget instances.Although your container might have its own method to set the child widgets, you should still provide an implementation for the virtual <methodname>on_add()</methodname> and <methodname>on_remove()</methodname> methods from the base class, so that the add() and remove() methods will do something appropriate if they are called.Although, in most cases, the programmer will prefer to allow containers to automatically destroy their children using <function>manage()</function> (see below), the programmer is not required to use <function>manage()</function>. The traditional <literal>new</literal> and <literal>delete</literal> operators may also be used.An <classname>Assistant</classname> splits a complex operation into steps. Each step is a page, containing a header, a child widget and an action area. The Assistant's action area has navigation buttons which update automatically depending on the type of the page, set with <methodname>set_page_type()</methodname>.An <classname>Entry</classname> widget can show a progress bar inside the text area, under the entered text. The progress bar will be shown if the <methodname>set_progress_fraction()</methodname> or <methodname>set_progress_pulse_step()</methodname> methods are called.An <classname>Entry</classname> widget can show an icon at the start or end of the text area. The icon can be specifed by methods such as <methodname>set_icon_from_pixbuf()</methodname> or <methodname>set_icon_from_stock()</methodname>. An application can respond to the user pressing the icon by handling the <methodname>signal_icon_press</methodname> signal.An <classname>InfoBar</classname> may show small items of information or to ask brief questions. Unlike a <classname>Dialog</classname>, it appears at the top of the current window instead of opening a new window. Its API is very similar to the <link linkend="chapter-dialogs">Gtk::Dialog</link> API.An improved Hello WorldAnastasovAnother thing to note about this example is that we made the call to <methodname>connect()</methodname> twice for the same signal object. This is perfectly fine - when the button is clicked, both signal handlers will be called.Another way of destroying the connection is your signal handler. It has to be of the type <classname>sigc::slot&lt;bool&gt;</classname>. As you see from the definition your signal handler has to return a value of the type <literal>bool</literal>. A definition of a sample method might look like this: <placeholder-1/>Another workaround is to add a <function>*_construct()</function> function that the C++ constructor can call after instantiating its own type. For instance, <placeholder-1/>Any additional non-generated <filename>.h</filename> and <filename>.cc</filename> source files may be placed in <filename>skeleton/skeletonmm/</filename> and listed in <filename>skeleton/skeletonmm/filelist.am</filename>, typically in the <varname>files_extra_h</varname> and <varname>files_extra_cc</varname> variables.Application LifetimeApplying TagsAs before, almost all of the interesting stuff is done in the expose event handler <methodname>on_expose_event()</methodname>. Before we dig into the expose event handler, notice that the constructor for the <classname>Clock</classname> widget connects a handler function <methodname>onSecondElapsed()</methodname> to a timer with a timeout period of 1000 milliseconds (1 second). This means that <methodname>onSecondElapsed()</methodname> will get called once per second. The sole responsibility of this function is to invalidate the window so that <application>gtkmm</application> will be forced to redraw it.As mentioned above, each <classname>TextView</classname> has a <classname>TextBuffer</classname>, and one or more <classname>TextView</classname> can share the same <classname>TextBuffer</classname>.As mentioned earlier, <classname>Gtk::Adjustment</classname> can emit signals. This is, of course, how updates happen automatically when you share an <classname>Adjustment</classname> object between a <classname>Scrollbar</classname> and another adjustable widget; all adjustable widgets connect signal handlers to their adjustment's <literal>value_changed</literal> signal, as can your program.As well as renaming the directories, we should rename some of the source files. For instance: <placeholder-1/> A number of the skeleton files must still be filled in with project-specific content later.As will be explained in the <link linkend="chapter-adjustment">Adjustment</link> section, all Range widgets are associated with a <classname>Adjustment</classname> object. To change the lower, upper, and current values used by the widget you need to use the methods of its <classname>Adjustment</classname>, which you can get with the <methodname>get_adjustment()</methodname> method. The <classname>Range</classname> widgets' default constructors create an <classname>Adjustment</classname> automatically, or you can specify an existing <classname>Adjustment</classname>, maybe to share it with another widget. See the <link linkend="chapter-adjustment">Adjustments</link> section for further details.As with <classname>Scrollbar</classname>s, there are separate widget types for horizontal and vertical widgets - <classname>Gtk::HScale</classname> and <classname>Gtk::VScale</classname>. The default constructors create an <classname>Adjustment</classname> with all of its values set to <literal>0.0</literal>. This isn't useful so you will need to set some <classname>Adjustment</classname> details to get meaningful behaviour.AspectFrameAssistantAssuming the displayed size of stringsAsynchronous operationsAt install time, the <filename>.po</filename> files are converted to a binary format (with the extension <filename>.mo</filename>) and placed in a system-wide directory for locale files, for example <filename>/usr/share/locale/</filename>.At the application development level, <application>gtkmm</application>'s printing API provides dialogs that are consistent across applications and allows us of Cairo's common drawing API, with Pango-driven text rendering. In the implementation of this common API, platform-specific backends and printer-specific drivers are used.At the least, the <function>_new()</function> function should not use any private API (functions that are only in a .c file). Even when there are no functions, we can sometimes reimplement 2 or 3 lines of code in a <function>_new()</function> function as long as those lines of code use API that is available to us.At the moment, we have separate tools for generating different parts of these <filename>.defs</filename>, so we split them up into separate files. For instance, in the <filename>gtk/src</filename> directory of the <application>gtkmm</application> sources, you will find these files: <placeholder-1/>Automatically-stored editable cells.Basic Type equivalentsBasic TypesBasicsBecause the user may enter arbitrary text, an active model row isn't enough to tell us what text the user has inputted. Therefore, you should retrieve the <classname>Entry</classname> widget with the <methodname>ComboBoxEntry::get_entry()</methodname> method and call <methodname>get_text()</methodname> on that.Because this automatic transformation is not always appropriate, you might want to provide hand-written text for a particular method. You can do this by copying the XML node for the function from your <filename>something_docs.xml</filename> file to the <filename>something_docs_override.xml</filename> file and changing the contents.Before attempting to install <application>gtkmm</application> 2.4, you might first need to install these other packages.Below is a short example to illustrate these functions. This example makes use of the Frame widget to better demonstrate the label styles. (The Frame widget is explained in the <link linkend="sec-frame">Frame</link> section.)BernhardBesides indicating the amount of progress that has occured, the progress bar can also be used to indicate that there is some activity; this is done by placing the progress bar in <emphasis>activity mode</emphasis>. In this mode, the progress bar displays a small rectangle which moves back and forth. Activity mode is useful in situations where the progress of an operation cannot be calculated as a value range (e.g., receiving a file of unknown length).Binding extra argumentsBjarne Stroustrup, "The C++ Programming Language" - section 14.4.2Box Packing 1Box Packing 2BoxesBuilding <application>gtkmm</application> on Win32But unlike most smartpointers, you can't use the * operator to access the underlying instance.But unlike normal pointers, <classname>RefPtr</classname>s are automatically initialized to null so you don't need to remember to do that yourself.ButtonButton boxes are a convenient way to quickly arrange a group of buttons. They come in both horizontal (<classname>Gtk::HButtonBox</classname>) and vertical (<classname>Gtk::VButtonBox</classname>) flavours. They are exactly alike, except in name and orientation.Button boxes support several layout styles. The style can be retrieved and changed using <methodname>get_layout()</methodname> and <methodname>set_layout()</methodname>.ButtonBoxButtonBoxesButtonsButtons are added to a <classname>ButtonBox</classname> with the <methodname>add()</methodname> method.By convention, glib/GTK+-style objects have <function>*_new()</function> functions, such as <function>example_widget_new()</function> that do nothing more than call <function>g_object_new()</function> and return the result. The input parameters are supplied to <function>g_object_new()</function> along with the names of the properties for which they are values. For instance, <placeholder-1/>By convention, structs are declared in glib/GTK+-style headers like so: <placeholder-1/>By default, <application>gtkmm</application> will be installed under the <filename>/usr/local</filename> directory. On some systems you may need to install to a different location. For instance, on Red Hat Linux systems you might use the <literal>--prefix</literal> option with configure, like so: <screen>
# ./configure --prefix=/usr
</screen>By default, <application>jhbuild</application>'s configuration is configured to install all software built with <application>jhbuild</application> under the <filename>/opt/gnome2</filename> prefix. You can choose a different prefix, but it is recommended that you keep this prefix different from other software that you've installed (don't set it to <filename>/usr</filename>!) If you've followed the jhbuild instructions then this prefix belongs to your user, so you don't need to run jhbuild as <literal>root</literal>.By default, <methodname>PrintOperation::run()</methodname> returns when a print operation is completed. If you need to run a non-blocking print operation, call <methodname>PrintOperation::set_allow_async()</methodname>. Note that <methodname>set_allow_async()</methodname> is not supported on all platforms, however the <literal>done</literal> signal will still be emitted.By default, only single rows can be selected, but you can allow multiple selection by setting the mode, like so: <placeholder-1/>By default, your signal handlers are called after any previously-connected signal handlers. However, this can be a problem with the X Event signals. For instance, the existing signal handlers, or the default signal handler, might return true to stop other signal handlers from being called. To specify that your signal handler should be called before the other signal handlers, so that will always be called, you can specify <literal>false</literal> for the optional <literal>after</literal> parameter. For instance, <placeholder-1/>By deriving directly from <classname>Gtk::Widget</classname> you can do all the drawing for your widget directly, instead of just arranging child widgets. For instance, a <classname>Gtk::Label</classname> draws the text of the label, but does not do this by using other widgets.By overriding <methodname>forall_vfunc()</methodname> you can allow applications to operate on all of the container's child widgets. For instance, <methodname>show_all_children()</methodname> uses this to find all the child widgets and show them.C programmers use <function>sprintf()</function> to compose and concatenate strings. C++ favours streams, but unfortunately, this approach makes translation difficult, because each fragment of text is translated separately, without allowing the translators to rearrange them according to the grammar of the language.C typeC++ typeCairo and PangoCall <methodname>add_drag_dest()</methodname> to allow items or groups to be dragged from the tool palette to a particular destination widget. You can then use <methodname>get_drag_item()</methodname> to discover which ToolItem or ToolItemGroup is being dragged. You can use <literal>dynamic_cast</literal> to discover whether is it an item or a group. For instance, you might use this in your <literal>drag_data_received</literal> signal handler, to add a dropped item, or to show a suitable icon while dragging.Call <methodname>show()</methodname> to display the widget.CastingCedricCells in a <classname>TreeView</classname> can be edited in-place by the user. To allow this, use the <classname>Gtk::TreeView</classname><methodname>insert_column_editable()</methodname> and <methodname>append_column_editable()</methodname> methods instead of <methodname>insert_column()</methodname> and <methodname>append_column()</methodname>. When these cells are edited the new values will be stored immediately in the Model. Note that these methods are templates which can only be instantiated for simple column types such as <classname>Glib::ustring</classname>, int, and long.Changing the layout of a window "on the fly", to make some extra widgets appear, for instance, is complex. It requires tedious recalculation of every widget's position.Changing the selectionChapter on "Drawing with Cairo".Chapter on "Printing".Chapter on "Recent Files".Chapter on "Timeouts".Chapter on "Win32 Installation".Chapter on "Working with gtkmm's Source Code".CheckButtonCheckboxesChecking for nullChildren can span multiple rows or columns, using <methodname>attach()</methodname>, or added next to an existing widget inside the grid with <methodname>attach_next_to()</methodname>. Individual rows and columns of the grid can be set to have uniform height or width with <methodname>set_row_homogeneous()</methodname> and <methodname>set_column_homogeneous()</methodname>. Set the <emphasis>margin</emphasis> and <emphasis>expand</emphasis> properties of the <classname>Widget</classname>s that are added to the grid, in order to control the geometry management.Class Scope widgetsClass macrosClipboard - IdealClipboard - SimpleColorSelectionDialogCombo BoxesComboBoxComboBox with an EntryComboBoxEntryComboBoxEntryTextComparison with other signalling systemsComposition of stringsConnect any signals you wish to use to the appropriate handlers.Connecting Plugs and SocketsConnecting signal handlersConst Objects used via <classname>RefPtr</classname>: If the object should not be changed by the function, then make sure that the object is const, even if the <classname>RefPtr</classname> is already const. For instance, <code>const Glib::RefPtr&lt;const Gtk::Action&gt;&amp; action</code>.ConstnessConstructorConstructor macrosConstructorsContainer WidgetsContributingCopyCopyingCopying the skeleton projectCreate a <classname>Plug</classname> independantly from any particular <classname>Socket</classname> and pass the ID of the <classname>Plug</classname> to other processes that need to use it. The ID of the <classname>Plug</classname> can be associated with a particular <classname>Socket</classname> object using the <methodname>Socket::add_id()</methodname> function. This is the approach used in the example below.Create a <classname>Socket</classname> object in one process and pass the ID of that <classname>Socket</classname> to another process so that it can create a <classname>Plug</classname> object by specifying the given <classname>Socket</classname> ID in its constructor. There is no way to assign a <classname>Plug</classname> to a particular <classname>Socket</classname> after creation, so you must pass the <classname>Socket</classname> ID to the <classname>Plug</classname>'s constructor.Create a sub-directory named <literal>po</literal> in your project's root directory. This directory will eventually contain all of your translations. Within it, create a file named <literal>LINGUAS</literal> and a file named <literal>POTFILES.in</literal>. It is common practice to also create a <literal>ChangeLog</literal> file in the <literal>po</literal> directory so that translators can keep track of translation changes.Create your own signals instead of passing pointers around. Objects can communicate with each other via signals and signal handlers. This is much simpler than objects holding pointers to each other and calling each other's methods. <application>gtkmm</application>'s classes uses special versions of <classname>sigc::signal</classname>, but you should use normal <classname>sigc::signal</classname>s, as described in the <application>libsigc++</application> documentation.Creating .hg and .ccg filesCreating an AdjustmentCreating your own signalsCummingCurrently, <application>gettext</application> does not support non-ASCII characters (i.e. any characters with a code above 127) in source code. For instance, you cannot use the copyright sign (©).Custom ContainerCustom ContainersCustom WidgetCustom WidgetsDISTCLEANFILES = ... intltool-extract \
                 intltool-merge \
                 intltool-update \
                 po/.intltool-merge-cacheDanielDeclare a variable of the type of <classname>Widget</classname> you wish to use, generally as member variable of a derived container class. You could also declare a pointer to the widget type, and then create it with <literal>new</literal> in your code. Even when using the widget via a pointer, it's still probably best to make that pointer a member variable of a container class so that you can access it later.Default formattingDefine <literal>INTLTOOL_FILES</literal> as: <placeholder-1/>Defines a custom clipboard target, though the format of that target is still text.DependenciesDereferencingDesigners without programming skills can create and edit UIs.DialogsDialogs are used as secondary windows, to provide specific information or to ask questions. <classname>Gtk::Dialog</classname> windows contain a few pre-packed widgets to ensure consistency, and a <methodname>run()</methodname> method which blocks until the user dismisses the dialog.Different applications contain different types of data, and they might make that data available in a variety of formats. <application>gtkmm</application> calls these data types <literal>target</literal>s.Different join types in CairoDisconnecting signal handlersDiscovering the available targetsDo an extra reference() on the return value, in case the C function does not provide a reference.Do not generate an <function>on_something()</function> virtual method to allow easy overriding of the default signal handler. Use this when adding a signal with a default signal handler would break the ABI by increasing the size of the class's virtual function table.DocumentationDocumentation build structureDrag and DropDragContextDrawing Arcs and CirclesDrawing Area - ArcsDrawing Area - LinesDrawing Curved LinesDrawing ImagesDrawing Images with GdkDrawing Straight LinesDrawing TextDrawing Text with PangoDrawing counter-clockwiseDrawing with relative coordinatesDuring a <literal>move</literal>, the source widget will also emit this signal: <placeholder-1/>Dynamic allocation with manage() and add()Dynamic allocation with new and deleteEach <classname>Cairo::Context</classname> is associated with a particular <classname>Gdk::Window</classname>, so the first line of the above example creates a <classname>Gtk::DrawingArea</classname> widget and the second line uses its associated <classname>Gdk::Window</classname> to create a <classname>Cairo::Context</classname> object. The final two lines change the graphics state of the context.Each <classname>Gtk::TextBuffer</classname> uses a <classname>Gtk::TextBuffer::TagTable</classname>, which contains the <classname>Tag</classname>s for that buffer. 2 or more <classname>TextBuffer</classname>s may share the same <classname>TagTable</classname>. When you create <classname>Tag</classname>s you should add them to the <classname>TagTable</classname>. For instance:Each <classname>Gtk::TreeView</classname> has an associated <classname>Gtk::TreeModel</classname>, which contains the data displayed by the <classname>TreeView</classname>. Each <classname>Gtk::TreeModel</classname> can be used by more than one <classname>Gtk::TreeView</classname>. For instance, this allows the same underlying data to be displayed and edited in 2 different ways at the same time. Or the 2 Views might display different columns from the same Model data, in the same way that 2 SQL queries (or "views") might show different fields from the same database table.Each item in the list of recently used files is identified by its URI, and can have associated metadata. The metadata can be used to specify how the file should be displayed, a description of the file, its mime type, which application registered it, whether it's private to the registering application, and several other things.Each line contains one horizontal box (<classname>HBox</classname>) with several buttons. Each of the buttons on a line is packed into the <classname>HBox</classname> with the same arguments to the <methodname>pack_start()</methodname> method).Editable CellsElstnerEmitted when the button is pressed and released.Emitted when the button is pressed.Emitted when the button is released.Emitted when the mouse pointer leaves the button's window.Emitted when the mouse pointer moves over the button's window.EntryEntry CompletionEntry Completion ExampleEntry Icon ExampleEntry IconsEntry ProgressEntry Progress ExampleEntry widgets allow the user to enter text. You can change the contents with the <methodname>set_text()</methodname> method, and read the current contents with the <methodname>get_text()</methodname> method.Entry with IconEntry with Progress BarEnumerations.EventBoxExampleExample Application: Creating a Clock with CairoExamplesExpecting UTF8Export to PDFExtending the print dialogFileChooserFileChooserDialogFiltering Recent FilesFinally, check the status. For instance, <placeholder-1/>Finally, to let you program use the translation for the current locale, add this code to the beginning of your <filename>main.cc</filename> file, to initialize gettext. <placeholder-1/>First create the <classname>Action</classname>s and add them to an <classname>ActionGroup</classname>, with <methodname>ActionGroup::add()</methodname>.First we instantiate an object called <literal>kit</literal>. This is of type <classname>Gtk::Main</classname>. Every <application>gtkmm</application> program must have one of these. We pass our command-line arguments to its constructor. It takes the arguments it wants, and leaves you the rest, as we described earlier.FontSelectionDialogFor a CellRendererToggle, you would set the <emphasis>activatable</emphasis> property instead.For all of these methods, the first argument is the <classname>Gdk::GC</classname>. The second argument is the object of the appropriate type to copy in: <classname>Gdk::Drawable</classname>, <classname>Gdk::Bitmap</classname>, <classname>Gdk::Image</classname>. The next two arguments are the x and y points in the image to begin copying from. Then come the x and y points in the drawing area to copy to. The final two arguments are the width and height of the area to copy.For any of the <classname>RecentChooser</classname> classes, if you don't wish to display all of the items in the list of recent files, you can filter the list to show only those that you want. You can filter the list with the help of the <classname>RecentFilter</classname> class. This class allows you to filter recent files by their name (<methodname>add_pattern()</methodname>), their mime type (<methodname>add_mime_type()</methodname>), the application that registered them (<methodname>add_application()</methodname>), or by a custom filter function (<methodname>add_custom()</methodname>). It also provides the ability to filter based on how long ago the file was modified and which groups it belongs to.For each page that needs to be rendered, the following signals are emitted: <placeholder-1/>For example, in <filename>dialog.hg</filename>: <placeholder-1/>For example, in <filename>progress.hg</filename>: <placeholder-1/>For example, in <filename>rectangle.hg</filename>: <placeholder-1/>For example: <placeholder-1/>For information about implementing your own signals rather than just connecting to the existing <application>gtkmm</application> signals, see the <link linkend="chapter-custom-signals">appendix</link>.For instance,For instance, <placeholder-1/>For instance, for <classname>Gdk::Color</classname>: <placeholder-1/>For instance, for <classname>Gdk::Rectangle</classname>: <placeholder-1/>For instance, for <classname>Gdk::Region</classname>: <placeholder-1/>For instance, for <classname>Pango::AttrIter</classname>: <placeholder-1/>For instance, for <classname>Pango::Coverage</classname>: <placeholder-1/>For instance, for a CellRendererText, you would set the cell's <emphasis>editable</emphasis> property to true, like so:For instance, from <filename>accelgroup.hg</filename>: <placeholder-1/>For instance, from <filename>button.hg</filename>: <placeholder-1/>For instance, from <filename>buttonbox.hg</filename>: <placeholder-1/>For instance, from <filename>celleditable.hg</filename>: <placeholder-1/>For instance, from <filename>container.hg</filename>: <placeholder-1/>For instance, from <filename>entry.hg</filename>: <placeholder-1/>For instance, from <filename>pixbuf.hg</filename>: <placeholder-1/>For instance, from <filename>widget.hg</filename>: <placeholder-1/>For instance, gedit can supply and receive the <literal>"UTF8_STRING"</literal> target, so you can paste data into gedit from any application that supplies that target. Or two different image editing applications might supply and receive a variety of image formats as targets. As long as one application can receive one of the targets that the other supplies then you will be able to copy data from one to the other.For instance, let's pretend that we are wrapping a C library called libexample. It provides a <classname>GObject</classname>-based API with types named, for instance, <classname>ExampleThing</classname> and <classname>ExampleStuff</classname>.For instance, this code would be problematic:For instance, to create a signal that sends 2 parameters, a <type>bool</type> and an <type>int</type>, just declare a <classname>sigc::signal</classname>, like so: <placeholder-1/>For instance:For more detailed information about signals, see the <link linkend="chapter-signals">appendix</link>.For multiple-selection, you need to define a callback, and give it to <methodname>selected_foreach()</methodname>, <methodname>selected_foreach_path()</methodname>, or <methodname>selected_foreach_iter()</methodname>, like so:For reference, it is possible to generate a file which contains all strings which appear in your code, even if they are not marked for translation, together with file name and line number references. To generate such a file named <literal>my-strings</literal>, execute the following command, within the source code directory: <placeholder-1/>For single-selection, you can just call <methodname>get_selected()</methodname>, like so:For the input of passwords, passphrases and other information you don't want echoed on the screen, calling <methodname>set_visibility()</methodname> with <literal>false</literal> will cause the text to be hidden.FrameFrames can enclose one or a group of widgets within a box, optionally with a title. For instance, you might place a group of <classname>RadioButton</classname>s or <classname>CheckButton</classname>s in a <classname>Frame</classname>.From time to time, it may be useful to be able to embed a widget from another application within your application. <application>gtkmm</application> allows you to do this with the <classname>Gtk::Socket</classname> and <classname>Gtk::Plug</classname> classes. It is not anticipated that very many applications will need this functionality, but in the rare case that you need to display a widget that is running in a completely different process, these classes can be very helpful.Full ExampleFunction scope widgetsGTK+ 3.0GTK+ and <application>gtkmm</application> were designed to work well with Microsoft Windows, and the developers encourage its use on the win32 platform. However, Windows has no standard installation system for development libraries. Please see the <ulink url="http://live.gnome.org/gtkmm/MSWindows">Windows Installation</ulink> page for Windows-specific installation instructions and notes.GTK+ uses the <ulink url="http://cairographics.org">Cairo</ulink> drawing API. With gtkmm, you may use the <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink> C++ API for cairo.GeneGenerating the .defs files.Generating the enums .defsGenerating the methods .defsGenerating the signals and properties .defsGeneration of the source code for a gtkmm-style wrapper API requires use of tools such as <command>gmmproc</command> and <filename>generate_wrap_init.pl</filename>. In theory you could write your own build files to use these appropriately, but a much better option is to make use of the build infrastructure provided by the mm-common module. To get started, it helps a lot to pick an existing binding module as an example to look at.Get the data from the widgets in the <literal>custom_widget_apply</literal> signal handler.Getting help with translationsGetting valuesGlade and Gtk::BuilderGlib::IO_ERR - Call your method when an error has occurred on the file descriptor.Glib::IO_HUP - Call your method when hung up (the connection has been broken usually for pipes and sockets).Glib::IO_IN - Call your method when there is data ready for reading on your file descriptor.Glib::IO_OUT - Call your method when the file descriptor is ready for writing.Glib::IO_PRI - Call your method when the file descriptor has urgent data to be read.Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

//Targets:
std::list&lt;Gtk::TargetEntry&gt; listTargets;
listTargets.push_back( Gtk::TargetEntry("example_custom_target") );
listTargets.push_back( Gtk::TargetEntry("UTF8_STRING") );

refClipboard-&gt;set( listTargets,
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_get),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_clear) );Glib::RefPtr&lt;Gtk::ListStore&gt; refListStore =
    Gtk::ListStore::create(m_Columns);Glib::RefPtr&lt;Gtk::RecentManager&gt; recent_manager = Gtk::RecentManager::get_default();
recent_manager-&gt;add_item(uri);Glib::RefPtr&lt;Gtk::TextBuffer::Mark&gt; refMark =
    refBuffer-&gt;create_mark(iter);Glib::RefPtr&lt;Gtk::TextBuffer::Tag&gt; refTagMatch =
    Gtk::TextBuffer::Tag::create();
refTagMatch-&gt;property_background() = "orange";Glib::RefPtr&lt;Gtk::TextBuffer::TagTable&gt; refTagTable =
    Gtk::TextBuffer::TagTable::create();
refTagTable-&gt;add(refTagMatch);
//Hopefully a future version of <application>gtkmm</application> will have a set_tag_table() method,
//for use after creation of the buffer.
Glib::RefPtr&lt;Gtk::TextBuffer&gt; refBuffer =
    Gtk::TextBuffer::create(refTagTable);Glib::RefPtr&lt;Gtk::TextChildAnchor&gt; refAnchor =
    refBuffer-&gt;create_child_anchor(iter);Glib::RefPtr&lt;Gtk::TreeModelSort&gt; sorted_model =
    Gtk::TreeModelSort::create(model);
sorted_model-&gt;set_sort_column(columns.m_col_name, Gtk::SORT_ASCENDING);
treeview.set_model(sorted_model);Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
    m_TreeView.get_selection();Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager =
    Gtk::UIManager::create();
m_refUIManager-&gt;insert_action_group(m_refActionGroup);
add_accel_group(m_refUIManager-&gt;get_accel_group());Glib::ustringGlib::ustring and std::iostreamsGlib::ustring strText = row[m_Columns.m_col_text];
int number = row[m_Columns.m_col_number];Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;menubar name='MenuBar'&gt;"
    "    &lt;menu action='MenuFile'&gt;"
    "      &lt;menuitem action='New'/&gt;"
    "      &lt;menuitem action='Open'/&gt;"
    "      &lt;separator/&gt;"
    "      &lt;menuitem action='Quit'/&gt;"
    "    &lt;/menu&gt;"
    "    &lt;menu action='MenuEdit'&gt;"
    "      &lt;menuitem action='Cut'/&gt;"
    "      &lt;menuitem action='Copy'/&gt;"
    "      &lt;menuitem action='Paste'/&gt;"
    "    &lt;/menu&gt;"
    "  &lt;/menubar&gt;"
    "  &lt;toolbar  name='ToolBar'&gt;"
    "    &lt;toolitem action='Open'/&gt;"
    "    &lt;toolitem action='Quit'/&gt;"
    "  &lt;/toolbar&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;popup name='PopupMenu'&gt;"
    "    &lt;menuitem action='ContextEdit'/&gt;"
    "    &lt;menuitem action='ContextProcess'/&gt;"
    "    &lt;menuitem action='ContextRemove'/&gt;"
    "  &lt;/popup&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);GridGroupsGtk::Adjustment(float value,
                float lower,
                float upper,
                float step_increment = 1,
                float page_increment = 10,
                float page_size = 0);Gtk::Alignment
Gtk::Arrow
Gtk::Bin
Gtk::Box
Gtk::Button
Gtk::CheckButton
Gtk::Fixed
Gtk::Image
Gtk::Item
Gtk::Label
Gtk::MenuItem
Gtk::Notebook
Gtk::Paned
Gtk::Pixmap
Gtk::RadioButton
Gtk::Range
Gtk::ScrolledWindow
Gtk::Separator
Gtk::Table
Gtk::Toolbar
Gtk::AspectFrame
Gtk::Frame
Gtk::VBox
Gtk::HBox
Gtk::VSeparator
Gtk::HSeparatorGtk::Box(bool homogeneous = false, int spacing = 0);Gtk::Button* pButton = new Gtk::Button("_Something", true);Gtk::Button* pButton = new Gtk::Button(Gtk::Stock::OK);Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
int cols_count = m_TreeView.append_column("Alex", *pRenderer);
Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
if(pColumn)
{
  pColumn-&gt;add_attribute(pRenderer-&gt;property_active(),
      m_columns.alex);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_visible(),
      m_columns.visible);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_activatable(),
      m_columns.world);Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
pRenderer-&gt;signal_toggled().connect(
    sigc::bind( sigc::mem_fun(*this,
        &amp;Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
);Gtk::DrawingArea myArea;
Cairo::RefPtr&lt;Cairo::Context&gt; myContext = myArea.get_window()-&gt;create_cairo_context();
myContext-&gt;set_source_rgb(1.0, 0.0, 0.0);
myContext-&gt;set_line_width(2.0);Gtk::EXPANDGtk::EventBox();Gtk::FILLGtk::Label support some simple formatting, for instance allowing you to make some text bold, colored, or larger. You can do this by providing a string to <methodname>set_markup()</methodname>, using the <ulink url="http://library.gnome.org/devel/pango/unstable/PangoMarkupFormat.html">Pango Markup syntax</ulink>. For instance, <code> &lt;b&gt;bold text&lt;/b&gt; and &lt;s&gt;strikethrough text&lt;/s&gt; </code> .Gtk::Main kit(argc, argv);Gtk::Main::run(window);Gtk::RecentInfo info = recent_manager-&gt;lookup_item(uri);
if (info)
{
  // item was found
}Gtk::SHRINKGtk::Table(int rows = 1, int columns = 1, bool homogeneous = false);Gtk::TreeModel::Children children = row.children();Gtk::TreeModel::Row row = *iter;Gtk::TreeModel::Row row = m_refModel-&gt;children()[5]; //The fifth row.
if(row)
  refTreeSelection-&gt;select(row);Gtk::TreeModel::iterator iter = m_Combo.get_active();
if(iter)
{
  Gtk::TreeModel::Row row = *iter;

  //Get the data for the selected row, using our knowledge
  //of the tree model:
  int id = row[m_Columns.m_col_id];
  set_something_id_chosen(id); //Your own function.
}
else
  set_nothing_chosen(); //Your own function.Gtk::TreeModel::iterator iter = m_refListStore-&gt;append();Gtk::TreeModel::iterator iter = m_refModel-&gt;children().begin()
if(iter)
  refTreeSelection-&gt;select(iter);Gtk::TreeModel::iterator iter_child =
    m_refListStore-&gt;append(row.children());Gtk::TreeView::Column* pColumn =
    Gtk::manage( new Gtk::TreeView::Column("Symbol") );

// m_columns.icon and m_columns.symbol are columns in the model.
// pColumn is the column in the TreeView:
pColumn-&gt;pack_start(m_columns.icon, false); //false = don't expand.
pColumn-&gt;pack_start(m_columns.symbol);

m_TreeView.append_column(*pColumn);Gtk::TreeView::Column* pColumn = treeview.get_column(0);
if(pColumn)
  pColumn-&gt;set_sort_column(m_columns.m_col_id);Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
pBox-&gt;add(*pMenuBar, Gtk::PACK_SHRINK);Gtk::Window window;GustinHand-coded source filesHand-coding constructorsHandling <literal>button_press_event</literal>Handling an X event doesn't affect the Widget's other signals. If you handle <literal>button_pressed_event</literal> for <classname>Gtk::Button</classname>, you'll still be able to get the <literal>clicked</literal> signal. They are emitted at (nearly) the same time.Headers and LinkingHello WorldHello World 2Hello World in <application>gtkmm</application>HelloWorld::HelloWorld()
:
  m_button ("Hello World")
{
  set_border_width(10);
  m_button.signal_clicked().connect(sigc::mem_fun(*this,
    &amp;HelloWorld::on_button_clicked));
  add(m_button);.
  m_button.show();
}Here are some examples of normal C++ memory management:Here is a list of some of these Widgets:Here is a simple example that packs 100 toggle buttons into a ScrolledWindow. Try resizing the window to see the scrollbars react.Here is a small bit of code to tie it all together: (Note that usually you wouldn't load the image every time in the expose event handler! It's just shown here to keep it all together)Here is a very simple example, demonstrating a drag and drop <literal>Copy</literal> operation:Here is an example callback method:Here is some example code from <filename>demos/gtk-demo/example_stockbrowser.cc</filename>, which has a pixbuf icon and a text name in the same column:Here is the source code for the example that produced the screenshots above. When you run this example, provide a number between 1 and 3 as a command-line option, to see different packing options in use.Here we define a new class called <classname>OverriddenButton</classname>, which inherits from <classname>Gtk::Button</classname>. The only thing we change is the <methodname>on_clicked()</methodname> method, which is called whenever <classname>Gtk::Button</classname> emits the <literal>clicked</literal> signal. This method prints "Hello World" to <literal>stdout</literal>, and then calls the original, overridden method, to let <classname>Gtk::Button</classname> do what it would have done had we not overridden.Here's a simple example: <placeholder-1/>Here's a slightly larger example of slots in action:Here's an example of a <classname>SpinButton</classname> in action:Here's an example of a signal handler being connected to a signal:Here's an example of a simple program that draws an arc, a circle and an ellipse into a drawing area.Here's an example of this technique:Here's the constructor for the box widgets: <placeholder-1/> Passing <literal>true</literal> for <parameter>homogeneous</parameter> will cause all of the contained widgets to be the same size. <parameter>spacing</parameter> is a (minimum) number of pixels to leave between each widget.How gettext worksHow to use GNOME CVS as a TranslatorHowever, <application>Glib</application> defines <function>gettext()</function> support macros which are shorter wrappers in an easy-to-use form. To use these macros, include <literal>&lt;glibmm/i18n.h&gt;</literal>, and then, for example, substitute: <placeholder-1/> with: <placeholder-2/>However, this does not allow you any control of which items can be dragged, and where they can be dropped. If you need that extra control then you might create a derived <literal>Gtk::TreeModel</literal> from <literal>Gtk::TreeStore</literal> or <literal>Gtk::ListStore</literal> and override the <literal>Gtk::TreeDragSource::row_draggable()</literal> and <literal>Gdk::TreeDragDest::row_drop_possible()</literal> virtual methods. You can examine the <literal>Gtk::TreeModel::Path</literal>s provided and allow or disallow dragging or dropping by return <literal>true</literal> or <literal>false</literal>.However, this is even simpler when using the <function>PKG_CHECK_MODULES()</function> macro in a standard configure.ac file with autoconf and automake. For instance: <placeholder-1/> This checks for the presence of gtkmm and defines MYAPP_LIBS and MYAPP_CFLAGS for use in your Makefile.am files.However, you might not want the new values to be stored immediately. For instance, maybe you want to restrict the input to certain characters or ranges of values.However, you probably already avoid bare char* arrays and pointer arithmetic by using <classname>std::string</classname>, so you just need to start using <classname>Glib::ustring</classname> instead. See the <link linkend="sec-basics-ustring">Basics</link> chapter about <classname>Glib::ustring</classname>.I've been embedded.
A plug was addedINTLTOOL_FILES = intltool-extract.in \
                 intltool-merge.in \
                 intltool-update.inIT_PROG_INTLTOOL([0.35.0])

GETTEXT_PACKAGE=programname
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                   [The domain to use with gettext])
AM_GLIB_GNU_GETTEXT

PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
AC_SUBST(PROGRAMNAME_LOCALEDIR)IdealIdeally, we would like you to <ulink url="http://www.gtkmm.org/bugs.shtml">provide a patch</ulink> to the <filename>docs/tutorial/C/gtkmm-tutorial-in.xml</filename> file. This file is currently in the <literal>gtkmm-documentation</literal> module in GNOME git.Idle FunctionsIf a programmer does not need a class scope widget, a function scope widget may also be used. The advantages to function scope over class scope are the increased data hiding and reduced dependencies. <placeholder-1/>If a programmer does not need dynamic memory allocation, automatic widgets in class scope may be used. One advantage of automatic widgets in class scope is that memory management is grouped in one place. The programmer does not risk memory leaks from failing to <literal>delete</literal> a widget.If everything worked correctly, you should be able to build <application>gtkmm</application> and all of its dependencies from git by executing <command>jhbuild build</command> (or, if you didn't specify <application>gtkmm</application> in the <varname>modules</varname> variable, with the command <command>jhbuild build gtkmm</command>).If for some reason the <classname>Socket</classname> couldn't attach the <classname>Plug</classname>, the window would look something like this:If the enum is not a <classname>GType</classname>, you must pass a third parameter NO_GTYPE. This is the case when there is no <function>*_get_type()</function> function for the C enum, but be careful that you don't just need to include an extra header for that function. You should also file a bug against the C API, because all enums should be registered as GTypes.If the table box is larger than the widget, and <literal>Gtk::FILL</literal> is specified, the widget will expand to use all the room available.If the table widget is allocated less space than it requested (because the user resized the window), then the widgets will normally just disappear off the bottom of the window. If <literal>Gtk::SHRINK</literal> is specified, the widgets will shrink with the table.If this is the first time you're using a program that uses the Recent Files framework, the dialog may be empty at first. Otherwise it should show the list of recently used documents registered by other applications.If you are interested in helping out with the development of <application>gtkmm</application>, or fixing a bug in <application>gtkmm</application>, you'll probably need to build the development version of <application>gtkmm</application>. However, you should not to install a development version over your stable version. Instead, you should install it alongside your existing <application>gtkmm</application> installation, in a separate path.If you are using <application>gettext</application> directly, you can only mark strings for translation if they are in source code file. However, if you use <application>intltool</application>, you can mark strings for translation in a variety of other file formats, including <application>Glade</application> UI files, xml, <ulink url="http://standards.freedesktop.org/desktop-entry-spec/latest/">.desktop files</ulink> and several more. So, if you have designed some of the application UI in <application>Glade</application> then also add your <filename>.glade</filename> files to the list in <literal>POTFILES.in</literal>.If you call <methodname>Gtk::TreeView::set_reorderable()</methodname> then your TreeView's items can be moved within the treeview itself. This is demonstrated in the <classname>TreeStore</classname> example.If you copied the skeleton source tree in mm-common and substituted the placeholder text, then you will already have suitable <filename>Makefile.am</filename> and <filename>Doxyfile.in</filename> files. With the mm-common build setup, the list of Doxygen input files is not defined in the Doxygen configuration file, but passed along from <command>make</command> to the standard input of <command>doxygen</command>. The input file list is defined by the <varname>doc_input</varname> variable in the <filename>Makefile.am</filename> file.If you copy a <classname>RefPtr</classname>, for instance <placeholder-1/> , or if you pass it as a method argument or a return type, then <classname>RefPtr</classname> will do any necessary referencing to ensure that the instance will not be destroyed until the last <classname>RefPtr</classname> has gone out of scope.If you do decide to contribute, please post your contribution to the <application>gtkmm</application> mailing list at <ulink url="mailto:gtkmm-list@gnome.org">&lt;gtkmm-list@gnome.org&gt;</ulink>. Also, be aware that the entirety of this document is free, and any addition you provide must also be free. That is, people must be able to use any portion of your examples in their programs, and copies of this document (including your contribution) may be distributed freely.If you don't want to look for a specific URI, but instead want to get a list of all recently used items, <classname>RecentManager</classname> provides the <methodname>get_items()</methodname> function. The return value of this function can be assigned to any standard C++ container (e.g. <classname>std::vector</classname>, <classname>std::list</classname>, etc) and contains a list of all recently-used files up to a user-defined limit (FIXME: what's the default limit?). The following code demonstrates how you might get a list of recently-used files:If you have created a <classname>Tag</classname> and added it to the <classname>TagTable</classname>, you may apply that tag to part of the <classname>TextBuffer</classname> so that some of the text is displayed with that formatting. You define the start and end of the range of text by specifying <classname>Gtk::TextBuffer::iterator</classname>s. For instance:If you share an adjustment object between a Scrollbar and a TextView widget, manipulating the scrollbar will automagically adjust the TextView widget. You can set it up like this:If you use one signal handler to catch the same signal from several widgets, you might like that signal handler to receive some extra information. For instance, you might want to know which button was clicked. You can do this with <function>sigc::bind()</function>. Here's some code from the <link linkend="sec-helloworld2">helloworld2</link> example, which you will encounter later. <placeholder-1/> This says that we want the signal to send an extra <classname>Glib::ustring</classname> argument to the signal handler, and that the value of that argument should be "button 1". Of course we will need to add that extra argument to the declaration of our signal handler: <placeholder-2/> Of course, a normal "clicked" signal handler would have no arguments.If you want to help develop <application>gtkmm</application> or experiment with new features, you can also install <application>gtkmm</application> from git. Most users will never need to do this, but if you're interested in helping with <application>gtkmm</application> development, see the <link linkend="chapter-working-with-source">Working with gtkmm's Source Code</link> appendix.If you want to register a file with metadata, you can pass a <classname>RecentManager::Data</classname> parameter to <methodname>add_item()</methodname>. The metadata that can be set on a particular file item is as follows:If you want to specify a method that gets called when nothing else is happening, use the following:If you wish to learn more about smartpointers, you might look in these books: <placeholder-1/>If you've drawn a series of lines that form a path, you may want them to join together in a certain way. Cairo offers three different ways to join lines together: Miter, Bevel, and Round. These are show below:If you've never used a packing toolkit before, it can take some getting used to. You'll probably find, however, that you don't need to rely on visual form editors quite as much as you might with other toolkits.If your distribution does not provide a pre-built <application>gtkmm</application> package, or if you want to install a different version than the one provided by your distribution, you can also install <application>gtkmm</application> from source. The source code for <application>gtkmm</application> can be downloaded from <ulink url="http://www.gtkmm.org/"/>.If your program is free software, there is a whole <literal>GNOME</literal> subproject devoted to helping you make translations, the <ulink url="http://developer.gnome.org/projects/gtp/"><literal>GNOME</literal> Translation Project</ulink>.Implementing custom logic for editable cells.In <filename>configure.ac</filename>, <placeholder-1/>In <filename>skeleton/skeletonmm/Makefile.am</filename> we must mention the correct values for the generic variables that are used elsewhere in the build system:In <filename>skeleton/src/Makefile.am</filename> we must mention the correct values for the generic variables that are used elsewhere in the build system:In addition to adding items to the list, you can also look up items from the list and modify or remove items.In addition to changing a file's URI, you can also remove items from the list, either one at a time or by clearint them all at once. The former is accomplished with <methodname>remove_item()</methodname>, the latter with <methodname>purge_items()</methodname>.In addition to drawing basic straight lines, there are a number of things that you can customize about a line. You've already seen examples of setting a line's color and width, but there are others as well.In addition to drawing straight lines Cairo allows you to easily draw curved lines (technically a cubic Bézier spline) using the <methodname>Cairo::Context::curve_to()</methodname> and <methodname>Cairo::Context::rel_curve_to()</methodname> functions. These functions take coordinates for a destination point as well as coordinates for two 'control' points. This is best explained using an example, so let's dive in.In general, gtkmm-style projects use Doxygen, which reads specially formatted C++ comments and generates HTML documentation. You may write these doxygen comments directly in the header files.In the <link linkend="sec-wrapping-hg-files">.hg and .ccg files</link> section you can learn about the syntax used in these files.In the example above we drew everything using absolute coordinates. You can also draw using relative coordinates. For a straight line, this is done with the function <methodname>Cairo::Context::rel_line_to()</methodname>.In the following example, we make a window with three buttons in a 2 x 2 table. The first two buttons will be placed in the upper row. A third button is placed in the lower row, spanning both columns.In the following example, we make a window with three buttons in a grid. The first two buttons will be placed in the upper row, from left to right. A third button is attached underneath the first buttion, in a new lower row, spanning two columns.In the instructions below we will assume that you will not be using <application>gettext</application> directly, but <application>intltool</application>, which was written specifically for <literal>GNOME</literal>. <application>intltool</application> uses <function>gettext()</function>, which extracts strings from source code, but <application>intltool</application> can also combine strings from other files, for example from desktop menu details, and GUI resource files such as <application>Glade</application> files, into standard <application>gettext</application><filename>.pot/.po</filename> files.In the top-level Makefile.am: <placeholder-1/>In these cases, you should add extra characters to the strings. For instance, use <literal>"jumps[noun]"</literal> and <literal>"jumps[verb]"</literal> instead of just <literal>"jumps"</literal>) and strip them again outside the <function>gettext</function> call. If you add extra characters you should also add a comment for the translators before the <function>gettext</function> call. Such comments will be shown in the <filename>.po</filename> files. For instance:In this example, we'll construct a small but fully functional <application>gtkmm</application> program and draw some lines into the window. The lines are drawn by creating a path and then stroking it. A path is created using the functions <methodname>Cairo::Context::move_to()</methodname> and <methodname>Cairo::Context::line_to()</methodname>. The function <methodname>move_to()</methodname> is similar to the act of lifting your pen off of the paper and placing it somewhere else -- no line is drawn between the point you were at and the point you moved to. To draw a line between two points, use the <methodname>line_to()</methodname> function.In this section of the tutorial, we'll cover the basic Cairo drawing model, describe each of the basic drawing elements in some detail (with examples), and then present a simple application that uses Cairo to draw a custom clock widget.In your <literal>src/Makefile.am</literal>, update your <literal>AM_CPPFLAGS</literal> to add the following preprocessor macro definition:In your callback, compare the list of available targets with those that your application supports for pasting. You could enable or disable a Paste menu item, depending on whether pasting is currently possible. For instance:In your signal handler, you should examine the new value and then store it in the Model if that is appropriate for your application.Includes the other files.Independently sorted views of the same modelInfoBarInheritance can be used to derive new widgets. The derivation of new widgets in GTK+ C code is so complicated and error prone that almost no C coders do it. As a C++ developer you know that derivation is an essential Object Orientated technique.InitializationInstallationInstalling <application>gtkmm</application> with <application>jhbuild</application>Installing From SourceInstalling and Using the git version of <application>gtkmm</application>Instead of laboriously connecting signal handlers to signals, you can simply make a new class which inherits from a widget - say, a Button - and then override the default signal handler, such as Button::on_clicked(). This can be a lot simpler than hooking up signal handlers for everything.Intermediate typesInternationalization and LocalizationInternationalizing GNOME applicationsIntltool READMEIntroductionIt follows the same form. The number 3 at the end of the type's name indicates that our signal handler will need three arguments. The first type in the type list is <type>void</type>, so that should be our signal handler's return type. The following three types are the argument types, in order. Our signal handler's prototype could look like this:It is common for binding modules to track the version number of the library they are wrapping. So, for instance, if the C library is at version 1.23.4, then the initial version of the binding module would be 1.23.0. However, avoid starting with an even minor version number as that usually indicates a stable release.It is good practice to put all modifications to the graphics state between <methodname>save()</methodname>/<methodname>restore()</methodname> function calls. For example, if you have a function that takes a <classname>Cairo::Context</classname> reference as an argument, you might implement it as follows:It supports pasting of 2 targets - both the custom one and a text one that creates an arbitrary text representation of the custom data.It uses <methodname>request_targets()</methodname> and the <literal>owner_change</literal> signal and disables the Paste button if it can't use anything on the clipboard.It's impossible to predict the amount of space necessary for text after it has been translated to other languages, or displayed in a different font. On Unix it is also impossible to anticipate the effects of every theme and window manager.It's possible that certain strings will be marked as <literal>fuzzy</literal> in the <filename>.po</filename> file. These translations will not substitute the original string. To make them appear, simply remove the <literal>fuzzy</literal> tag.Iterating over Model RowsIteratorsJonathonJongsmaJust call the non-const version of the same function, instead of generating almost duplicate code.Just like normal pointers, you can check whether a <classname>RefPtr</classname> points to anything.LabelLabels are the main method of placing non-editable text in windows, for instance to place a title next to a <classname>Entry</classname> widget. You can specify the text in the constructor, or later with the <methodname>set_text()</methodname> or set_markup() methods.Lack of propertiesLaursenLess C++ code is required.Let's look at an example of overriding:Let's take a look at a slightly improved <literal>helloworld</literal>, showing what we've learnt.Let's take another look at a Signal's <literal>connect</literal> method:Like checkboxes, radio buttons also inherit from <classname>Gtk::ToggleButton</classname>, but these work in groups, and only one RadioButton in a group can be selected at any one time.Like the <classname>TreeView</classname>, you should probably put your <classname>TextView</classname> inside a <classname>ScrolledWindow</classname> to allow the user to see and move around the whole text area with scrollbars.Likewise, replace all instances of <varname>Joe Hacker</varname> by the name of the intended copyright holder, which is probably you. Do the same for the <varname>joe@example.com</varname> email address.Line ends can have different styles as well. The default style is for the line to start and stop exactly at the destination points of the line. This is called a Butt cap. The other options are Round (uses a round ending, with the center of the circle at the end point) or Square (uses a squared ending, with the center of the square at the end point). This setting is set using the function <methodname>Cairo::Context::set_line_cap()</methodname>.Line stylesListStoreListStore, for rowsLoading the .glade fileLooking up Items in the List of Recent FilesLots of people need to implement right-click context menus for <classname>TreeView</classname>'s so we will explain how to do that here to save you some time. Apart from one or two points, it's much the same as a normal context menu, as described in the <link linkend="sec-menus-popup">menus chapter</link>.Main MenuMain Menu exampleMakefile.am filesManaged WidgetsMany Cairo drawing functions have a <methodname>_preserve()</methodname> variant. Normally drawing functions such as <methodname>clip()</methodname>, <methodname>fill()</methodname>, or <methodname>stroke()</methodname> will clear the current path. If you use the <methodname>_preserve()</methodname> variant, the current path will be retained so that you can use the same path with the next drawing function.Many GUI toolkits require you to precisely place widgets in a window, using absolute positioning, often using a visual editor. This leads to several problems:Marking strings for translationMarkoMarksMaybe the user should not be able to select every item in your list or tree. For instance, in the gtk-demo, you can select a demo to see the source code, but it doesn't make any sense to select a demo category.Member instances can be used, simplifying memory management. All GTK+ C widgets are dealt with by use of pointers. As a C++ coder you know that pointers should be avoided where possible.Memory managementMenus and ToolbarsMessageDialogMethod macrosMethodsMicrosoft WindowsMiscellaneous WidgetsMixing C and C++ APIsModel ColumnsModelColumns()
{ add(m_col_id); add(m_col_name); }

  Gtk::TreeModelColumn&lt;int&gt; m_col_id;
  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
};

ModelColumns m_columns;Modifying build filesModifying the List of Recent FilesMonitoring I/OMore information about what lies behind the internationalization and localization process is presented and demonstrated in: <placeholder-1/>More than one Model Column per View ColumnMost applications will have only one <classname>Window</classname>, or only one main window. These applications can use the <methodname>Gtk::Main::run(Gtk::Window&amp;)</methodname> overload. It shows the window and returns when the window has been hidden. This might happen when the user closes the window, or when your code decides to <methodname>hide()</methodname> the window. You can prevent the user from closing the window (for instance, if there are unsaved changes) by overriding <methodname>Gtk::Window::on_delete_event()</methodname>.Most custom widgets need their own <classname>Gdk::Window</classname> to draw on. Then you can call <methodname>Gtk::Widget::set_has_window(true)</methodname> in your constructor. (This is the default value.) If you do not call <methodname>set_has_window(false)</methodname>, you must override <methodname>on_realize()</methodname> and call <methodname>Gtk::Widget::set_realized()</methodname> and <methodname>Gtk::Widget::set_window()</methodname> from there.Most of our examples use this technique.Most of the chapters in this book deal with specific widgets. See the <link linkend="chapter-container-widgets">Container Widgets</link> section for more details about adding widgets to container widgets.Most of the useful member methods for this class are actually in the <classname>Gtk::FileChooser</classname> base class.Most packing uses boxes as in the above example. These are invisible containers into which we can pack our widgets. When packing widgets into a horizontal box, the objects are inserted horizontally from left to right or right to left depending on whether <methodname>pack_start()</methodname> or <methodname>pack_end()</methodname> is used. In a vertical box, widgets are packed from top to bottom or vice versa. You may use any combination of boxes inside or beside other boxes to create the desired effect.MoveMultiple-item widgetsMultiple-item widgets inherit from <classname>Gtk::Container</classname>; just as with <classname>Gtk::Bin</classname>, you use the <methodname>add()</methodname> and <methodname>remove()</methodname> methods to add and remove contained widgets. Unlike <methodname>Gtk::Bin::remove()</methodname>, however, the <methodname>remove()</methodname> method for <classname>Gtk::Container</classname> takes an argument, specifiying which widget to remove.MurrayMurray CummingNext we call the Window's <methodname>set_border_width()</methodname> method. This sets the amount of space between the sides of the window and the widget it contains.Next we make an object of our <classname>HelloWorld</classname> class, whose constructor takes no arguments, but it isn't visible yet. When we call Gtk::Main::run(), giving it the helloworld Window, it shows the Window and starts the <application>gtkmm</application><emphasis>event loop</emphasis>. During the event loop <application>gtkmm</application> idles, waiting for actions from the user, and responding appropriately. When the user closes the Window, run() will return, causing the final line of our main() function be to executed. The application will then finish.Next we must adapt the various <filename>Makefile.am</filename> files: <placeholder-1/>Next you should create a <classname>UIManager</classname> and add the <classname>ActionGroup</classname> to the <classname>UIManager</classname> with <methodname>insert_action_group()</methodname> At this point is also a good idea to tell the parent window to respond to the specified keyboard shortcuts, by using <methodname>add_accel_group()</methodname>.Next, we use the Window's <methodname>add()</methodname> method to put <literal>m_button</literal> in the Window. (<methodname>add()</methodname> comes from <classname>Gtk::Container</classname>, which is described in the chapter on container widgets.) The <methodname>add()</methodname> method places the Widget in the Window, but it doesn't display the widget. <application>gtkmm</application> widgets are always invisible when you create them - to display them, you must call their <methodname>show()</methodname> method, which is what we do in the next line.Nicolai M. Josuttis, "The C++ Standard Library" - section 4.2Normal C++ memory managementNote also that not all widgets receive all X events by default. To receive additional X events, you can use <methodname>Gtk::Widget::set_events()</methodname> before showing the widget, or <methodname>Gtk::Widget::add_events()</methodname> after showing the widget. However, some widgets must first be placed inside an <classname>EventBox</classname> widget. See the <link linkend="chapter-widgets-without-xwindows">Widgets Without X-Windows</link> chapter.Note that UTF-8 isn't compatible with 8-bit encodings like ISO-8859-1. For instance, German umlauts are not in the ASCII range and need more than 1 byte in the UTF-8 encoding. If your code contains 8-bit string literals, you have to convert them to UTF-8 (e.g. the Bavarian greeting "Grüß Gott" would be "Gr\xC3\xBC\xC3\x9F Gott").Note that files ending in <filename>.in</filename> will be used to generate files with the same name but without the <filename>.in</filename> suffix, by replacing some variables with actual values during the configure stage.Note that if you mention extra modules in addition to gtkmm-2.4, they should be separated by spaces, not commas.Note that in this case, we've expressed nearly everything in terms of the height and width of the window, including the width of the lines. Because of this, when you resize the window, everything scales with the window. Also note that there are three drawing sections in the function and each is wrapped with a <methodname>save()</methodname>/<methodname>restore()</methodname> pair so that we're back at a known state after each drawing.Note that most language teams only consist of 1-3 persons, so if your program contains a lot of strings, it might last a while before anyone has the time to look at it. Also, most translators do not want to waste their time (translating is a very time-consuming task) so if they do not assess your project as being really serious (in the sense that it is polished and being maintained) they may decide to spend their time on some other project.Note that the coordinate system starts in the upper left hand corner.Note that the instance (such as m_Columns here) should usually not be static, because it often needs to be instantiated after glibmm has been instantiated.Note that this is where we specify the names of the actions as they will be seen by users in menus and toolbars. Therefore, this is where you should make strings translatable, by putting them inside the _() macro. When we use the Gtk::Stock items, of course, translations are automatically available.Note that to build <application>gtkmm</application> from git, you'll often need to build all of its dependencies from git as well. <application>jhbuild</application> makes this easier than it would normally be, but it will take quite a while to build and install them all. You will probably encounter build problems, though these will usually be corrected quickly if you report them.Note that we clip to the area that needs re-exposing just as we did in the last example. After clipping, however, we make a call to <methodname>Cairo::Context::scale()</methodname>, passing in the width and height of the drawing area. This scales the user-space coordinate system such that the the width and height of the widget are both equal to 1.0 'units'. There's no particular reason to scale the coordinate system in this case, but sometimes it can make drawing operations easier.Note that we don't pass a pointer to <methodname>on_button_clicked()</methodname> directly to the signal's <methodname>connect()</methodname> method. Instead, we call <function>sigc::ptr_fun()</function>, and pass the result to <methodname>connect()</methodname>.Note that you can't just do <placeholder-1/> because the group is modified by <methodname>set_group()</methodname> and therefore non-const.Note that you must specify actions for sub menus as well as menu items.Note that, due to GTK+'s theming system, the appearance of these widgets will vary. In the case of checkboxes and radio buttons, they may vary considerably.Note, however, that the TreeView will provide iterators to the sorted model. You must convert them to iterators to the underlying child model in order to perform actions on that model. For instance:NotebookNotice that the return value is of type <classname>sigc::signal&lt;void,int&gt;::iterator</classname>. This can be implicitely converted into a <classname>sigc::connection</classname> which in turn can be used to control the connection. By keeping a connection object you can disconnect its associated signal handler using the method <methodname>sigc::connection::disconnect()</methodname>.Notice that we provided <command>gmmproc</command> with the path to the .m4 convert files, the path to the .defs file, the name of a .hg file, the source directory, and the destination directory.Notice that we've used an initialiser statement to give the <literal>m_button</literal> object the label "Hello World".Now let's look at our program's <function>main()</function> function. Here it is, without comments:Now let's look at the connection again:Now let's take a look at the code that performs the actual drawing. The first section of <methodname>on_expose_event()</methodname> should be pretty familiar by now as it's mostly 'boilerplate' code for getting the <classname>Gdk::Window</classname>, creating a <classname>Cairo::Context</classname>, and clipping to the area that we want to re-draw. This example again scales the coordinate system to be a unit square so that it's easier to draw the clock as a percentage of window size so that it will automatically scale when the window size is adjusted. Furthermore, the coordinate system is scaled over and down so that the (0, 0) coordinate is in the very center of the window.Now that there is a place to put your translations, you need to initialize <application>intltool</application> and <application>gettext</application>. Add the following code to your <literal>configure.ac</literal>, substituting 'programname' with the name of your program:Now that we understand the basics of the Cairo graphics library, we're almost ready to start drawing. We'll start with the simplest of drawing elements: the straight line. But first you need to know a little bit about Cairo's coordinate system. The origin of the Cairo coordinate system is located in the upper-left corner of the window with positive x values to the right and positive y values going down. <placeholder-1/>Now that we've covered the basics of drawing with Cairo, let's try to put it all together and create a simple application that actually does something. The following example uses Cairo to create a custom <classname>Clock</classname> widget. The clock has a second hand, a minute hand, and an hour hand, and updates itself every second.Now that you've seen signals and signal handlers in <application>gtkmm</application>, you might like to use the same technique to allow interaction between your own classes. That's actually very simple by using the <application>libsigc++</application> library directly.Now we edit the files to adapt them to to our needs. You might prefer to use a multiple-file search-replace utility for this, such as <command>regexxer</command>. Note that nearly all of the files provided with the skeleton source tree contain placeholder text. Thus, the substitutions should be performed globally, and not be limited to the Automake and Autoconf files.OK, you say, that's nice, but what if I want to create my own handlers to respond when the user adjusts a <classname>Range</classname> widget or a <classname>SpinButton</classname>. To access the value of a <classname>Gtk::Adjustment</classname>, you can use the <methodname>get_value()</methodname> and <methodname>set_value()</methodname> methods:Objects and functions.Objects such as <classname>Gdk::Bitmap</classname> can only be instantiated with a <methodname>create()</methodname> function. For instance, <placeholder-1/>Objects used via <classname>RefPtr</classname>: Pass the <classname>RefPtr</classname> as a const reference. For instance, <code>const Glib::RefPtr&lt;Gtk::Action&gt;&amp; action</code>.Occasionally you might want to make an <classname>Entry</classname> widget read-only. This can be done by passing <literal>false</literal> to the <methodname>set_editable()</methodname> method.Of course this means that you can store <classname>RefPtrs</classname> in standard containers, such as <classname>std::vector</classname> or <classname>std::list</classname>.Of course, a top level container will not be added to another container. The programmer is responsible for destroying the top level container using one of the traditional C++ techniques. For instance, your top-level Window might just be an instance in your <function>main()</function> function..OleOn Unix, the default preview handler uses an external viewer program. On Windows, the native preview dialog will be shown. If necessary you may override this behaviour and provide a custom preview dialog. See the example located in /examples/book/printing/advanced.Once you've built your software, you'll need to run your program within the jhbuild environment as well. To do this, you can again use the <command>jhbuild shell</command> command to start a new shell with the <application>jhbuild</application> environment set up. Alternatively, you can execute a one-off command in the <application>jhbuild</application> environment using the following command: <command>jhbuild run command-name</command>. In this case, the command will be run with the correct environment variables set, but will return to your previous environment after the program exits.Once you've configured <application>jhbuild</application> as described above, building <application>gtkmm</application> should be relatively straightforward. The first time you run <application>jhbuild</application>, you should run the following sequence of commands to ensure that <application>jhbuild</application> has the required tools and verify that it is set up correctly: <screen>$ jhbuild bootstrap
$ jhbuild sanitycheck</screen>One of the benefits of UTF-8 is that you don't need to use it unless you want to, so you don't need to retrofit all of your code at once. <classname>std::string</classname> will still work for 7-bit ASCII strings. But when you try to localize your application for languages like Chinese, for instance, you will start to see strange errors, and possible crashes. Then all you need to do is start using <classname>Glib::ustring</classname> instead.One of the major advantages of <application>gtkmm</application> is that it is crossplatform. <application>gtkmm</application> programs written on other platforms such as GNU/Linux can generally be transferred to Windows (and vice versa) with few modifications to the source.Openismus has more <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">basic help with automake and autoconf</ulink>.Or you could specify the tag when first inserting the text: refBuffer-&gt;insert_with_tag(iter, "Some text", refTagMatch);Other macrosOther macros, such as <function>_WRAP_METHOD()</function> and <function>_SIGNAL()</function> may only be used after a call to a <function>_CLASS_*</function> macro.Other methodsOther than the signal's name (<literal>focus</literal>), two things are important to note here: the number following the word <classname>SignalProxy</classname> at the beginning (1, in this case), and the types in the list (<type>bool</type> and <type>Gtk::DirectionType</type>). The number indicates how many arguments the signal handler should have; the first type, <type>bool</type>, is the type that the signal handler should return; and the next type, <type>Gtk::DirectionType</type>, is the type of this signal's first, and only, argument. By looking at the reference documentation, you can see the names of the arguments too.Our examples all tend to have the same structure. They follow these steps for using a <classname>Widget</classname>:Overriding default signal handlersOverviewPKG_CHECK_MODULES([MYAPP], [gtkmm-2.4 &gt;= 2.8.0])Pack the widget into a container using the appropriate call, e.g. <methodname>Gtk::Container::add()</methodname> or <methodname>pack_start()</methodname>.PackingPage setupPanedPanes divide a widget into two halves, separated by a moveable divider. There are two such widgets: <classname>Gtk::HPaned</classname> adds a horizontal divider, and <classname>Gtk::VPaned</classname> adds a vertical one. Other than the names and the orientations, there's no difference between the two.PangoParts of chapter on "Internationalization".PastePer-child packing optionsPer-container packing optionsPermission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You may obtain a copy of the GNU Free Documentation License from the Free Software Foundation by visiting their Web site or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.PitfallsPlease see <ulink url="http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm">http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm</ulink> for instructions on how to build gtkmm on Windws.PlugsPlugs and SocketsPlugs and Sockets ExamplePopup Context MenuPopup MenuPopup Menu examplePopup MenusPrebuilt PackagesPreparing your projectPretty thrilling, eh? Let's examine the code. First, the <classname>HelloWorld</classname> class:Preventing row selectionPreviewPrintOperationPrintingPrinting - SimplePrinting support is available in <application>gtkmm</application> version 2.10 and later.Probably the most common way of creating <classname>Gdk::Pixbuf</classname>s is to use <methodname>Gdk::Pixbuf::create_from_file()</methodname>, which can read an image file, such as a png file into a pixbuf ready for rendering.Problems in the C API.Programming with <application>gtkmm</application>Progress bars are used to show the status of an ongoing operation. For instance, a <classname>ProgressBar</classname> can show how much of a task has been completed.ProgressBarPush-ButtonsPuts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.Radio buttonsRadioButtonRange WidgetsRe. Overriding signal handlers: You can do this in the straight-C world of GTK+ too; that's what GTK's object system is for. But in GTK+, you have to go through some complicated procedures to get object-oriented features like inheritance and overloading. In C++, it's simple, since those features are supported in the language itself; you can let the compiler do the dirty work.Recent Files support is available in <application>gtkmm</application> version 2.10 and laterRecent versions of <application>gtkmm</application> are packaged by nearly every major Linux distribution these days. So, if you use Linux, you can probably get started with <application>gtkmm</application> by installing the package from the official repository for your distribution. Distributions that include <application>gtkmm</application> in their repositories include Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, and many others.RecentChooserRecentManagerRecently Used DocumentsRecommended TechniquesReferenceRemember that on a Unix or Linux operating system, you will probably need to be <literal>root</literal> to install software. The <command>su</command> command will allow you to enter the <literal>root</literal> password and have <literal>root</literal> status temporarily.Remember that these names are just the identifiers that we used when creating the actions. They are not the text that the user will see in the menus and toolbars. We provided those human-readable names when we created the actions.Remember that you are not instantiating a widget with <methodname>get_widget()</methodname>, you are just obtaining a pointer to one that already exists. You will always receive a pointer to the same instance when you call <methodname>get_widget()</methodname> on the same <classname>Gtk::Builder</classname>, with the same widget name. The widgets are instantiated during <methodname>Gtk::Builder::create_from_file()</methodname>.Rendering textReorderable rowsResourcesResponding to changesReusing C documentationRiederRow childrenRuebsamenSame strings, different semanticsScale WidgetsScrollbar WidgetsScrolled windows have <emphasis>scrollbar policies</emphasis> which determine whether the <classname>Scrollbar</classname>s will be displayed. The policies can be set with the <methodname>set_policy()</methodname> method. The policy may be one of <literal>Gtk::POLICY_AUTOMATIC</literal> or <literal>Gtk::POLICY_ALWAYS</literal>. <literal>Gtk::POLICY_AUTOMATIC</literal> will cause the scrolled window to display the scrollbar only if the contained widget is larger than the visible area. <literal>Gtk::POLICY_ALWAYS</literal> will cause the scrollbar to be displayed always.ScrolledWindowScrollingSecond, check for an error and connect to the <literal>status_changed</literal> signal. For instance: <placeholder-1/>Section "Build Structure" of chapter on "Wrapping C Libraries with gmmproc".See <link linkend="sec-printing-example-simple">an example</link> of exactly how this can be done.See the <link linkend="chapter-draganddrop">Drag and Drop</link> chapter for general advice about Drag and Drop with gtkmm.See the <link linkend="chapter-internationalization">Internationalization</link> section for information about providing the UTF-8 string literals.See the <link linkend="chapter-refptr">appendix</link> for detailed information about RefPtr.See the <link linkend="sec-progressbar">ProgressBar</link> section for another example that uses an <classname>Alignment</classname>.Set the attributes of the widget. If the widget has no default constructor, then you will need to initialize the widget in the initalizer list of your container class's constructor.Set the title of the tab via <methodname>PrintOperation::set_custom_tab_label()</methodname>, create a new widget and return it from the <literal>create_custom_widget</literal> signal handler. You'll probably want this to be a container widget, packed with some others.Setting a prefixSetting up jhbuildSetting valuesShared resourcesShown below is a simple example of how to use the <classname>RecentChooserDialog</classname> class in a program. This simple program has a menubar with a "Recent Files Dialog" menu item. When you select this menu item, a dialog pops up showing the list of recently used files.Signal Handler sequenceSignalsSignals and properties.Signals usually have function pointers in the GTK struct, with a corresponding enum value. and a <function>g_signal_new()</function> in the .c file.SimpleSimple Entry ExampleSimple ExampleSimple RecentChooserWidget exampleSimple Text ExampleSimple UseSimple text copy-paste functionality is provided for free by widgets such as Gtk::Entry and Gtk::TextView, but you might need special code to deal with your own data formats. For instance, a drawing program would need special code to allow copy and paste within a view, or between documents.Since a <classname>Plug</classname> is just a special type of <classname>Gtk::Window</classname> class, you can add containers or widgets to it like you would to any other window.Since the Cairo graphics library was written with support for multiple output targets (the X window system, PNG images, OpenGL, etc), there is a distinction between user-space and device-space coordinates. The mapping between these two coordinate systems defaults to one-to-one so that integer values map roughly to pixels on the screen, but this setting can be adjusted if desired. Sometimes it may be useful to scale the coordinates so that the full width and height of a window both range from 0 to 1 (the 'unit square') or some other mapping that works for your application. this can be done with the <methodname>Cairo::Context::scale()</methodname> function.Since this is very similar to the methods above this explanation should be sufficient to understand what's going on. However, here's a little example:Single or multiple selectionSingle-item ContainersSo far we've told you to perform actions in response to button-presses and the like by handling signals. That's certainly a good way to do things, but it's not the only way.So that a user can click on a <classname>TreeView</classname>'s column header to sort the <classname>TreeView</classname>'s contents, call <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>, supplying the model column on which model should be sorted when the header is clicked. For instance:So that applications can react to changes, for instance when a user moves a scrollbar, <classname>Gtk::Adjustment</classname> has a <literal>changed</literal> signal. You can then use the <methodname>get_changed()</methodname> method to discover the new value.So that the Entry can interact with the drop-down list of choices, you must specify which of your model columns are the text column, with <methodname>set_entry_text_column()</methodname>. For instance: <placeholder-1/>So you should either avoid this situation or revert to the C-style <function>sprintf()</function>. One possible solution is the <ulink url="http://www.cs.auc.dk/~olau/compose/">compose library</ulink> which supports syntax such as:So your application doesn't need to wait for clipboard operations, particularly between the time when the user chooses Copy and then later chooses Paste, most <classname>Gtk::Clipboard</classname> methods take <classname>sigc::slot</classname>s which specify callback methods. When <classname>Gtk::Clipboard</classname> is ready, it will call these methods, either providing the requested data, or asking for data.So, for example, if you have a <classname>Scale</classname> widget, and you want to change the rotation of a picture whenever its value changes, you would create a signal handler like this:SocketsSome <application>gtkmm</application> widgets don't have associated X windows; they draw on their parents' windows. Because of this, they cannot receive events. Also, if they are incorrectly sized, they don't clip, so you can get messy overwriting etc. To receive events on one of these widgets, you can it inside an <classname>EventBox</classname> widget and then call <methodname>Gtk::Widget::set_events()</methodname> on the EventBox before showing it.Some Widgets do not have an associated X-Window, so they therefore do not receive X events. This means that the signals described in the <link linkend="sec-xeventsignals">X event signals</link> section will not be emitted. If you want to capture events for these widgets you can use a special container called <classname>Gtk::EventBox</classname>, which is described in the <link linkend="sec-eventbox">EventBox</link> section.Some extra macros make this easier and consistent. Look in gtkmm's .m4 files for examples. For instance: <placeholder-1/>Some objects, such as <classname>Gdk::Pixmap</classname>s and <classname>Pango::Font</classname>s, are obtained from a shared store. Therefore you cannot instantiate your own instances. These classes typically inherit from <classname>Glib::Object</classname>. Rather than requiring you to reference and unreference these objects, <application>gtkmm</application> uses the <classname>RefPtr&lt;&gt;</classname> smartpointer.Some of the basic types that are used in C APIs have better alternatives in C++. For example, there's no need for a <type>gboolean</type> type since C++ has <type>bool</type>. The following list shows some commonly-used types in C APIs and what you might convert them to in a C++ wrapper library.Some parts of the <application>gtkmm</application> API use intermediate data containers, such as <classname>Glib::StringArrayHandle</classname> instead of a specific Standard C++ container such as <classname>std::vector</classname> or <classname>std::list</classname>. You should not declare these types yourself -- you should use whatever Standard C++ container you prefer instead. <application>gtkmm</application> will do the conversion for you. Here are some of these intermediate types: <placeholder-1/>Sometimes two english strings are identical but have different meanings in different contexts, so they would probably not be identical when translated. Since the English strings are used as look-up keys, this causes problems.SortingSorting by clicking on columnsSource CodeSources and DestinationsSpecifies the destination directry for generated sources, and the name of the main .defs file that <command>gmmproc</command> should parse.Specifying CellRenderer detailsSpinButtonStart the <filename>plug</filename> program and send it to the background (or just use a different terminal).String literals should be typed in the source code in English, but surrounded by a macro. The <application>gettext</application> (or intltool) utility can then extract the marked strings for tramslation, and substitute the translated text at runtime.String literals should be typed in the source code in English, but they should be surrounded by a call to the <function>gettext()</function> function. These strings will be extracted for translation and the translations may be used at runtime instead of the original English strings.Subclass Widgets to better organize your code. You should probably subclass your main <classname>Window</classname> at least. Then you can make your child Widgets and signal handlers members of that class.Subclassing isn't always the best way to accomplish things. It is only useful when you want the widget to handle its own signal by itself. If you want some other class to handle the signal then you'll need to connect a separate handler. This is even more true if you want several objects to handle the same signal, or if you want one signal handler to respond to the same signal from different objects.TableTables allows us to place widgets in a grid, similar to <classname>Gtk::Grid</classname>.TagTableTagsTags and FormattingTargetsTells <command>gmmproc</command> to add some typedefs, constructors, and standard methods to this class, as appropriate when wrapping a GtkObject-derived type.Tells <command>gmmproc</command> to include a header from the generated private/button_p.h file.Testing and adding translationsText is drawn via Pango Layouts. The easiest way to create a <classname>Pango::Layout</classname> is to use <methodname>create_pango_layout</methodname>. Once created, the layout can be manipulated in various ways, including changing the text, font, etc. Finally, the layout can be rendered using the <methodname>draw_layout</methodname> method of <classname>Gdk::Drawable</classname>, which takes a <classname>Gdk::GC</classname> object, an x-position, a y-position and the layout itself.Text rendering is done using Pango. The <classname>Pango::Layout</classname> object for printing should be created by calling the <methodname>PrintContext::create_pango_layout()</methodname> method. The <classname>PrintContext</classname> object also provides the page metrics, via <methodname>get_width()</methodname> and <methodname>get_height()</methodname>. The number of pages can be set with <methodname>PrintOperation::set_n_pages()</methodname>. To actually render the Pango text in <literal>on_draw_page</literal>, get a <classname>Cairo::Context</classname> with <methodname>PrintContext::get_cairo_context()</methodname> and show the <classname>Pango::LayoutLine</classname>s that appear within the requested page number.TextViewThat will create a file named <filename>programname.pot</filename>. Now copy that file to <filename>languagecode.po</filename>, such as <filename>de.po</filename> or <filename>hu.po</filename>. Also add that language code to <literal>LINGUAS</literal>. The <filename>.po</filename> file contains a header and a list of English strings, with space for the translated strings to be entered. Make sure you set the encoding of the <filename>.po</filename> file (specified in the header, but also as content) to <literal>UTF-8</literal>.The "changed" signalThe 'Print to file' option is available in the print dialog, without the need for extra implementation. However, it is sometimes useful to generate a pdf file directly from code. For instance, <placeholder-1/>The .h and .cc files will be generated from the .hg and .ccg files by processing them with <command>gmmproc</command> like so, though this happens automatically when using the above build structure: <placeholder-1/>The .hg and .ccg filesThe .hg and .ccg source files are very much like .h and .cc C++ source files, but they contain extra macros, such as <function>_CLASS_GOBJECT()</function> and <function>_WRAP_METHOD()</function>, from which <command>gmmproc</command> generates appropriate C++ source code, usually at the same position in the header. Any additional C++ source code will be copied verbatim into the corresponding .h or .cc file.The <application>GNU gettext</application> package allows you to mark strings in source code, extract those strings for translation, and use the translated strings in your application.The <application>gtkmm</application> module is defined in the GNOME moduleset (i.e. <filename>gnome-2.xx.modules</filename>, so edit your <filename>.jhbuildrc</filename> file and set your moduleset setting to the latest version of GNOME like so: <placeholder-1/>The <classname>Alignment</classname> widget allows you to place a widget at a position and size relative to the size of the <classname>Alignment</classname> widget itself. For instance, it might be used to center a widget.The <classname>AspectFrame</classname> widget looks like a <classname>Frame</classname> widget, but it also enforces the <emphasis>aspect ratio</emphasis> (the ratio of the width to the height) of the child widget, adding extra space if necessary. For instance, this would allow you to display a photograph without allowing the user to distort it horizontally or vertically while resizing.The <classname>ColorSelectionDialog</classname> allows the user to choose a color.The <classname>ComboBox</classname> widgets offers a list (or tree) of choices in a dropdown menu. If appropriate, it can show extra information about each item, such as text, a picture, a checkbox, or a progress bar. The <classname>ComboBox</classname> widget usually restricts the user to the available choices, but it can optionally have an <classname>Entry</classname>, allowing the user to enter arbitrary text if the none of the available choices are suitable.The <classname>DrawingArea</classname> widget is a blank window that gives you the freedom to create any graphic you desire. Along with that freedom comes the responsibility to handle expose events on the widget. When a widget is first shown, or when it is covered and then uncovered again it needs to redraw itself. Most widgets have code to do this, but the DrawingArea does not, allowing you to write your own expose event signal handler to determine how the contents of the widget will be drawn. This is most often done by overriding the virtual <methodname>on_expose_event()</methodname> member function.The <classname>EntryCompletion</classname> may use a <classname>TreeModel</classname> containing possible entries, specified with <methodname>set_model()</methodname>. You should then call <methodname>set_text_column()</methodname> to specify which of your model columns should be used to match possible text entries.The <classname>FileChooserDialog</classname> is suitable for use with "Open" or "Save" menu items.The <classname>FontSelectionDialog</classname> allows the user to choose a font.The <classname>Gdk::Pixbuf</classname> can be rendered with <methodname>render_to_drawable</methodname>, which takes quite a few parameters. The <methodname>render_to_drawable</methodname> is a member of <classname>Gdk::Pixbuf</classname> rather than <classname>Gdk::Drawable</classname>, which is unlike the <methodname>draw_*</methodname> functions described earlier. As such, its first parameter is the drawable to render to. The second parameter is still the <classname>Gdk::GC</classname>. The next two parameters are the point in the pixbuf to start drawing from. This is followed by the point in the drawable to draw it at, and by the width and height to actually draw (which may not be the whole image, especially if you're only responding to an expose event for part of the window). Finally, there are the dithering parameters. If you use Gdk::RGB_DITHER_NONE as the dither type, then the dither offset parameters can both be 0.The <classname>Gtk::Adjustment</classname> constructor is as follows:The <classname>Gtk::Button</classname> widget has the following signals, but most of the time you will just handle the <literal>clicked</literal> signal:The <classname>Gtk::TreeView</classname> widget can contain lists or trees of data, in columns.The <classname>ListStore</classname> contains simple rows of data, and each row has no children.The <classname>PrintOperation</classname> class has a method called <methodname>set_default_page_setup()</methodname> which selects the default paper size, orientation and margins. To show a page setup dialog from your application, use the <methodname>Gtk::run_page_setup_dialog()</methodname> method, which returns a <classname>Gtk::PageSetup</classname> object with the chosen settings. Use this object to update a <classname>PrintOperation</classname> and to access the selected <classname>Gtk::PaperSize</classname>, <literal>Gtk::PageOrientation</literal> and printer-specific margins.The <classname>SpinButton</classname> can create a default <classname>Adjustment</classname>, which you can access via the <methodname>get_adjustment()</methodname> method, or you can specify an existing <classname>Adjustment</classname> in the constructor.The <classname>Tag</classname> class has many other properties.The <classname>TextView</classname> creates its own default <classname>TextBuffer</classname>, which you can access via the <methodname>get_buffer()</methodname> method.The <classname>TextView</classname> widget can be used to display and edit large amounts of formatted text. Like the <classname>TreeView</classname>, it has a model/view design. In this case the <classname>TextBuffer</classname> is the model.The <classname>ToolPalette</classname>'s items might be dragged or simply activated. For instance, the user might drag objects to a canvas to create new items there. Or the user might click an item to activate a certain brush size in a drawing application.The <classname>TreeModelColumnRecord</classname> class is used to keep track of the columns and their data types. You add <classname>TreeModelColumn</classname> instances to the <classname>ColumnRecord</classname> and then use those <classname>TreeModelColumns</classname> when getting and setting the data in model rows. You will probably find it convenient to derive a new <classname>TreeModelColumnRecord</classname> which has your <classname>TreeModelColumn</classname> instances as member data.The <classname>TreeStore</classname> contains rows of data, and each row may have child rows.The <classname>TreeView</classname> already allows you to show the same <classname>TreeModel</classname> in two <classname>TreeView</classname> widgets. If you need one of these TreeViews to sort the model differently than the other then you should use a <classname>TreeModelSort</classname> instead of just, for instance, <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>. <classname>TreeModelSort</classname> is a model that contains another model, presenting a sorted version of that model. For instance, you might add a sorted version of a model to a <classname>TreeView</classname> like so:The <classname>Widget</classname> class has some special signals which correspond to the underlying X-Windows events. These are suffixed by <literal>_event</literal>; for instance, <methodname>Widget::signal_button_pressed_event()</methodname>.The <emphasis>update policy</emphasis> of a <classname>Range</classname> widget defines at what points during user interaction it will change the <literal>value</literal> field of its <classname>Gtk::Adjustment</classname> and emit the <literal>value_changed</literal> signal. The update policies, set with the <methodname>set_update_policy()</methodname> method, are: <placeholder-1/>The <filename>.defs</filename> file are text files, in a lisp format, that describe the API of a C library, including its <placeholder-1/>The <filename>configure</filename> script will check to make sure all of the required dependencies are already installed. If you are missing any dependencies, it will exit and display an error.The <function>AC_CONFIG_FILES()</function> block must mention the correct directory names, as described above.The <function>AC_CONFIG_HEADERS()</function> line is used to generate two or more configuration header files. The first header file in the list contains all configuration macros which are set during the configure run. The remaining headers in the list contain only a subset of configuration macros and their corresponding <filename>configh.h.in</filename> file will not be autogenerated. The reason for this separation is that the namespaced configuration headers are installed with your library and define publically visible macros.The <function>AC_CONFIG_SRCDIR()</function> line must mention a file in our source tree. We can edit this later if we don't yet know the names of any of the files that we will create.The <function>AC_SUBST([SOMETHINGMM_MODULES], ['...'])</function> line may need to be modified to check for the correct dependencies.The <function>_CTOR_DEFAULT()</function> and <function>_WRAP_CTOR()</function> macros add constructors, wrapping the specified <function>*_new()</function> C functions. These macros assume that the C object has properties with the same names as the function parameters, as is usually the case, so that it can supply the parameters directly to a <function>g_object_new()</function> call. These constructors never actually call the <function>*_new()</function> C functions, because gtkmm must actually instantiate derived GTypes, and the <function>*_new()</function> C functions are meant only as convenience functions for C programmers.The <link linkend="chapter-draganddrop">Drag and Drop</link> API uses the same mechanism. You should probably use the same data targets and formats for both Clipboard and Drag and Drap operations.The <literal>const ... &amp;</literal> around both is just for efficiency, like using <classname>const std::string&amp;</classname> instead of <classname>std::string</classname> for a method parameter to avoid unnecessary copying.The <literal>ideal</literal> example below can supply more than one clipboard target.The <methodname>PrintOperation::run()</methodname> method starts the print loop, during which various signals are emitted: <placeholder-1/>The <methodname>get_request_mode_vfunc()</methodname>, <methodname>get_preferred_width_vfunc()</methodname>, <methodname>get_preferred_height_vfunc()</methodname>, <methodname>get_preferred_width_for_height_vfunc()</methodname>, <methodname>get_preferred_height_for_width_vfunc()</methodname>, and <methodname>on_size_allocate()</methodname> virtual methods control the layout of the child widgets. For instance, if your container has 2 child widgets, with one below the other, your <methodname>get_request_mode_vfunc()</methodname> might request height-for-width layout. Then your <methodname>get_preferred_width_vfunc()</methodname> might report the maximum of the widths of the child widgets, and <methodname>get_preferred_height_for_width_vfunc()</methodname> might report the sum of their heights. If you want padding between the child widgets then you would add that to the width and height too. Your widget's container will use this result to ensure that your widget gets enough space, and not less. By examining each widget's parent, and its parent, this logic will eventually decide the size of the top-level window.The <methodname>pack_start()</methodname> and <methodname>pack_end()</methodname> methods place widgets inside these containers. The <methodname>pack_start()</methodname> method will start at the top and work its way down in a <classname>VBox</classname>, or pack left to right in an <classname>HBox</classname>. <methodname>pack_end()</methodname> will do the opposite, packing from bottom to top in a <classname>VBox</classname>, or right to left in an <classname>HBox</classname>. Using these methods allows us to right justify or left justify our widgets. We will use <methodname>pack_start()</methodname> in most of our examples.The <methodname>run()</methodname> method returns an <literal>int</literal>. This may be a value from the <literal>Gtk::ResponseType</literal> if the user closed the button by clicking a standard button, or it could be the custom response value that you specified when using <methodname>add_button()</methodname>.The <methodname>spin()</methodname> method 'spins' the <classname>SpinButton</classname>, as if one of its arrows had been clicked. You need to specify a <classname>Gtk::SpinType</classname> to specify the direction or new position.The <parameter>left_attach</parameter> and <parameter>right_attach</parameter> arguments specify where to place the widget, and how many boxes to use. For example, if you want a button in the lower-right cell of a 2 x 2 table, and want it to occupy that cell <emphasis>only</emphasis>, then <parameter>left_attach</parameter> would be 1, <parameter>right_attach</parameter> 2, <parameter>top_attach</parameter> 1, and <parameter>bottom_attach</parameter> 2. If, on the other hand, you wanted a widget to take up the entire top row of our 2 x 2 table, you'd set <parameter>left_attach</parameter> = 0, <parameter>right_attach</parameter> = 2, <parameter>top_attach</parameter> = 0, and <parameter>bottom_attach</parameter> = 1.The <parameter>options</parameter> argument can take one of these three options: <placeholder-1/>The <parameter>padding</parameter> argument specifies the width of an extra border area to leave around the packed widget.The <parameter>value</parameter> argument is the initial value of the adjustment, usually corresponding to the topmost or leftmost position of an adjustable widget. The <parameter>lower</parameter> and <parameter>upper</parameter> arguments specifies the possible range of values which the adjustment can hold. The <parameter>step_increment</parameter> argument specifies the smaller of the two increments by which the user can change the value, while the <parameter>page_increment</parameter> is the larger one. The <parameter>page_size</parameter> argument usually corresponds somehow to the visible area of a panning widget. The <parameter>upper</parameter> argument is used to represent the bottom most or right most coordinate in a panning widget's child.The BufferThe C function (e.g. <function>gtk_entry_set_text</function>) is described more fully in the .defs file, and the <filename>convert*.m4</filename> files contain the necessary conversion from the C++ parameter type to the C parameter type. This macro also generates doxygen documentation comments based on the <filename>*_docs.xml</filename> and <filename>*_docs_override.xml</filename> files.The Cairo Drawing ModelThe Cairo coordinate system, in the <literal>draw_page</literal> handler, is automatically rotated to the current page orientation. It is normally within the printer margins, but you can change that via the <methodname>PrintOperation::set_use_full_page()</methodname> method. The default measurement unit is device pixels. To select other units, use the <methodname>PrintOperation::set_unit()</methodname> method.The ClipboardThe Drawing Area WidgetThe ModelThe RefPtr smartpointerThe SelectionThe TreeView widgetThe UI layout for a popup menu should use the <literal>popup</literal> node. For instance:The ViewThe View is the actual widget (<classname>Gtk::TreeView</classname>) that displays the model (<classname>Gtk::TreeModel</classname>) data and allows the user to interact with it. The View can show all of the model's columns, or just some, and it can show them in various ways.The adjustable widgets can be roughly divided into those which use and require specific units for these values, and those which treat them as arbitrary numbers.The arguments to <methodname>Action::create()</methodname> specify the action's name and how it will appear in menus and toolbars. Use stock items where possible so that you don't need to specify the label, accelerator, icon, and tooltips, and so you can use pre-existing translations.The basic concept of drawing in Cairo involves defining 'invisible' paths and then stroking or filling them to make them visible.The build structureThe call to <methodname>Cairo::Context::curve_to()</methodname> should be fairly self-explanatory. The first pair of coordinates define the control point for the beginning of the curve. The second set of coordinates define the control point for the end of the curve, and the last set of coordinates define the destination point. To make the concept of control points a bit easier to visualize, a line has been draw from each control point to the end-point on the curve that it is associated with. Note that these control point lines are both translucent. This is achieved with a variant of <methodname>set_source_rgb()</methodname> called <methodname>set_source_rgba()</methodname>. This function takes a fourth argument specifying the alpha value of the color (valid values are between 0 and 1).The chosen itemThe class macro declares the class itself and its relationship with the underlying C type. It generates some internal constructors, the member <varname>gobject_</varname>, typedefs, the <function>gobj()</function> accessors, type registration, and the <function>Glib::wrap()</function> method, among other things.The clear callback allows you to free the memory used by your stored data when the clipboard replaces its data with something else.The command line options passed to the C preprocessor.The command line options passed to the C++ compiler.The communication between a <classname>Socket</classname> and a <classname>Plug</classname> follows the XEmbed protocol. This protocol has also been implemented in other toolkits (e.g. Qt), which allows the same level of integration when embedding a Qt widget in GTK+ or vice versa.The compiler will complain if you use an inappropriate type. For instance, this would generate a compiler error:The constructor for <classname>ExampleWindow</classname> creates the menu using <classname>UIManager</classname> (see <xref linkend="chapter-menus-and-toolbars"/> for more information). It then adds the menu and the toolbar to the window.The constructor for <classname>Gtk::EventBox</classname> is:The current state of a <classname>Cairo::Context</classname> can be saved to an internal stack of saved states and later be restored to the state it was in when you saved it. To do this, use the <methodname>save()</methodname> method and the <methodname>restore()</methodname> method. This can be useful if you need to temporarily change the line width and color (or any other graphics setting) in order to draw something and then return to the previous settings. In this situation, you could call <methodname>Cairo::Context::save()</methodname>, change the graphics settings, draw the lines, and then call <methodname>Cairo::Context::restore()</methodname> to restore the original graphics state. Multiple calls to <methodname>save()</methodname> and <methodname>restore()</methodname> can be nested; each call to <methodname>restore()</methodname> restores the state from the matching paired <methodname>save()</methodname>. <placeholder-1/>The default <classname>CellRenderers</classname> and their default behaviour will normally suffice, but you might occasionally need finer control. For instance, this example code from <filename>demos/gtk-demo/example_treestore.cc</filename>, manually constructs a <classname>Gtk::CellRenderer</classname> widget and instructs it to render the data from various model columns through various aspects of its appearance.The destination widget will emit this signal, after the source destination has emitted the <literal>drag_get</literal> signal: <placeholder-1/>The drag and drop signals provide a DragContext, which contains some information about the drag and drop operation and can be used to influence the process. For instance, you can discover the source widget, or change the drag and drop icon, by using the <methodname>set_icon()</methodname> methods. More importantly, you should call the <methodname>drag_finish()</methodname> method from your <literal>drag_data_received</literal> signal handler to indicate whether the drop was successful.The easiest way to do this is using <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">jhbuild</ulink>. <application>jhbuild</application> is a program that makes building GNOME software much easier by calculating dependencies and building things in the correct order. This section will give a brief explanation of how to set up jhbuild to build and install <application>gtkmm</application> from the source repository (git). For up-to-date information on <application>jhbuild</application>, please refer to the <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">jhbuild manual</ulink>. If you need assistance using <application>jhbuild</application>, you should ask for help on the <ulink url="http://mail.gnome.org/mailman/listinfo/gnome-love">gnome-love mailing list</ulink>.The entryThe example in examples/book/printing/advanced demonstrates this.The extra typedef allows the struct to be used in a header without including its full defintion, simply by predeclaring it, by repeating that typedef. This means that you don't have to include the C library's header in your C++ header, thus keeping it out of your public API. <command>gmmproc</command> assumes that this technique was used, so you will see compiler errors if that is not the case.The first 6 methods in the previous table are also overridden in custom containers. They are briefly described in the <link linkend="sec-custom-containers">Custom Containers</link> section.The first argument is a <classname>slot</classname> you wish to have called when the timeout occurs. The second argument is the number of milliseconds between calls to that method. You receive a <classname>sigc::connection</classname> object that can be used to deactivate the connection using its <methodname>disconnect()</methodname> method:The first argument is a slot you wish to have called when then the specified event (see argument 3) occurs on the file descriptor you specify using argument two. Argument three may be one or more (using <literal>|</literal>) of:The first argument is the number of rows to make in the table, while the second, obviously, is the number of columns. If <parameter>homogeneous</parameter> is <literal>true</literal>, the table cells will all be the same size (the size of the largest widget in the table).The first argument is the widget you wish to place in the table.The first argument is the widget you're packing. In our example these are all <classname>Button</classname>s.The first call to <methodname>connect()</methodname> is just like the one we saw last time; nothing new here.The first line of output is from <filename>plug</filename>, after it has been notified that it has been embedded inside of a <classname>Socket</classname>. The second line was emitted by <filename>socket</filename> in response to its <methodname>plug_added</methodname> signal. If everything was done as described above, the <filename>socket</filename> window should look roughly like the following:The following example demonstrates both uses of an <classname>EventBox</classname> - a label is created that is clipped to a small box, and set up so that a mouse-click on the label causes the program to exit. Resizing the window reveals varying amounts of the label.The following example demonstrates how to print some input from a user interface. It shows how to implement <literal>on_begin_print</literal> and <literal>on_draw_page</literal>, as well as how to track print status and update the print settings.The following example demonstrates the use of <classname>RadioButton</classname>s:The following example shows how to set up a Cairo context with a foreground color of red and a width of 2. Any drawing functions that use this context will use these settings.The following is a simple example of using sockets and plugs. The method of communication between processes is deliberately kept very simple: The <classname>Plug</classname> writes its ID out to a text file named <filename>plug.id</filename> and the process with the socket reads the ID from this files. In a real program, you may want to use a more sophisticated method of inter-process communication.The following program uses a <classname>Gtk::AspectFrame</classname> to present a drawing area whose aspect ratio will always be 2:1, no matter how the user resizes the top-level window.The function <methodname>Cairo::Context::arc_negative()</methodname> is exactly the same as <methodname>Cairo::Context::arc()</methodname> but the angles go the opposite direction.The function <methodname>Cairo::Context::paint()</methodname> is used here to set the background color of the window. This function takes no arguments and fills the current surface (or the clipped portion of the surface) with the source color currently active. After setting the background color of the window, we draw a circle for the clock outline, fill it with white, and then stroke the outline in black. Notice that both of these actions use the <methodname>_preserve</methodname> variant to preserve the current path, and then this same path is clipped to make sure than our next lines don't go outside the outline of the clock.The functions <methodname>move_item()</methodname>, <methodname>remove_item()</methodname> and <methodname>purge_items()</methodname> have no effect on the actual files that are referred to by the URIs, they only modify the list of recent files.The grid's dimensions need to be specified in the constructor:The group which treats the values as arbitrary numbers includes the <classname>Range</classname> widgets (<classname>Scrollbars</classname> and <classname>Scales</classname>, the <classname>Progressbar</classname> widget, and the <classname>SpinButton</classname> widget). These widgets are typically "adjusted" directly by the user with the mouse or keyboard. They will treat the <parameter>lower</parameter> and <parameter>upper</parameter> values of an adjustment as a range within which the user can manipulate the adjustment's <parameter>value</parameter>. By default, they will only modify the <parameter>value</parameter> of an adjustment.The implementation of the <function>wrap_init()</function> method in <filename>wrap_init.cc</filename> is generated by <filename>generate_wrap_init.pl</filename>, but the declaration in <filename>wrap_init.h</filename> is hand-coded, so you will need to adjust <filename>wrap_init.h</filename> so that the <function>init()</function> function appears in the correct C++ namespace.The label text can be justified using the <methodname>set_justify()</methodname> method. The widget is also capable of word-wrapping, which can be activated with <methodname>set_line_wrap()</methodname>.The last class that implements the <classname>RecentChooser</classname> interface is <classname>RecentChooserMenu</classname>. This class allows you to list recently used files as a menu.The last line shows the window and enters the <application>gtkmm</application> main processing loop, which will finish when the window is closed.The limit on the number of items returned can be set by <methodname>set_limit()</methodname>, and queried with <methodname>get_limit()</methodname>.The line join style is set using the function <methodname>Cairo::Context::set_line_join()</methodname>.The list is provided via a <classname>TreeModel</classname>, and columns from this model are added to the ComboBox's view with the <methodname>ComboBox::pack_start()</methodname> method. This provides flexibility and compile-time type-safety, but the <classname>ComboBoxText</classname> class provides a simpler text-based specialization in case that flexibility is not required.The macros are explained in more detail in the following sections.The macros in this example do the following: <placeholder-1/>The macros that you use in the .hg and .ccg files often need to know how to convert a C++ type to a C type, or vice-versa. gmmproc takes this information from an .m4 file in your <literal>tools/m4/</literal> directory. This allows it to call a C function in the implementation of your C++ method, passing the appropriate parameters to that C functon. For instance, this tells gmmproc how to convert a GtkTreeView pointer to a Gtk::TreeView pointer: <placeholder-1/>The main activity in the internationalization process is finding strings seen by users and marking them for translation. You do not need to do it all at once - if you set up the necessary project infrastructure correctly then your application will work normally regardless of how many strings you've covered.The modelThe model for a ComboBox can be defined and filled exactly as for a <classname>TreeView</classname>. For instance, you might derive a ComboBox class with one integer and one text columns, like so:The name of the library, such as libsomethingmm.The names of the <application>gtkmm</application> packages vary from distribution to distribution (e.g. <application>libgtkmm3.0-dev</application> on Debian and Ubuntu or <application>gtkmm30-devel</application> on Red Hat Fedora), so check with your distribution's package management program for the correct package name and install it like you would any other package.The native GTK+ print dialog has a preview button, but you may also start a preview directly from an application: <placeholder-1/>The next is more interesting. <function>sigc::mem_fun()</function> is called with two arguments. The first argument is <parameter>some_object</parameter>, which is the object that our new slot will be pointing at. The second argument is a pointer to one of its methods. This particular version of <function>sigc::mem_fun()</function> creates a slot which will, when "called", call the pointed-to method of the specified object, in this case <methodname>some_object.on_button_clicked()</methodname>.The next line: <placeholder-1/> creates a <classname>Gtk::Main</classname> object. This is needed in all <application>gtkmm</application> applications. The constructor for this object initializes <application>gtkmm</application>, and checks the arguments passed to your application on the command line, looking for standard options such as <literal>-display</literal>. It takes these from the argument list, leaving anything it does not recognize for your application to parse or ignore. This ensures that all <application>gtkmm</application> applications accept the same set of standard arguments.The next two lines of code create and display a window:The number of decimal places can be altered using the <methodname>set_digits()</methodname> method.The only difference between this example and the straight line example is in the <methodname>on_expose_event()</methodname> function, but there are a few new concepts and functions introduced here, so let's examine them briefly.The other group includes the <classname>Viewport</classname> widget and the <classname>ScrolledWindow</classname> widget. All of these widgets use pixel values for their adjustments. These are also typically adjusted indirectly using scrollbars. While all widgets which use adjustments can either create their own adjustments or use ones you supply, you'll generally want to let this particular category of widgets create its own adjustments.The package names will not change when new API/ABI-compatible versions of <application>gtkmm</application> are released. Otherwise they would not be API/ABI-compatible. So don't be surprised, for instance, to find <application>gtkmm</application> 2.8 supplied by Debian's <application>libgtkmm2.4-dev</application> package.The padding arguments work just as they do for <methodname>pack_start()</methodname>.The primary disadvantages of using class scope widgets are revealing the class implementation rather than the class interface in the class header. Class scope widgets also require Automatic widgets in class scope suffer the same disadvantages as any other class scope automatic variable.The primary object is <classname>Gtk::PrintOperation</classname>, allocated for each print operation. To handle page drawing connect to its signals, or inherit from it and override the default virtual signal handlers. <classname>PrintOperation</classname> automatically handles all the settings affecting the print loop.The process of writing source code that allows for translation is called <literal>internationalization</literal>, often abbreviated to <literal>i18n</literal>. The <literal>Localization</literal> process, sometimes abbreviated as <literal>l10n</literal>, provides translated text for other languages, based on that source code.The return value is a <classname>sigc::connection</classname> that may be used to stop monitoring this file descriptor using its <methodname>disconnect()</methodname> method. The <parameter>slot</parameter> signal handler should be declared as follows:The rows and columns are indexed starting at 0. If you specify <parameter>rows</parameter> = 2 and <parameter>columns</parameter> = 2, the layout would look something like this:The same principles apply for signals which have more arguments. Here's one with three (taken from <filename>&lt;gtkmm/editable.h&gt;</filename>):The second way to set up radio buttons is to make a group first, and then add radio buttons to it. Here's an example:The section for drawing an arc introduces one new function, <methodname>close_path()</methodname>. This function will in effect draw a straight line from the current point back to the first point in the path. There is a significant difference between calling <methodname>close_path()</methodname> and manually drawing a line back to the starting point, however. If you use <methodname>close_path()</methodname>, the lines will be nicely joined together. If you use <methodname>line_to()</methodname> instead, the lines will end at the same point, but Cairo won't do any special joining.The selected rowsThe signal handler is <methodname>on_button_clicked()</methodname>.The single-item container widgets derive from <classname>Gtk::Bin</classname>, which provides the <methodname>add()</methodname> and <methodname>remove()</methodname> methods for the child widget. Note that <classname>Gtk::Button</classname> and <classname>Gtk::Window</classname> are technically single-item containers, but we have discussed them already elsewhere.The source widget will emit these signals, in this order: <placeholder-1/>The standard tree models (<classname>TreeStore</classname> and <classname>ListStore</classname> derive from <classname>TreeSortable</classname>, so they offer sorting functionality. For instance, call <methodname>set_sort_column()</methodname>, to sort the model by the specified column. Or supply a callback function to <methodname>set_sort_func()</methodname> to implement a more complicated sorting algorithm.The text columnThe use of the <literal>const</literal> keyword in C++ is not always clear. You might not realise that <type>const Something*</type> declares a pointer to a <type>const Something</type>, The pointer can be changed, but not the <type>Something</type> that it points to.The value can have an adjustable number of decimal places, and the step size is configurable. <classname>SpinButton</classname>s have an 'auto-repeat' feature as well: holding down one of the arrows can optionally cause the value to change more quickly the longer the arrow is held down.The value displayed by a scale widget is rounded to one decimal point by default, as is the <literal>value</literal> field in its <classname>Gtk::Adjustment</classname>. You can change this with the <methodname>set_digits()</methodname> method.The way it works is that you contact the gnome-i18n mailing list to find out how the translators can access your <filename>po/</filename> subdirectory, and to add your project to the big <ulink url="http://developer.gnome.org/projects/gtp/status/">status tables</ulink>.The way that <classname>Sockets</classname> and <classname>Plugs</classname> work together is through their window ids. Both a <classname>Socket</classname> and a <classname>Plug</classname> have IDs that can be retrieved with their <methodname>get_id()</methodname> member functions. The use of these IDs will be explained below in <xref linkend="sec-connecting-plugs-sockets"/>.The widgets don't rearrange themselves when the window is resized. Some widgets are hidden when the window is made smaller, and lots of useless space appears when the window is made larger.The width of the label will be adjusted automatically. You can produce multi-line labels by putting line breaks ("\n") in the label string.The window ID is: 69206019Then edit the <filename>.cc</filename> file to specify the correct types. For instance, your <function>main()</function> function might look like this: <placeholder-1/>Then start the <filename>socket</filename> program:Then use <methodname>append_column()</methodname> to add the view Column to the View. Notice that <methodname>Gtk::View::append_column()</methodname> is overridden to accept either a prebuilt <classname>Gtk::View::Column</classname> widget, or just the <classname>TreeModelColumn</classname> from which it generates an appropriate <classname>Gtk::View::Column</classname> widget.Then you make sure you update the file <filename>POTFILES.in</filename> in the <filename>po/</filename> subdirectory (<command>intltool-update -M</command> can help with this) so that the translators always access updated <filename>myprogram.pot</filename> files, and simply freeze the strings at least a couple of days before you make a new release, announcing it on gnome-i18n. Depending on the number of strings your program contains and how popular it is, the translations will then start to tick in as <filename>languagename.po</filename> files.Then, to add a widget at that position, use <methodname>Gtk::TextView::add_child_at_anchor()</methodname>:Then, you can define the actual visible layout of the menus and toolbars, and add the UI layout to the <classname>UIManager</classname>. This "ui string" uses an XML format, in which you should mention the names of the actions that you have already created. For instance:There are a couple of drawing methods for putting image data into a drawing area. <methodname>draw_pixmap()</methodname> can copy the contents of a <classname>Gdk::Drawable</classname> (the window of a drawing area is one) into the drawing area. There is also <methodname>draw_bitmap()</methodname> for drawing a two-color image into the drawing area, and <methodname>draw_image()</methodname> for drawing an image with more than two colors.There are a couple of things to note about this example code. Again, the only real difference between this example and the previous ones is the <methodname>on_expose_event()</methodname> function, so we'll limit our focus to that function. In addition, the first part of the function is nearly identical to the previous examples, so we'll skip that portion.There are a few common mistakes that you would discover eventually yourself. But this section might help you to avoid them.There are a number of graphics state variables that can be set for a Cairo context. The most common context attributes are color (using <methodname>set_source_rgb()</methodname> or <methodname>set_source_rgba()</methodname> for translucent colors), line width (using <methodname>set_line_width()</methodname>), line dash pattern (using <methodname>set_dash()</methodname>), line cap style (using <methodname>set_line_cap()</methodname>), and line join style (using <methodname>set_line_join()</methodname>), and font styles (using <methodname>set_font_size()</methodname>, <methodname>set_font_face()</methodname> and others). There are many other settings as well, such as transformation matrices, fill rules, whether to perform antialiasing, and others. For further information, see the <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink> API documentation.There are basically five different styles, as shown in this picture:There are horizontal and vertical scrollbar classes - <classname>Gtk::HScrollbar</classname> and <classname>Gtk::VScrollbar</classname>.There are other things you can customize as well, including creating dashed lines and other things. For more information , see the Cairo API documentation.There are several derived <classname>Dialog</classname> classes which you might find useful. <classname>Gtk::MessageDialog</classname> is used for most simple notifications. But at other times you might need to derive your own dialog class to provide more complex functionality.There are several options governing how widgets are to be packed, and this can be confusing at first. If you have difficulties then it is sometimes a good idea to play with the <application>glade</application> GUI designer to see what is possible. You might even decide to use the <application>Gtk::Builder</application> API to load your GUI at runtime.There are several other containers, which we will also discuss.There are some optional extra arguments: <placeholder-1/>There are specific APIs for Menus and toolbars, but you should usually deal with them together, using the <classname>UIManager</classname> to define <classname>Action</classname>s which you can then arrange in menu and toolbars. In this way you can handle activation of the action instead of responding to the menu and toolbar items separately. And you can enable or disable both the menu and toolbar item via the action.There are two basic strategies that can be used: <placeholder-1/>There are two built-in <classname>Mark</classname>s - <literal>insert</literal> and <literal>select_bound</literal>, which you can access with <classname>TextBuffer</classname>'s <methodname>get_insert()</methodname> and <methodname>get_selection_bound()</methodname> methods.There are two ways to create a Button. You can specify a label string in the <classname>Gtk::Button</classname> constructor, or set it later with <methodname>set_label()</methodname>.There are two ways to set up a group of radio buttons. The first way is to create the buttons, and set up their groups afterwards. Only the first two constructors are used. In the following example, we make a new window class called <classname>RadioButtons</classname>, and then put three radio buttons in it:There is a more complex example in examples/dnd.There is also a method for drawing from a <classname>Gdk::Pixbuf</classname>. A <classname>Gdk::Pixbuf</classname> buffer is a useful wrapper around a collection of pixels, which can be read from files, and manipulated in various ways.There may be times when you need to modify the list of recent files. For instance, if a file is moved or renamed, you may need to update the file's location in the recent files list so that it doesn't point to an incorrect location. You can update an item's location by using <methodname>move_item()</methodname>.There's rather a lot to think about in this (non-functional) code. First let's identify the parties involved:Therefore, the <classname>RefPtr</classname> equivalent of <type>Something*</type> for a method parameter is <type>const Glib::RefPtr&lt;Something&gt;&amp;</type>, and the equivalent of <type>const Something*</type> is <type>const Glib::RefPtr&lt;const Something&gt;&amp;</type>.These are standard scrollbars. They should be used only to scroll another widget, such as, a <classname>Gtk::Entry</classname>, or a <classname>Gtk::Viewport</classname>, though it's usually easier to use the <classname>Gtk::ScrolledWindow</classname> widget in most cases.These dependencies have their own dependencies, including the following applications and libraries:These signals behave slightly differently. The value returned from the signal handler indicates whether it has fully "handled" the event. If the value is <literal>false</literal> then <application>gtkmm</application> will pass the event on to the next signal handler. If the value is <literal>true</literal> then no other signal handlers will need to be called.These widgets are mainly used for decoration or layout, so you won't often need to capture events on them. They are intended to have no X-Window in order to improve performance.Things are dragged from <literal>sources</literal> to be dropped on <literal>destinations</literal>. Each source and destination has infomation about the data formats that it can send or receive, provided by <classname>Gtk::TargetEntry</classname> items. A drop destination will only accept a dragged item if they both share a compatible <classname>Gtk::TargetEntry</classname> item. Appropriate signals will then be emitted, telling the signal handlers which <classname>Gtk::TargetEntry</classname> was used.This <filename>.defs</filename> file describes enum types and their possible values. It is generated by the <filename>enum.pl</filename> script which you can find in glibmm's <filename>tools</filename> directory. For instance, <placeholder-1/>This <filename>.defs</filename> file describes objects and their functions. It is generated by the <command>h2def.py</command> script which you can find in pygobject's <filename>codegen</filename> directory. For instance, <placeholder-1/>This <filename>.defs</filename> file describes signals and properties. It is generated by the special <filename>extra_defs</filename> utility that is in every wrapping project, such as <filename>gtkmm/tools/extra_defs_gen/</filename>. For instance <placeholder-1/>This <varname>PROGRAMNAME_LOCALEDIR</varname> variable will be used later in the <literal>Makefile.am</literal> file, to define a macro that will be used when you initialize <application>gettext</application> in your source code.This allows language bindings to implement their own equivalents (such as C++ constructors), without using the <function>*_new()</function> function. This is often necessary so that they can actually instantiate a derived GType, to add their own hooks for signal handlers and vfuncs.This bookThis book assumes a good understanding of C++, and how to create C++ programs.This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets").This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets"). Although it mentions classes, constructors, and methods, it does not go into great detail. Therefore, for full API information you should follow the links into the reference documentation.This causes <application>gtkmm</application> to call the specified method whenever nothing else is happening. You can add a priority (lower numbers are higher priorities). There are two ways to remove the signal handler: calling <methodname>disconnect()</methodname> on the <classname>sigc::connection</classname> object, or returning <literal>false</literal> in the signal handler, which should be declared as follows:This chapter will introduce some of the most important aspects of <application>gtkmm</application> coding. These will be demonstrated with simple working example code. However, this is just a taster, so you need to look at the other chapters for more substantial information.This class implements the "Hello World" window. It's derived from <classname>Gtk::Window</classname>, and has a single <classname>Gtk::Button</classname> as a member. We've chosen to use the constructor to do all of the initialisation work for the window, including setting up the signals. Here it is, with the comments omitted:This command will build and install a series of modules and will probably take quite a long time the first time through. After the first time, however, it should go quite a bit faster since it only needs to rebuild files than changed since the last build. Alternatively, after you've built and installed <application>gtkmm</application> the first time, you can rebuild <application>gtkmm</application> by itself (without rebuilding all of its dependencies) with the command <command>jhbuild buildone gtkmm</command>.This compiler error might look like this: <placeholder-1/> or this: <placeholder-2/>This document, like so much other great software out there, was created for free by volunteers. If you are at all knowledgeable about any aspect of <application>gtkmm</application> that does not already have documentation, please consider contributing to this document.This example adds a <classname>ToolPalette</classname> and a <classname>DrawingArea</classname> to a window and allows the user to drag icons from the tool palette to the drawing area. The tool palette contains several groups of items. The combo boxes allow the user to change the style and orientation of the tool palette.This example allows copy and pasting of application-specific data, using the standard text target. Although this is simple, it's not ideal because it does not identify the <classname>Clipboard</classname> data as being of a particular type.This example creates a <classname>Gtk::EntryCompletion</classname> and associates it with a <classname>Gtk::Entry</classname> widget. The completion uses a <classname>Gtk::TreeModel</classname> of possible entries, and some additional actions.This example creates a button with a picture and a label.This example creates two executable programs: <filename>socket</filename> and <filename>plug</filename>. The idea is that <filename>socket</filename> has an application window that will embed a widget from the <filename>plug</filename> program. The way this example is designed, <filename>plug</filename> must be running first before starting <filename>socket</filename>. To see the example in action, execute the following commands in order from within the example directory:This example displays a window with three range widgets all connected to the same adjustment, along with a couple of controls for adjusting some of the parameters mentioned above and in the section on adjustments, so you can see how they affect the way these widgets work for the user.This example has a <classname>Gtk::TreeView</classname> widget, with a <classname>Gtk::ListStore</classname> model.This example implements a container with two child widgets, one above the other. Of course, in this case it would be far simpler just to use a <classname>Gtk::VBox</classname>.This example implements a widget which draws a Penrose triangle.This example is identical to the <classname>ListStore</classname> example, but it uses <methodname>TreeView::append_column_editable()</methodname> instead of <methodname>TreeView::append_column()</methodname>.This example is much like the <classname>ListStore</classname> example, but derives a custom <classname>TreeView</classname> in order to override the <literal>button_press_event</literal>, and also to encapsulate the tree model code in our derived class. See the <link linkend="sec-treeview-contextmenu">TreeView Popup Context Menu</link> section.This example is much like the <classname>TreeStore</classname> example, but has 2 extra columns to indicate whether the row can be dragged, and whether it can receive drag-and-dropped rows. It uses a derived <classname>Gtk::TreeStore</classname> which overrides the virtual functions as described in the <link linkend="sec-treeview-draganddrop">TreeView Drag and Drop</link> section..This example is very similar to the <classname>ListStore</classname> example, but uses a <classname>Gtk::TreeStore</classname> model instead, and adds children to the rows.This example points out the difference of idle and timeout methods a little. If you need methods that are called periodically, and speed is not very important, then you want timeout methods. If you want methods that are called as often as possible (like calculating a fractal in background), then use idle methods.This example right-aligns a button in a window by using an <classname>Alignment</classname> widget.This example shows a <classname>Gtk::Entry</classname> widget with a progress bar.This example shows a <classname>Gtk::Entry</classname> widget with a stock search icon, and prints text to the terminal when the icon is pressed.This example shows how to load a <application>Glade</application> file at runtime and access the widgets via a derived class.This example uses <classname>Gtk::Entry</classname>. It also has two <classname>CheckButton</classname>s, with which you can toggle the editable and visible flags.This exception can then be thrown by methods which are generated from _WRAP_METHOD() with the errthrow option.This has the following advantages: <placeholder-1/>This involves a variety of tools, some of them crufty, but it does at least work, and has been used successfully by several projects.This involves the use of the <classname>Gtk::ActionGroup</classname>, <classname>Gtk::Action</classname>, and <classname>UIManager</classname> classes, all of which should be instantiated via their <methodname>create()</methodname> methods, which return <classname>RefPtr</classname>s.This is a full working example that defines and uses custom signal.This is demonstrated in the Popup Custom Menu example.This is demonstrated in the drag_and_drop example.This is easy to correct in the C library, so do send a patch to the relevant maintainer.This is like the simple example, but it <placeholder-1/>This is one of the places where the beauty of C++ really comes out. One wouldn't think of subclassing a GTK+ widget simply to override its action method; it's just too much trouble. In GTK+, you almost always use signals to get things done, unless you're writing a new widget. But because overriding methods is so easy in C++, it's entirely practical - and sensible - to subclass a button for that purpose.This is the declaration of the <methodname>pack_start()</methodname> method:This isn't purely a <application>gtkmm</application> or GUI issue. <application>gtkmm</application> uses <application>libsigc++</application> to implement its proxy wrappers for the <application>GTK+</application> signal system, but for new, non-GTK+ signals, you can create pure C++ signals, using the <classname>sigc::signal&lt;&gt;</classname> template.This macro can be used to wrap structs which don't fit into any specialized category.This macro creates a constructor with arguments, equivalent to a <function>*_new()</function> C function. It won't actually call the <function>*_new()</function> function, but will simply create an equivalent constructor with the same argument types. It takes a C++ constructor signature, and a C function name.This macro creates a default constructor with no arguments.This macro declares a wrapper for a non-<classname>GObject</classname> struct, registered with <function>g_boxed_type_register_static()</function>.This macro declares a wrapper for a reference-counted opaque struct. The C++ wrapper cannot be directly instantiated and can only be used with <classname>Glib::RefPtr</classname>.This macro declares a wrapper for a simple assignable struct such as <classname>GdkRectangle</classname>. It is similar to <function>_CLASS_BOXEDTYPE</function>, but the C struct is not allocated dynamically.This macro declares a wrapper for a type that is derived from <classname>GObject</classname>, but which is not derived from <classname>GtkObject</classname>.This macro declares a wrapper for a type that is derived from <classname>GtkObject</classname>, such as a widget or dialog.This macro declares a wrapper for an opaque struct that has copy and free functions. The new, copy and free functions will be used to instantiate the default constructor, copy constructor and destructor.This macro generates a C++ enum to wrap a C enum. You must specify the desired C++ name and the name of the underlying C enum.This macro generates a C++ exception class, derived from Glib::Error, with a Code enum and a code() method. You must specify the desired C++ name, the name of the corresponding C enum, and the prefix for the C enum values.This macro generates the C++ libsigc++-style signal to wrap a C GObject signal. It actually generates a public accessor method, such as <function>signal_clicked()</function>, which returns a proxy object. <command>gmmproc</command> uses the .defs file to discover the C parameter types and the .m4 convert files to discover appropriate type conversions.This macro generates the C++ method to wrap a C GObject property. You must specify the property name and the wanted C++ type for the property. <command>gmmproc</command> uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.This macro generates the C++ method to wrap a C function.This macro is like <function>_WRAP_METHOD()</function>, but it generates only the documentation for a C++ method that wraps a C function. Use this when you must hand-code the method, but you want to use the documentation that would be generated if the method was generated.This macro will be used when you initialize <literal>gettext</literal> in your source code.This means that any method which takes a <type>const Glib::RefPtr&lt;BaseType&gt;</type> argument can also take a <type>const Glib::RefPtr&lt;DerivedType&gt;</type>. The cast is implicit, just as it would be for a normal pointer.This program contains a single class, <classname>MyArea</classname>, which is a subclass of <classname>Gtk::DrawingArea</classname> and contains an <methodname>on_expose_event()</methodname> member function. This method is called whenever the image in the drawing area needs to be redrawn. This function is passed a pointer to a <classname>GdkEventExpose</classname> structure which defines the area that needs to be redrawn. We use these values to create a rectangle path in Cairo (using the <methodname>rectangle()</methodname> function) and then <methodname>clip()</methodname> to this path. The <methodname>clip()</methodname> function sets a clip region. The current clip region affects all drawing operations by effectively masking out any changes to the surface that are outside the current clip region. This allows us to limit our redrawing to only the area that needs to be redrawn. The actual drawing code sets the color we want to use for drawing by using <methodname>set_source_rgb()</methodname> which takes arguments defining the Red, Green, and Blue components of the desired color (valid values are between 0 and 1). After setting the color, we created a new path using the functions <methodname>move_to()</methodname> and <methodname>line_to()</methodname>, and then stroked this path with <methodname>stroke()</methodname>.This provides a directory structure for the source .hg and .ccg files and the generated .h and .cc files, with <filename>filelist.am</filename> Automake include files that can specify the various files in use, in terms of generic Automake variables. The directory structure usually looks like this, after we have renamed the directories appropriately: <placeholder-1/>This section is simply a gathering of wisdom, general style guidelines and hints for creating <application>gtkmm</application> applications.This simple application draws a curve with Cairo and displays the control points for each end of the curve.This simple example shows how to load a <application>Glade</application> file at runtime and access the widgets with <application>Gtk::Builder</application>.This variable must mention the correct library name, and this library name must be used to form the <varname>_SOURCES</varname>, <varname>_LDFLAGS</varname>, and <varname>_LIBADD</varname> variable names. It is permissible to use variables substituted by <filename>configure</filename> like <varname>@SOMETHINGMM_API_VERSION@</varname> as part of the variable names.This will cause the table to expand to use up anyremaining space in the window.Though it's usually obvious what C++ types should be used in the C++ method, here are some hints: <placeholder-1/>TimeoutsTimeouts, I/O and Idle FunctionsTo access a widget, for instance to <methodname>show()</methodname> a dialog, use the <methodname>get_widget()</methodname> method, providing the widget's name. This name should be specified in the <application>Glade</application> Properties window. If the widget could not be found, or is of the wrong type, then the pointer will be set to 0. <placeholder-1/>To achieve this, you should use the normal <classname>Gtk::TreeView</classname><methodname>insert_column()</methodname> and <methodname>append_column()</methodname> methods, then use <methodname>get_column_cell_renderer()</methodname> to get the <classname>Gtk::CellRenderer</classname> used by that column.To add a new file to the list of recent documents, in the simplest case, you only need to provide the URI. For example:To add widgets to the action area, use the <methodname>add_action_widget()</methodname> method. They will be packed alongside the default buttons. Use the <methodname>remove_action_widget()</methodname> method to remove widgets.To begin our introduction to <application>gtkmm</application>, we'll start with the simplest program possible. This program will create an empty 200 x 200 pixel window.To change the selection, specify a <classname>Gtk::TreeModel::iterator</classname> or <classname>Gtk::TreeModel::Row</classname>, like so:To change the value shown, use the <methodname>set_fraction()</methodname> method, passing a double between 0 and 1 to provide the new percentage.To control which rows can be selected, use the <methodname>set_select_function()</methodname> method, providing a <classname>sigc::slot</classname> callback. For instance:To convince yourself that you've done well, you may wish to add a translation for a new locale. In order to do that, go to the <filename>po</filename> subdirectory of your project and execute the following command: <placeholder-1/>To define an accelerator key for keyboard navigation, place an underscore before one of the label's characters and specify <literal>true</literal> for the optional <literal>mnemonic</literal> parameter. For instance:To detect a click of the right mouse button, you need to handle the <literal>button_press_event</literal> signal, and check exactly which button was pressed. Because the <classname>TreeView</classname> normally handles this signal completely, you need to either override the default signal handler in a derived <classname>TreeView</classname> class, or use <methodname>connect_nofify()</methodname> instead of <methodname>connect()</methodname>. You probably also want to call the default handler before doing anything else, so that the right-click will cause the row to be selected first.To determine the currently-visible page, use the <methodname>get_current_page()</methodname> method, and pass the result to <methodname>get_nth_page()</methodname>, which returns a pointer to the actual widget. To programmatically change the current page, use the <methodname>set_current_page()</methodname> method.To discover the currently visible page, use the <methodname>get_current_page()</methodname> method. This returns the page number, and then calling <methodname>get_nth_page()</methodname> with that number will give you a pointer to the actual child widget.To discover what item, if any, the user has chosen from the ComboBox, call <methodname>ComboBox::get_active()</methodname>. This returns a <classname>TreeModel::iterator</classname> that you can dereference to a <classname>Row</classname> in order to read the values in your columns. For instance, you might read an integer ID value from the model, even though you have chosen only to show the human-readable description in the Combo. For instance:To do any drawing in <application>gtkmm</application> with Cairo, you must first create a <classname>Cairo::Context</classname> object. This class holds all of the graphics state parameters that describe how drawing is to be done. This includes information such as line width, color, the surface to draw to, and many other things. This allows the actual drawing functions to take fewer arguments to simplify the interface. In <application>gtkmm</application>, a <classname>Cairo::Context</classname> is created by calling the <methodname>Gdk::Window::create_cairo_context()</methodname> function. Since Cairo context are reference-counted objects, this function returns a <classname>Cairo::RefPtr&lt;Cairo::Context&gt;</classname> object.To do this, you need to call the <methodname>pulse()</methodname> method at regular intervals. You can also choose the step size, with the <methodname>set_pulse_step()</methodname> method.To draw an ellipse, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse in the box given by <varname>x</varname>, <varname>y</varname>, <varname>width</varname>, <varname>height</varname>: <placeholder-1/> Note that this contradicts the <ulink url="http://www.cairographics.org/manual/cairo-Paths.html#cairo-arc">advice given in the official Cairo documentation</ulink>, but it seems to work.To enable this functionality, you must create a <classname>EntryCompletion</classname> object, and provide it to the <classname>Entry</classname> widget via the <methodname>set_completion()</methodname> method.To find out what rows the user has selected, get the <classname>Gtk::TreeView::Selection</classname> object from the <classname>TreeView</classname>, like so:To find out what targets are currently available on the <classname>Clipboard</classname> for pasting, call the <methodname>request_targets()</methodname> method, specifying a method to be called with the information. For instance:To find out what type of signal handler you can connect to a signal, you can look it up in the reference documentation or the header file. Here's an example of a signal declaration you might see in the <application>gtkmm</application> headers:To force it to snap to the nearest <literal>step_increment</literal>, use <methodname>set_snap_to_ticks()</methodname>.To instantiate a <classname>Gtk::MenuBar</classname> or <classname>Gtk::Toolbar</classname> which you can actually show, you should use the <methodname>UIManager::get_widget()</methodname> method, and then add the widget to a container. For instance:To instantiate just one window, or just one of the child widgets, you can specify the name of a widget as the second parameter. For instance, <placeholder-1/>To look up recently used files, <classname>RecentManager</classname> provides several functions. To look up a specific item by its URI, you can use the <methodname>lookup_item()</methodname> function, which will return a <classname>RecentInfo</classname> class. If the specified URI did not exist in the list of recent files, the <classname>RecentInfo</classname> object will be invalid. <classname>RecentInfo</classname> provides an implementation for <methodname>operator bool()</methodname> which can be used to test for validity. For example:To make the <classname>SpinButton</classname> 'wrap' between its upper and lower bounds, use the <methodname>set_wrap()</methodname> method.To obtain a <application>gtkmm</application> instance from a C GObject instance, use the Glib::wrap() function. For instanceTo pack widgets into a custom dialog, you should pack them into the <classname>Gtk::VBox</classname>, available via <methodname>get_vbox()</methodname>. To just add a <classname>Button</classname> to the bottom of the <classname>Dialog</classname>, you could use the <methodname>add_button()</methodname> method.To place a widget into a box, use the following method:To prevent the user from typing non-numeric characters into the entry box, pass <literal>true</literal> to the <methodname>set_numeric()</methodname> method.To programmatically change the selected page, use the <methodname>set_current_page()</methodname> method.To render more than one model column in a view column, you need to create the <classname>TreeView::Column</classname> widget manually, and use <methodname>pack_start()</methodname> to add the model columns to it.To respond to the user clicking on a row or range of rows, connect to the signal like so:To retrieve the state of the <classname>ToggleButton</classname>, you can use the <methodname>get_active()</methodname> method. This returns <literal>true</literal> if the button is "down". You can also set the toggle button's state, with <methodname>set_active()</methodname>. Note that, if you do this, and the state actually changes, it causes the "clicked" signal to be emitted. This is usually what you want.To set the title of a page, use the <methodname>set_page_title()</methodname> method. The header and side images of a page can be set with the <methodname>set_page_header_image()</methodname> and <methodname>set_page_side_image()</methodname> methods.To set up <application>jhbuild</application>, follow the basic installation instructions from the <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">jhbuild manual</ulink>. After you've have installd <application>jhbuild</application>, you should copy the sample <application>jhbuild</application> configuration file into your home directory by executing the following command from the <application>jhbuild</application> directory: <command>$ cp sample.jhbuildrc ~/.jhbuildrc</command>To show the popup menu, use <classname>Gtk::Menu</classname>'s <methodname>popup()</methodname> method, providing the button identifier and the time of activation, as provided by the <literal>button_press_event</literal> signal, which you will need to handle anyway. For instance:To simplify compilation, we use <literal>pkg-config</literal>, which is present in all (properly installed) <application>gtkmm</application> installations. This program 'knows' what compiler switches are needed to compile programs that use <application>gtkmm</application>. The <literal>--cflags</literal> option causes <literal>pkg-config</literal> to output a list of include directories for the compiler to look in; the <literal>--libs</literal> option requests the list of libraries for the compiler to link with and the directories to find them in. Try running it from your shell-prompt to see the results on your system.To specify that some text in the buffer should have specific formatting, you must define a tag to hold that formatting information, and then apply that tag to the region of text. For instance, to define the tag and its properties:To use a <application>gtkmm</application> instance with a C function that requires a C GObject instance, use the <function>gobj()</function> function to obtain a pointer to the underlying GObject instance. For instanceTo work around this, you could write a comment in the source code just before the string, telling the translators to use the special character if it is available in their languages. For english, you could then make an American English <filename>en_US.po</filename> translation which used that special charactger.Toggle buttonsToggleButtonToolItem ReferenceToolItemGroup ReferenceToolPaletteToolPalette ExampleToolPalette ReferenceTooltipTooltip ReferenceTooltipsTooltips are the little information windows that pop up when you leave your pointer over a widget for a few seconds. Use <methodname>set_tooltip_text()</methodname> to set a text string as a tooltip on any <classname>Widget</classname>. <classname>Gtk::ToolItem</classname>s are not <classname>Widget</classname>s, but have the same method for convenience. <classname>Gtk::Tooltip</classname> is used for more advanced tooltip usage, such as showing an image as well as text.TreeModel::iterator iter = refTreeSelection-&gt;get_selected();
if(iter) //If anything is selected
{
  TreeModel::Row row = *iter;
  //Do something with the row.
}TreeModelSort ReferenceTreeSortable ReferenceTreeStoreTreeStore, for a hierarchyTreeView - Drag And DropTreeView - Editable CellsTreeView - ListStoreTreeView - Popup Context MenuTreeView - TreeStoreTrolltech's Qt is the closest competition to <application>gtkmm</application>, so it deserves discussion.Try executing the example and increasing the system load. The upper progress bar will increase steadily; the lower one will slow down.Try to compile and run it before going on. You should see something like this:Two extra parameters are optional, for the case that the interface derives from another interface, which should be the case when the GInterface has another GInterface as a prerequisitite. For instance, from <filename>loadableicon.hg</filename>: <placeholder-1/>Typically our wrapper library would be called libsomethingmm. We can start by copying the <ulink url="http://git.gnome.org/cgit/mm-common/tree/skeletonmm">skeleton source tree</ulink> from the mm-common module. <placeholder-1/>UI changes can be seen more quickly, so UIs are able to improve.UIManagerUnable to predeclare structsUnfortunately, the integration with the standard iostreams is not completely foolproof. <application>gtkmm</application> converts <classname>Glib::ustring</classname>s to a locale-specific encoding (which usually is not UTF-8) if you output them to an <classname>ostream</classname> with <function>operator&lt;&lt;</function>. Likewise, retrieving <classname>Glib::ustrings</classname> from <classname>istream</classname> with <function>operator&gt;&gt;</function> causes a conversion in the opposite direction. But this scheme breaks down if you go through a <classname>std::string</classname>, e.g. by inputting text from a stream to a <classname>std::string</classname> and then implicitly converting it to a <classname>Glib::ustring</classname>. If the string contained non-ASCII characters and the current locale is not UTF-8 encoded, the result is a corrupted <classname>Glib::ustring</classname>. You can work around this with a manual conversion. For instance, to retrieve the <classname>std::string</classname> from a <classname>ostringstream</classname>: <placeholder-1/>Unix and LinuxUnless your container is a top-level window that derives from <classname>Gtk::Window</classname>, you should probably also call <methodname>Gtk::Widget::set_has_window(false)</methodname> in your constructor. This means that your container does not create its own <classname>Gdk::Window</classname>, but uses its parent's window. (Note the difference between <classname>Gtk::Window</classname> and <classname>Gdk::Window</classname>.) If your container does need its own <classname>Gdk::Window</classname>, and does not derive from <classname>Gtk::Window</classname>, you must also override the <methodname>on_realize()</methodname> method as described in the <link linkend="sec-custom-widgets">Custom Widgets</link> section. And unless your container draws directly onto the underlying <classname>Gdk::Window</classname>, you should probably call <methodname>set_redraw_on_allocate(false)</methodname> to improve performance.Unlike the Windows UCS-2 Unicode solution, this does not require any special compiler options to process string literals, and it does not result in Unicode executables and libraries which are incompatible with ASCII ones.Unlike the other widgets in this chapter, pane widgets contain not one but two child widgets, one in each pane. Therefore, you should use <methodname>add1()</methodname> and <methodname>add2()</methodname> instead of the <methodname>add()</methodname> method.Unusual wordsUpdate PoliciesUpdate your <literal>DISTCLEANFILES</literal>: <placeholder-1/>Use <methodname>Gtk::Builder::get_widget_derived()</methodname> like so: <placeholder-1/>Use GNU <application>autoconf</application> and <application>automake</application>! They are your friends :) <application>Automake</application> examines C files, determines how they depend on each other, and generates a <filename>Makefile</filename> so the files can be compiled in the correct order. <application>Autoconf</application> permits automatic configuration of software installation, handling a large number of system quirks to increase portability..Use the <methodname>append_page()</methodname>, <methodname>prepend_page()</methodname> and <methodname>insert_page()</methodname> methods to add tabbed pages to the <literal>Notebook</literal>, supplying the child widget and the name for the tab.Use the <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> and <methodname>insert_page()</methodname> methods to add pages to the <classname>Assistant</classname>, supplying the child widget for each page.Use the last GError* parameter of the C function to throw an exception.Use these macros if you're wrapping a simple struct or boxed type that provides direct access to its data members, to create getters and setters for the data members.Use these macros to automatically provide getters and setters for a data member that is a pointer type. For the getter function, it will create two methods, one const and one non-const.Use this macro to provide getters and setters for a data member that is a <classname>GObject</classname> type that must be referenced before being returned.Useful methodsUsing Adjustments the Easy WayUsing a <application>gtkmm</application> widgetUsing a ModelUsing derived widgetsUsing non-ASCII characters in stringsUsing the git version of <application>gtkmm</application>We also assume that you are using autotools (e.g. <application>automake</application> and <application>autoconf</application>) to build your project, and that you are using <ulink url="http://svn.gnome.org/viewcvs/gnome-common/trunk/autogen.sh?view=markup"><literal>./autogen.sh</literal> from <application>gnome-common</application></ulink>, which, among other things, takes care of some <application>intltool</application> initialization.We also discuss the <classname>Gtk::Paned</classname> widget, which allows you to divide a window into two separate "panes". This widget actually contains two child widgets, but the number is fixed so it seems appropriate.We just told you that the button's <literal>clicked</literal> signal is expecting to call a method with no arguments. All signals have requirements like this - you can't hook a function with two arguments to a signal expecting none (unless you use an adapter, such as <function>sigc::bind()</function>, of course). Therefore, it's important to know what type of signal handler you'll be expected to connect to a given signal.We made a new group by simply declaring a variable, <literal>group</literal>, of type <classname>Gtk::RadioButton::Group</classname>. Then we made three radio buttons, using a constructor to make each of them part of <literal>group</literal>.We must mention all of our <filename>.hg</filename> and <filename>.ccg</filename> files in the <filename>skeleton/src/filelist.am</filename> file, typically in the <varname>files_hg</varname> variable.We should now create our first <filename>.hg</filename> and <filename>.ccg</filename> files, to wrap one of the objects in the C library. One pair of example source files already exists: <filename>skeleton.ccg</filename> and <filename>skeleton.hg</filename>. Create copies of these files as necessary.We then hook up a signal handler to <literal>m_button</literal>'s <literal>clicked</literal> signal. This prints our friendly greeting to <literal>stdout</literal>.We told <application>gtkmm</application> to put all three <classname>RadioButton</classname>s in the same group by obtaining the group with <methodname>get_group()</methodname> and using <methodname>set_group()</methodname> to tell the other <classname>RadioButton</classname>s to share that group.We will now explain each line of the exampleWe would very much like to hear of any problems you have learning <application>gtkmm</application> with this document, and would appreciate input regarding improvements. Please see the <link linkend="chapter-contributing">Contributing</link> section for further information.We're hooking it up to the <classname>Gtk::Button</classname> object called <varname>button</varname>.We've now learned enough to look at a real example. In accordance with an ancient tradition of computer science, we now introduce Hello World, a la <application>gtkmm</application>:What if a widget reconfigures the <parameter>upper</parameter> or <parameter>lower</parameter> fields of its <classname>Adjustment</classname>, such as when a user adds more text to a text widget? In this case, it emits the <literal>changed</literal> signal.What's the difference between spacing (set when the box is created) and padding (set when elements are packed)? Spacing is added between objects, and padding is added on either side of a widget. The following figure should make it clearer:When <varname>bitmap</varname> goes out of scope an <methodname>unref()</methodname> will happen in the background and you don't need to worry about it anymore. There's no <literal>new</literal> so there's no <literal>delete</literal>.When a constructor must be partly hand written because, for instance, the <function>*_new()</function> C function's parameters do not correspond directly to object properties, or because the <function>*_new()</function> C function does more than call <function>g_object_new()</function>, the <function>_CONSTRUCT()</function> macro may be used in the .ccg file to save some work. The <function>_CONSTRUCT</function> macro takes a series of property names and values. For instance, from <filename>button.ccg</filename>: <placeholder-1/>When a drop destination has accepted a dragged item, certain signals will be emitted, depending on what action has been selected. For instance, the user might have held down the <keycap>Shift</keycap> key to specify a <literal>move</literal> rather than a <literal>copy</literal>. Remember that the user can only select the actions which you have specified in your calls to <methodname>drag_dest_set()</methodname> and <methodname>drag_source_set()</methodname>.When deriving from <classname>Gtk::Container</classname>, you should override the following virtual methods: <placeholder-1/>When deriving from <classname>Gtk::Widget</classname>, you should override the following virtual methods. The methods marked (optional) need not be overridden in all custom widgets. The base class's methods may be appropriate. <placeholder-1/>When in continuous mode, the progress bar can also display a configurable text string within its trough, using the <methodname>set_text()</methodname> method.When the Button emits its <literal>clicked</literal> signal, <methodname>on_button_clicked()</methodname> will be called.When the application runs, the <application>gettext</application> library checks the system-wide directory to see if there is a <filename>.mo</filename> file for the user's locale environment (you can set the locale with, for instance, "export LANG=de_DE.UTF-8" from a bash console). Later, when the program reaches a <literal>gettext</literal> call, it looks for a translation of a particular string. If none is found, the original string is used.When the mouse is over the button and a mouse button is pressed, <methodname>on_button_press()</methodname> will be called.When the user asks to copy some data, you should tell the <classname>Clipboard</classname> what targets are available, and provide the callback methods that it can use to get the data. At this point you should store a copy of the data, to be provided when the clipboard calls your callback method in repsonse to a paste.When the user asks to paste data from the <classname>Clipboard</classname>, you should request a specific format and provide a callback method which will be called with the actual data. For instance:When using <function>_CLASS_GOBJECT()</function>, the constructors should be protected (rather than public) and each constructor should have a corresponding <function>_WRAP_CREATE()</function> in the public section. This prevents the class from being instantiated without using a <classname>RefPtr</classname>. For instance: <placeholder-1/>When using a <classname>Gtk::TreeStore</classname>, the rows can have child rows, which can have their own children in turn. Use <methodname>Gtk::TreeModel::Row::children()</methodname> to get the container of child <classname>Row</classname>s: <placeholder-1/>When using this simple <methodname>append_column()</methodname> override, the <classname>TreeView</classname> will display the model data with an appropriate <classname>CellRenderer</classname>. For instance, strings and numbers are shown in a simple <classname>Gtk::Entry</classname> widget, and booleans are shown in a <classname>Gtk::CheckButton</classname>. This is usually what you need. For other column types you must either connect a callback that converts your type into a string representation, with <methodname>TreeViewColumn::set_cell_data_func()</methodname>, or derive a custom <classname>CellRenderer</classname>. Note that (unsigned) short is not supported by default - You could use (unsigned) int or (unsigned) long as the column type instead.When you select a choice from the drop-down menu, the value from this column will be placed in the <classname>Entry</classname>.Wherever possible you should use Stock items, to ensure consistency with other applications, and to improve the appearance of your applications by using icons. For instance, <placeholder-1/> This will use standard text, in all languages, with standard keyboard accelerators, with a standard icon.Why use <application>gtkmm</application> instead of GTK+?Widget ReferenceWidgetsWidgets Without X-WindowsWidgets and ChildAnchorsWidgets are arranged inside container widgets such as frames and notebooks, in a hierarchy of widgets within widgets. Some of these container widgets, such as <classname>Gtk::Grid</classname>, are not visible - they exist only to arrange other widgets. Here is some example code that adds 2 <classname>Gtk::Button</classname> widgets to a <classname>Gtk::VBox</classname> container widgets: <placeholder-1/> and here is how to add the <classname>Gtk::VBox</classname>, containing those buttons, to a <classname>Gtk::Frame</classname>, which has a visible frame and title: <placeholder-2/>With Cairo, the same function is used to draw arcs, circles, or ellipses: <methodname>Cairo::Context::arc()</methodname>. This function takes five arguments. The first two are the coordinates of the center point of the arc, the third argument is the radius of the arc, and the final two arguments define the start and end angle of the arc. All angles are defined in radians, so drawing a circle is the same as drawing an arc from 0 to 2 * M_PI radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_PI/2 radians (90 degrees) is in the direction of the positive Y axis (in user-space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction.Working with gtkmm's Source CodeWrapping <classname>GList*</classname> and <classname>GSList*</classname> parameters: First, you need to discover what objects are contained in the list's data field for each item, usually by reading the documentation for the C function. The list can then be wrapped by an appropriate intermediate type, such as <classname>Glib::ListHandle</classname> or <classname>Glib::SListHandle</classname>. These are templates, so you can specify the item type. For instance, <code>Glib::ListHandle&lt; Glib::RefPtr&lt;Action&gt; &gt;</code>. Existing typedefs exist for some common list types. You may need to define a Traits type to specify how the C and C++ types should be converted.Wrapping <classname>GList*</classname> and <classname>GSList*</classname> return types: You must discover whether the caller should free the list and whether it should release the items in the list, again by reading the documentation of the C function. With this information you can choose the ownership (none, shallow or deep) for the m4 conversion rule, which you should probably put directly into the .hg file because the ownership depends on the function rather than the type. For instance: <placeholder-1/>Wrapping C Libraries with gmmprocWriting signal handlersWriting the vfuncs .defsX Event signalsYes, that's correct: a Window can contain at most one widget. How, then, can we use a window for anything useful? By placing a multiple-child container in the window. The most useful container widgets are <classname>Gtk:Grid</classname>, <classname>Gtk:VBox</classname>, <classname>Gtk::HBox</classname>, and <classname>Gtk::Table</classname>.You are likely to encounter some problems in the library that you are wrapping, particularly if it is a new project. Here are some common problems, with solutions.You are not guaranteed to get the <literal>Gtk::SizeRequestMode</literal> that you request. Therefore all four of the <methodname>get_preferred_xxx_vfunc()</methodname> methods must return sensible values.You can adjust the position of the divider using the <methodname>set_position()</methodname> method, and you will probably need to do so.You can also cast to a derived type, but the syntax is a little different than with a normal pointer.You can also connect to <classname>CellRenderer</classname> signals to detect user actions. For instance:You can also set a consistent spacing for all rows and/or columns with <methodname>set_row_spacings()</methodname> and <methodname>set_col_spacings()</methodname>. Note that with these calls, the last row and last column do not get any spacing.You can also specify a signal handler when calling <methodname>ActionGroup::add()</methodname>. This signal handler will be called when the action is activated via either a menu item or a toolbar button.You can also use <methodname>get_tag_table()</methodname> to get, and maybe modify, the <classname>TextBuffer</classname>'s default <classname>TagTable</classname> instead of creating one explicitly.You can apply more than one <classname>Tag</classname> to the same text, by using <methodname>apply_tag()</methodname> more than once, or by using <methodname>insert_with_tags()</methodname>. The <classname>Tag</classname>s might specify different values for the same properties, but you can resolve these conflicts by using <methodname>Tag::set_priority()</methodname>.You can build all GNOME C++ modules by setting the <varname>modules</varname> variable to the meta-package named <literal>meta-gnome-c++</literal> or build all of the core GNOME modules with <literal>meta-gnome-desktop</literal>. The <varname>modules</varname> variable specifies which modules that will be built when you don't explicitly specify anything on the command line. You can always build a different moduleset later by specifying it on the commandline (e.g. <command>jhbuild build gtkmm</command>).You can cast <classname>RefPtrs</classname> to base types, just like normal pointers.You can copy <classname>RefPtr</classname>s, just like normal pointers. But unlike normal pointers, you don't need to worry about deleting the underlying instance.You can create a new <classname>RecentManager</classname>, but you'll most likely just want to use the default one. You can get a reference to the default <classname>RecentManager</classname> with <methodname>get_default()</methodname>.You can dereference a smartpointer with the -&gt; operator, to call the methods of the underlying instance, just like a normal pointer.You can dereference the iterator to get the Row:You can draw very sophisticated shapes using Cairo, but the methods to do so are quite basic. Cairo provides methods for drawing straight lines, curved lines, and arcs (including circles). These basic shapes can be combined to create more complex shapes and paths which can be filled with solid colors, gradients, patterns, and other things. In addition, Cairo can perform complex transformations, do compositing of images, and render antialiased text.You can embed widgets, such as <classname>Gtk::Button</classname>s, in the text. Each such child widget needs a <classname>ChildAnchor</classname>. ChildAnchors are associated with <classname>iterators</classname>. For instance, to create a child anchor at a particular position, use <methodname>Gtk::TextBuffer::create_child_anchor()</methodname>:You can modify the update policy using the <methodname>set_update_policy()</methodname> method, specifying either <literal>Gtk::UPDATE_ALWAYS</literal> or <literal>Gtk::UPDATE_IF_VALID</literal>. <literal>Gtk::UPDATE_ALWAYS</literal> causes the <classname>SpinButton</classname> to ignore errors encountered while converting the text in the entry box to a numeric value. This setting also therefore allows the <classname>SpinButton</classname> to accept non-numeric values. You can force an immediate update using the <methodname>update()</methodname> method.You can set the spinbutton's value using the <methodname>set_value()</methodname> method, and retrieve it with <methodname>get_value()</methodname>.You can specify a <classname>Gtk::TreeModel</classname> when constructing the <classname>Gtk::TreeView</classname>, or you can use the <methodname>set_model()</methodname> method, like so:You can specify a name for the <classname>Tag</classname> when using the <methodname>create()</methodname> method, but it is not necessary.You can stop the timeout method by returning <literal>false</literal> from your signal handler. Therefore, if you want your method to be called repeatedly, it should return <literal>true</literal>.You can then connect to the appropriate "edited" signal. For instance, connect to <methodname>Gtk::CellRendererText::signal_edited()</methodname>, or <methodname>Gtk::CellRendererToggle::signal_toggled()</methodname>. If the column contains more than one <classname>CellRenderer</classname> then you will need to use <methodname>Gtk::TreeView::get_column()</methodname> and then call <methodname>get_cell_renderers()</methodname> on that view Column.You can then connect to the signal using the same syntax used when connecting to <application>gtkmm</application> signals. For instance, <placeholder-1/>You can then use the <methodname>get_iter()</methodname> method later to create an iterator for the <classname>Mark</classname>'s new position.You can use <application>Glade</application> to layout your own custom widgets derived from <application>gtkmm</application> widget classes. This keeps your code organized and encapsulated. Of course you won't see the exact appearance and properties of your derived widget in <application>Glade</application>, but you can specify its location and child widgets and the properties of its <application>gtkmm</application> base class.You can use C APIs which do not yet have convenient C++ interfaces. It is generally not a problem to use C APIs from C++, and <application>gtkmm</application> helps by providing access to the underlying C object, and providing an easy way to create a C++ wrapper object from a C object, provided that the C API is also based on the GObject system.You can use the <methodname>append_column()</methodname> method to tell the View that it should display certain Model columns, in a certain order, with a certain column title.You can use the <methodname>operator[]</methodname> override to get the data in a particular column in a row, specifiying the <classname>TreeModelColumn</classname> used to create the model.You can use the <methodname>operator[]</methodname> override to set the data for a particular column in the row, specifying the <classname>TreeModelColumn</classname> used to create the model.You can use the <methodname>toggled()</methodname> method to toggle the button, rather than forcing it to be up or down: This switches the button's state, and causes the <literal>toggled</literal> signal to be emitted.You could just declare that signal as a public member variable, but some people find that distasteful and prefer to make it available via an accessor method, like so: <placeholder-1/>You could then encapsulate the manipulation of the child widgets in the constructor of the derived class, maybe using <methodname>get_widget()</methodname> or <methodname>get_widget_derived()</methodname> again. For instance, <placeholder-1/>You don't always need to call the parent's method; there are times when you might not want to. Note that we called the parent method <emphasis>after</emphasis> writing "Hello World", but we could have called it before. In this simple example, it hardly matters much, but there are times when it will. With signals, it's not quite so easy to change details like this, and you can do something here which you can't do at all with connected signal handlers: you can call the parent method in the <emphasis>middle</emphasis> of your custom code.You have no way of getting a bare <classname>Gdk::Bitmap</classname>. In the example, <varname>bitmap</varname> is a smart pointer, so you can do this, much like a normal pointer: <placeholder-1/>You may add a custom tab to the print dialog: <placeholder-1/>You may be wondering how to make <application>gtkmm</application> do useful work while it's idling along (well, sleeping actually) in <methodname>Gtk::Main::run()</methodname>. Happily, you have several options. Using the following methods you can create a timeout method that will be called every few milliseconds.You might be surprised to learn that <application>gtkmm</application> doesn't use <classname>std::string</classname> in it its interfaces. Instead it uses <classname>Glib::ustring</classname>, which is so similar and unobtrusive that you could actually pretend that each Glib::ustring is a <classname>std::string</classname> and ignore the rest of this section. But read on if you want to use languages other than English in your application.You might need to react to every change of selection in the ComboBox, for instance to update other widgets. To do so, you should handle the "changed" signal. For instance:You might not anticipate the need to support additional languages, but you can never rule it out. And it's easier to develop the application properly in the first place rather than retrofitting later.You might occasionally find it useful to handle X events when there's something you can't accomplish with normal signals. <classname>Gtk::Button</classname>, for example, does not send mouse-pointer coordinates with its <literal>clicked</literal> signal, but you could handle <literal>button_pressed_event</literal> if you needed this information. X events are also often used to handle key-presses.You might then handle the <classname>ToolButton</classname>'s <literal>clicked</literal> signal. Alternatively, you could allow the item to be dragged to another widget, by calling <methodname>Gtk::ToolPalette::add_drag_dest()</methodname> and then using <methodname>Gtk::ToolPalette::get_drag_item()</methodname> in the other widget's <literal>drag_data_received</literal> signal handler.You might want to associate extra data with each row. If so, just add it as a Model column, but don't add it to the View.You might want to be notified whenever the user types in a text entry widget. <classname>Gtk::Entry</classname> provides two signals, <literal>activate</literal> and <literal>changed</literal>, for just this purpose. <literal>activate</literal> is emitted when the user presses the enter key in a text-entry widget; <literal>changed</literal> is emitted when the text in the widget changes. You can use these, for instance, to validate or filter the text the user types.You might want to include additional source files that will not be generated by <command>gmmproc</command> from <filename>.hg</filename> and <filename>.ccg</filename> files. You can simply place these in your <filename>libsomething/libsomethingmm</filename> directory and mention them in the <filename>Makefile.am</filename> in the <varname>files_extra_h</varname> and <varname>files_extra_cc</varname> variables.You might wish to reuse documentation that exists for the C library that you are wrapping. GTK-style C libraries typically use gtk-doc and therefore have source code comments formatted for gtk-doc and some extra documentation in .tmpl files. The docextract_to_xml.py script, from pygobject's codegen directory, can read these files and generate an .xml file that <command>gmmproc</command> can use to generate doxygen comments. <command>gmmproc</command> will even try to transform the documentation to make it more appropriate for a C++ API.You must call the base class's constructor in the initialization list, providing the C pointer. For instance, <placeholder-1/>You must edit the source code of your own <filename>generate_extra_defs</filename> tool in order to generate the <filename>.defs</filename> for the GObject C types that you wish to wrap. In the skeleton source tree, the source file is named <filename>codegen/extradefs/generate_extra_defs_skeleton.cc</filename>. If not done so already, the file should be renamed, with the basename of your new binding substituted for the <varname>skeleton</varname> placeholder. The <filename>codegen/Makefile.am</filename> file should also mention the new source filename.You need to specify the <classname>Alignment</classname>'s characteristics to the constructor, or to the <methodname>set()</methodname> method. In particular, you won't notice much effect unless you specify a number other than 1.0 for the <literal>xscale</literal> and <literal>yscale</literal> parameters, because 1.0 simply means that the child widget will expand to fill all available space.You never know how much space a string will take on screen when translated. It might very possibly be twice the size of the original English string. Luckily, most <application>gtkmm</application> widgets will expand at runtime to the required size.You probably won't ever need to attach a handler to this signal, unless you're writing a new type of range widget.You should avoid C-style pointer arithmetic, and functions such as strlen(). In UTF-8, each character might need anywhere from 1 to 6 bytes, so it's not possible to assume that the next byte is another character. <classname>Glib::ustring</classname> worries about the details of this for you so you can use methods such as Glib::ustring::substr() while still thinking in terms of characters instead of bytes.You should avoid cryptic abbreviations, slang, or jargon. They are usually difficult to translate, and are often difficult for even native speakers to understand. For instance, prefer "application" to "app"You should avoid including the C header from your C++ header, to avoid polluting the global namespace, and to avoid exporting unnecessary public API. But you will need to include the necessary C headers from your .ccg file.You should be very careful when installing to standard system prefixes such as <filename>/usr</filename>. Linux distributions install software packages to <filename>/usr</filename>, so installing a source package to this prefix could corrupt or conflict with software installed using your distribution's package-management system. Ideally, you should use a separate prefix for all software you install from source.You should save the chosen <classname>Gtk::PageSetup</classname> so you can use it again if the page setup dialog is shown again.You should then cast that <classname>Gtk::CellRenderer*</classname> to the specific <classname>CellRenderer</classname> that you expect, so you can use specific API.You specify the <classname>ColumnRecord</classname> when creating the Model, like so:You still need C++ code to deal with User Interface changes triggered by user actions, but using <application>Gtk::Builder</application> for the widget layout allows you to focus on implementing that functionality.You've probably noticed that <application>gtkmm</application> windows seem "elastic" - they can usually be stretched in many different ways. This is due to the <emphasis>widget packing</emphasis> system.Your callback will then provide the store data when the user chooses to paste the data. For instance:Your derived class must have a constructor that takes a pointer to the underlying C type, and the <classname>Gtk::Builder</classname> instance. All relevant classes of <application>gtkmm</application> typedef their underlying C type as <classname>BaseObjectType</classname> (<classname>Gtk::Dialog</classname> typedefs <classname>BaseObjectType</classname> as <type>GtkDialog</type>, for instance).Your existing knowledge of C++ will help you with <application>gtkmm</application> as it would with any library. Unless we state otherwise, you can expect <application>gtkmm</application> classes to behave like any other C++ class, and you can expect to use your existing C++ techniques with <application>gtkmm</application> classes.Your implementation of the <methodname>child_type_vfunc()</methodname> method should report the type of widget that may be added to your container, if it is not yet full. This is usually <methodname>Gtk::Widget::get_type()</methodname> to indicate that the container may contain any class derived from <classname>Gtk::Widget</classname>. If the container may not contain any more widgets, then this method should return <literal>G_TYPE_NONE</literal>.Your library must be initialized before it can be used, to register the new types that it makes available. Also, the C library that you are wrapping might have its own initialization function that you should call. You can do this in an <function>init()</function> function that you can place in hand-coded <filename>init.h</filename> and <filename>init.cc</filename> files. This function should initialize your dependencies (such as the C function, and <application>gtkmm</application>) and call your generated <function>wrap_init()</function> function. For instance: <placeholder-1/>_CLASS_BOXEDTYPE_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )_CLASS_BOXEDTYPE_STATIC_CLASS_BOXEDTYPE_STATIC( C++ class, C class )_CLASS_GENERIC_CLASS_GENERIC( C++ class, C class )_CLASS_GOBJECT_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )_CLASS_GTKOBJECT_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )_CLASS_GTKOBJECT()_CLASS_INTERFACE_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )_CLASS_OPAQUE_COPYABLE_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, copy function, free function )_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, ref function, unref function )_CLASS_OPAQUE_REFCOUNTED_CTOR_DEFAULT_DEFS()_IGNORE()_IGNORE(C function name 1, C function name2, etc)_MEMBER_GET / _MEMBER_SET_MEMBER_GET(C++ name, C name, C++ type, C type)_MEMBER_GET(x, x, int, int)_MEMBER_GET_GOBJECT / _MEMBER_SET_GOBJECT_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)_MEMBER_GET_PTR / _MEMBER_SET_PTR_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)_MEMBER_SET(C++ name, C name, C++ type, C type)_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)_PINCLUDE()_WRAP_CTOR_WRAP_ENUM_WRAP_GERROR_WRAP_METHOD_WRAP_METHOD( C++ method signature, C function name)_WRAP_METHOD_DOCS_ONLY_WRAP_METHOD_DOCS_ONLY(C function name)_WRAP_PROPERTY_WRAP_PROPERTY(C property name, C++ type)_WRAP_SIGNAL_WRAP_SIGNAL( C++ signal handler signature, C signal name)adj.value_changed.connect(sigc::bind&lt;Widget*&gt;(sigc::mem_fun(*this,
    &amp;cb_rotate_picture), picture));adjustment-&gt;changed();and connect it to the scale widget's adjustment like this:and thenbinding_namebindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);boolbool DemoWindow::select_function(
    const Glib::RefPtr&lt;Gtk::TreeModel&gt;&amp; model,
    const Gtk::TreeModel::Path&amp; path, bool)
{
  const Gtk::TreeModel::iterator iter = model-&gt;get_iter(path);
  return iter-&gt;children().empty(); // only allow leaf nodes to be selected
}bool ExampleWindow::on_button_press_event(GdkEventButton* event)
{
  if( (event-&gt;type == GDK_BUTTON_PRESS) &amp;&amp;
      (event-&gt;button == 3) )
  {
    m_Menu_Popup-&gt;popup(event-&gt;button, event-&gt;time);
    return true; //It has been handled.
  }
  else
    return false;
}bool myarea::on_expose_event(GdkEventExpose* ev)
{
Glib::RefPtr&lt;Gdk::Pixbuf&gt; image = Gdk::Pixbuf::create_from_file("myimage.png");
image-&gt;render_to_drawable(get_window(), get_style()-&gt;get_black_gc(),
0, 0, 100, 80, image-&gt;get_width(), image-&gt;get_height(), // draw the whole image (from 0,0 to the full width,height) at 100,80 in the window
Gdk::RGB_DITHER_NONE, 0, 0);
return true;
}buttons examplecairocairommcell.property_editable() = true;class HelloWorld : public Gtk::Window
{

public:
  HelloWorld();
  virtual ~HelloWorld();

protected:
  //Signal handlers:
  virtual void on_button_clicked();

  //Member widgets:
  Gtk::Button m_button;
};class ModelColumns : public Gtk::TreeModelColumnRecord
{
public:

  ModelColumns()
    { add(m_col_text); add(m_col_number); }

  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_text;
  Gtk::TreeModelColumn&lt;int&gt; m_col_number;
};

ModelColumns m_Columns;class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();

protected:
    Gtk::RadioButton m_rb1, m_rb2, m_rb3;
};

RadioButtons::RadioButtons()
  : m_rb1("button1"),
    m_rb2("button2"),
    m_rb3("button3")
{
    Gtk::RadioButton::Group group = m_rb1.get_group();
    m_rb2.set_group(group);
    m_rb3.set_group(group);
}class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();
};

RadioButtons::RadioButtons()
{
    Gtk::RadioButton::Group group;
    Gtk::RadioButton *m_rb1 = Gtk::manage(
      new Gtk::RadioButton(group,"button1"));
    Gtk::RadioButton *m_rb2 = manage(
      new Gtk::RadioButton(group,"button2"));
      Gtk::RadioButton *m_rb3 = manage(
        new Gtk::RadioButton(group,"button3"));
}clickedconfigure.acconstversioncontext-&gt;save();
context-&gt;translate(x, y);
context-&gt;scale(width / 2.0, height / 2.0);
context-&gt;arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
context-&gt;restore();deprecateddisplay_message("Getting ready for i18n.");display_message(_("Getting ready for i18n."));doubleenterenumserrthrowevent_box.add(child_widget);flags: Used only for drag and drop, this specifies whether the data may be dragged to other widgets and applications, or only to the same ones.foo.add( (w=new Gtk::Label("Hello"), w-&gt;set_manage(), &amp;w) );foo.add( manage(new Gtk::Label("Hello")) );functionsg++ simple.cc -o simple `pkg-config gtkmm-2.4 --cflags --libs`gbooleangchar*gdk-pixbufgdoublegettext manualgintglibgnomemm_hellogtk.defsgtk_enums.defsgtk_methods.defsgtk_signals.defsgtk_vfuncs.defsgtkmmgtkmm-2.4 is the name of the current stable API. There was an older API called gtkmm-2-0 which installs in parallel when it is available. There are several versions of gtkmm-2.4, such as gtkmm 2.10. Note that the API name does not change for every version because that would be an incompatible API and ABI break. Theoretically, there might be a future gtkmm-3.0 API which would install in parallel with gtkmm-2.4 without affecting existing applications.gtkmm_helloguintgunicharinfo: An identifier which will be sent to your signals to tell you which TargetEntry was used.intint main(int argc, char** argv)
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  Gtk::Main::run(helloworld);

  return 0;
}intltool-update --potis the same aslabel.set_text(compose(_("Really delete %1 now?"), filename));leavelib_LTLIBRARIESlibsigc++ 2.0m4 Conversionsm_TextView.add_child_at_anchor(m_Button, refAnchor);m_TreeView.append_column("Messages", m_Columns.m_col_text);m_TreeView.set_model(m_refListStore);m_box.pack_start(m_Button1);
m_box.pack_start(m_Button2);m_button1.signal_clicked().connect( sigc::mem_fun(*this,
  &amp;HelloWorld::on_button_clicked) );m_combo.set_entry_text_column(m_columns.m_col_name);m_combo.signal_changed().connect( sigc::mem_fun(*this,
      &amp;ExampleWindow::on_combo_changed) );m_frame.add(m_box);m_rb2.set_group(m_rb1.get_group()); //doesn't workm_refActionGroup = Gtk::ActionGroup::create();

m_refActionGroup-&gt;add( Gtk::Action::create("MenuFile", "_File") );
m_refActionGroup-&gt;add( Gtk::Action::create("New", Gtk::Stock::NEW),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_new) );
m_refActionGroup-&gt;add( Gtk::Action::create("ExportData", "Export Data"),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_open) );
m_refActionGroup-&gt;add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_quit) );m_refTreeSelection-&gt;set_select_function( sigc::mem_fun(*this,
    &amp;DemoWindow::select_function) );modules = [ 'gtkmm', ]moduleset = 'gnome-2.30'no_default_handlerobjects (GObjects, widgets, interfaces, boxed-types and plain structs)orpkg-configpressedpropertiesrefBuffer-&gt;apply_tag(refTagMatch, iterRangeStart, iterRangeStop);refClipboard-&gt;request_contents("example_custom_target",
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_received) );refClipboard-&gt;request_targets( sigc::mem_fun(*this,
    &amp;ExampleWindow::on_clipboard_received_targets) );refTreeSelection-&gt;selected_foreach_iter(
    sigc::mem_fun(*this, &amp;TheClass::selected_row_callback) );

void TheClass::selected_row_callback(
    const Gtk::TreeModel::iterator&amp; iter)
{
  TreeModel::Row row = *iter;
  //Do something with the row.
}refTreeSelection-&gt;set_mode(Gtk::SELECTION_MULTIPLE);refTreeSelection-&gt;signal_changed().connect(
    sigc::mem_fun(*this, &amp;Example_StockBrowser::on_selection_changed)
);refreturnreleasedrow[m_Columns.m_col_text] = "sometext";signalssrc/main.cc
src/other.ccstd::cout &lt;&lt; _("Current amount: ") &lt;&lt; amount
          &lt;&lt; _(" Future: ") &lt;&lt; future &lt;&lt; std::endl;

label.set_text(_("Really delete ") + filename + _(" now?"));std::ostringstream output;
output.imbue(std::locale("")); // use the user's locale for this stream
output &lt;&lt; percentage &lt;&lt; " % done";
label-&gt;set_text(Glib::locale_to_utf8(output.str()));std::stringstd::string uses 8 bit per character, but 8 bits aren't enough to encode languages such as Arabic, Chinese, and Japanese. Although the encodings for these languages has now been specified by the Unicode Constortium, the C and C++ languages do not yet provide any standardised Unicode support. GTK+ and GNOME chose to implement Unicode using UTF-8, and that's what is wrapped by Glib::ustring. It provides almost exactly the same interface as std::string, along with automatic conversions to and from std::string.std::vector&lt;Gtk::RecentInfo&gt; info_list = recent_manager-&gt;get_items();target: A name, such as "STRING"translator-creditstypedef Gtk::TreeModel::Children type_children; //minimise code length.
type_children children = refModel-&gt;children();
for(type_children::iterator iter = children.begin();
    iter != children.end(); ++iter)
{
  Gtk::TreeModel::Row row = *iter;
  //Do something with the row - see above for set/get.
}vfuncsvfuncs (function pointer member fields in structs), written by hand.void ExampleWindow::on_button_delete()
{
  Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
      m_treeview.get_selection();
  if(refTreeSelection)
  {
    Gtk::TreeModel::iterator sorted_iter =
        m_refTreeSelection-&gt;get_selected();
    if(sorted_iter)
    {
      Gtk::TreeModel::iterator iter =
          m_refModelSort-&gt;convert_iter_to_child_iter(sorted_iter);
      m_refModel-&gt;erase(iter);
    }
  }
}void ExampleWindow::on_clipboard_get(
    Gtk::SelectionData&amp; selection_data, guint info)
{
  const Glib::ustring target = selection_data.get_target();

  if(target == "example_custom_target")
    selection_data.set("example_custom_target", m_ClipboardStore);
}void ExampleWindow::on_clipboard_received(
    const Gtk::SelectionData&amp; selection_data)
{
  Glib::ustring clipboard_data = selection_data.get_data_as_string();
  //Do something with the pasted data.
}void ExampleWindow::on_clipboard_received_targets(
  const Glib::StringArrayHandle&amp; targets_array)
{
  // Get the list of available clipboard targets:
  std::list&lt;std::string&gt; targets = targets_array;

  const bool bPasteIsPossible =
    std::find(targets.begin(), targets.end(),
      example_target_custom) != targets.end();

  // Enable/Disable the Paste button appropriately:
  m_Button_Paste.set_sensitive(bPasteIsPossible);
}void Gtk::Table::attach(Gtk::Widget&amp; child,
                        guint left_attach, guint right_attach,
                        guint top_attach, guint bottom_attach,
                        guint xoptions = Gtk::FILL | Gtk::EXPAND,
                        guint yoptions = Gtk::FILL | Gtk::EXPAND,
                        guint xpadding = 0, guint ypadding = 0);void cb_rotate_picture (Gtk::Widget *picture)
{
  picture-&gt;set_rotation (adj-&gt;value);
...void doSomething(Cairo::RefPtr&lt;Cairo::Context&gt; context, int x)
{
    context-&gt;save();
    // change graphics state
    // peform drawing operations
    context-&gt;restore();
}void drag_dest_set(const ArrayHandle_TargetEntry&amp; targets,
    GtkDestDefaults flags, GdkDragAction actions);void drag_source_set(const ArrayHandle_TargetEntry&amp; targets,
      GdkModifierType start_button_mask, GdkDragAction actions);void pack_start(Gtk::Widget&amp; child,
                PackOptions options = PACK_EXPAND_WIDGET,
                guint padding = 0);where <literal>percentage</literal> is a number, from 0 to 1, indicating what fraction of the bar should be filled.where <parameter>condition</parameter> is as specified above. As usual the slot is created with <function>sigc::mem_fun()</function> (for a member method of an object.), or <function>sigc::ptr_fun()</function> (for a function).wrap_init_flagsxgettext -a -o my-strings --omit-header *.cc *.hProject-Id-Version: gtkmm-documentation master
Report-Msgid-Bugs-To: 
PO-Revision-Date: 2011-03-25 22:29+0100
Last-Translator: Bruno Brouard <annoa.b@gmail.com>
Language-Team: GNOME French Team <gnomefr@traduc.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8 bits
Plural-Forms: nplurals=2; plural=n>1;

    ...
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
    ...

  $ git clone git://git.gnome.org/mm-common
  $ cp -a mm-common/skeletonmm libsomethingmm

  _CLASS_INTERFACE(CellEditable,
                   GtkCellEditable,
                   GTK_CELL_EDITABLE,
                   GtkCellEditableIface)

  _CLASS_INTERFACE(LoadableIcon,
                   GLoadableIcon,
                   G_LOADABLE_ICON,
                   GLoadableIconIface,
                   Icon,
                   GIcon)

 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+

# ./configure
# make
# make install

#include &lt;gtkmm/bin.h&gt;
#include &lt;gtkmm/stockid.h&gt;
_DEFS(gtkmm,gtk)
_PINCLUDE(gtkmm/private/bin_p.h)

namespace Gtk
{

class Button : public Bin
{
  _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
public:

  _CTOR_DEFAULT
  explicit Button(const Glib::ustring&amp; label, bool mnemonic = false);
  explicit Button(const StockID&amp; stock_id);

  _WRAP_METHOD(void set_label(const Glib::ustring&amp; label), gtk_button_set_label)

  ...

  _WRAP_SIGNAL(void clicked(), "clicked")

  ...

  _WRAP_PROPERTY("label", Glib::ustring)
};

} // espace de nom Gtk

#include &lt;gtkmm/button.h&gt;

class OverriddenButton : public Gtk::Button
{
protected:
    virtual void on_clicked();
}

void OverriddenButton::on_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;

// appeler la version de la classe de base de la fonction membre:
    Gtk::Button::on_clicked();
}

#include &lt;gtkmm/button.h&gt;

void on_button_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;
}

main()
{
    Gtk::Button button("Hello World");
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
}

#include &lt;gtkmm/button.h&gt;
class Foo
{
private:
  Gtk::Button theButton;
  // sera détruit en même temps que l'objet Foo
};

#include &lt;libsomething.h&gt;

int main(int, char**)
{
  something_init();

  std::cout &lt;&lt; get_defs(EXAMPLE_TYPE_SOMETHING)
            &lt;&lt; get_defs(EXAMPLE_TYPE_THING);
  return 0;
}

$ ./enum.pl /usr/include/gtk-2.0/gtk/*.h &gt; gtk_enums.defs

$ ./h2def.py /usr/include/gtk-2.0/gtk/*.h &gt; gtk_methods.defs

$ cd gtk/src
$ /usr/lib/glibmm-2.4/proc/gmmproc -I ../../tools/m4 --defs . button . ./../gtkmm

$ cd tools/extra_defs_gen
$ ./generate_extra_defs &gt; gtk_signals.defs

$ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
    d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
  done

// dans une classe qui hérite de Gtk::Window...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...paramétrer op...
op-&gt;run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);

// dans la fonction membre de la classe ExampleWindow...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...paramétrer op...
op-&gt;signal_done().connect(sigc::bind(sigc::mem_fun(*this, 
                &amp;ExampleWindow::on_printoperation_done), op));
// lancer op

// Dans une classe dérivée de Gtk::Window 
// avec m_refPageSetup et m_refSettings comme membres...
Glib::RefPtr&lt;Gtk::PageSetup&gt; new_page_setup = Gtk::run_page_setup_dialog(*this,
                                                      m_refPageSetup, m_refSettings);
m_refPageSetup = new_page_setup;

Button::Button(const Glib::ustring&amp; label, bool mnemonic)
:
  _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
{}

DerivedDialog* pDialog = 0;
builder-&gt;get_widget_derived("DialogBasic", pDialog);

DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                             const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject)
{
}

DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                             const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject),
  m_builder(builder),
  m_pButton(0)
{
  // Obtenir le bouton instancié par Glade 
  // et le connecter au gestionnaire de signal :
  m_builder-&gt;get_widget("quit_button", m_pButton);
  if(m_pButton)
  {
    m_pButton-&gt;signal_clicked().connect( sigc::mem_fun(*this,
                                   &amp;DerivedDialog::on_button_quit) );
  }
}

Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap = Gdk::Bitmap::create(window, data, width, height);

Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap2 = bitmap.

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Gdk::Bitmap* underlying = *refBitmap; // Erreur de syntaxe - ne compilera pas.

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap2 = refBitmap;

Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
int depth = refBitmap-&gt;get_depth();

Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                Gtk::Builder::create_from_file("basic.glade");

Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                Gtk::Builder::create_from_file(
                              "basic.glade",
                              "treeview_products");

Glib::RefPtr&lt;Gtk::PrintOperation&gt; op = Gtk::PrintOperation::create();
// ...configurer op...
op-&gt;set_export_filename("test.pdf");
Gtk::PrintOperationResult res = op-&gt;run(Gtk::PRINT_OPERATION_ACTION_EXPORT);

Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = m_TreeView.get_model();
if(refModel)
{
  int cols_count = refModel-&gt;get_n_columns();
  ...
}

Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_dynamic(refModel);
Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore2 =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_static(refModel);

Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore = Gtk::TreeStore::create(columns);
Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = refStore;

Glib::SignalProxy1&lt;bool, Gtk::DirectionType&gt; signal_focus()

Glib::SignalProxy3&lt;void, const Glib::ustring&amp;, int, int*&gt; signal_insert_text()


Gtk::Button* button = new Gtk::Button("exemple");
gtk_button_do_something_new(button-&gt;gobj());

Gtk::Button* pButton = new Gtk::Button("Test");

// faire quelque chose d'utile avec pButton

delete pButton;

Gtk::Dialog* pDialog = 0;
builder-&gt;get_widget("DialogBasic", pDialog);

Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Grande"));
button-&gt;set_tooltip_text("Grande brosse);
group_brushes-&gt;insert(*button);

Gtk::ToolItemGroup* group_brushes =
  Gtk::manage(new Gtk::ToolItemGroup("Brosses"));
m_ToolPalette.add(*group_brushes);

Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
{
  set_custom_tab_label("Onglet personnalisé");

  Gtk::HBox* hbox = new Gtk::HBox(false, 8);
  hbox-&gt;set_border_width(6);

  Gtk::Label* label = Gtk::manage(new Gtk::Label("Saisissez du texte : "));
  hbox-&gt;pack_start(*label, false, false);
  label-&gt;show();

  hbox-&gt;pack_start(m_Entry, false, false);
  m_Entry.show();

  return hbox;
}

void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
{
  Glib::ustring user_input = m_Entry.get_text();
  //...
}

GtkButton* cbutton = get_a_button();
Gtk::Button* button = Glib::wrap(cbutton);

GtkWidget* example_widget_new(int something, const char* thing)
{
        ExampleWidget* widget;
        widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
        example_widget_construct(widget, 
                                 "something", something,
                                 "thing", thing);
}

void example_widget_construct(ExampleWidget* widget,
                              int something,
                              const char* thing)
{
        //faire quelque chose qui utilise l'API privée:
        widget-&gt;priv-&gt;thing = thing;
        do_something(something);
}

GtkWidget* example_widget_new(int something, const char* thing)
{
        return g_object_new (EXAMPLE_TYPE_WIDGET,
                             "something", something, 
                             "thing", thing, NULL);
}

MyWidget::MyWidget()
{
  Gtk::Button* pButton = manage(new Gtk::Button("Test"));
  add(*pButton); //ajoute aButton à MyWidget
}

_CLASS_BOXEDTYPE(Color, GdkColor, NONE, gdk_color_copy, gdk_color_free)

_CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

_CLASS_GENERIC(AttrIter, PangoAttrIterator)

_CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)

_CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)

_CLASS_OPAQUE_COPYABLE(Region, 
                       GdkRegion,
                       gdk_region_new,
                       gdk_region_copy,
                       gdk_region_destroy)

_CLASS_OPAQUE_REFCOUNTED(Coverage, 
                         PangoCoverage, 
                         pango_coverage_new, 
                         pango_coverage_ref, 
                         pango_coverage_unref)

_CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')

_CONVERSION(`PrintSettings&amp;',`GtkPrintSettings*',__FR2P)
_CONVERSION(`const PrintSettings&amp;',`GtkPrintSettings*',__FCR2P)
_CONVERSION(`const Glib::RefPtr&lt;Printer&gt;&amp;',`GtkPrinter*',__CONVERT_REFPTR_TO_P($3))

_IGNORE(gtk_button_box_set_spacing, gtk_button_box_get_spacing,

_MEMBER_GET_GOBJECT(offscreen_pixmap, offscreen_pixmap, Gdk::Pixmap, GdkPixmap*)

_MEMBER_GET_PTR(vbox, vbox, VBox*, GtkWidget*)

_WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags)

_WRAP_ENUM(WindowType, GdkWindowType)

_WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

_WRAP_METHOD(void set_text(const Glib::ustring&amp; text), gtk_entry_set_text)

_WRAP_METHOD_DOCS_ONLY(gtk_container_remove)

_WRAP_PROPERTY("label", Glib::ustring)

_WRAP_SIGNAL(void clicked(),"clicked")

bool MyCallback() { std::cout &lt;&lt; "Hello World!\n" &lt;&lt; std::endl; return true; }

bool idleFunc();

bool input_callback(Glib::IOCondition condition);

bool on_button_press(GdkEventButton* event);
Gtk::Button button("label");
button.signal_button_press_event().connect(
                  sigc::ptr_fun(&amp;on_button_press) 
                                          );

button.signal_button_press_event().connect( 
                sigc::ptr_fun(&amp;on_mywindow_button_press), 
                false );

class ActionGroup : public Glib::Object
{
  _CLASS_GOBJECT(ActionGroup, GtkActionGroup,
                 GTK_ACTION_GROUP, Glib::Object, GObject)

protected:
  _WRAP_CTOR(ActionGroup(const Glib::ustring&amp; name = Glib::ustring()),
             gtk_action_group_new)

public:
  _WRAP_CREATE(const Glib::ustring&amp; name = Glib::ustring())

class Server
{
public:
  // mécanisme d'accès au signal :
  typedef sigc::signal&lt;void, bool, int&gt; type_signal_something;
  type_signal_something signal_something();

protected:
  type_signal_something m_signal_something;
};

Server::type_signal_something Server::signal_something()
{
  return m_signal_something;
}

example-widget.h:56: error: using typedef-name 'ExampleWidget' after 'struct'
../../libexample/libexamplemm/example-widget.h:34: error: 
           'ExampleWidget' has a previous declaration here
make[4]: *** [example-widget.lo] Error 1

example-widget.h:60: error: '_ExampleWidget ExampleWidget' 
     redeclared as different kind of symbol
../../libexample/libexamplemm/example-widget.h:34: error: 
previous declaration of 'typedef struct _ExampleWidget ExampleWidget'

if(bitmap)
{
  int depth = bitmap-&gt;get_depth().
}

m_button1.signal_clicked().connect( 
            sigc::bind&lt;Glib::ustring&gt;( 
                                 sigc::mem_fun(
                                               *this, 
                                               &amp;HelloWorld::on_button_clicked
                                              ),
                                 "bouton 1")
                                  );

my_connection.disconnect();

server.signal_something().connect(
  sigc::mem_fun(client, &amp;Client::on_server_something) );

sigc::connection  Glib::SignalIdle::connect(
                      const sigc::slot&lt;bool&gt;&amp; slot,
                      int priority = Glib::PRIORITY_DEFAULT_IDLE);

sigc::connection Glib::SignalInput::connect(
             const sigc::slot&lt;bool,Glib::IOCondition&gt;&amp; slot,
             int fd,
             Glib::IOCondition condition,
             int priority = Glib::PRIORITY_DEFAULT);

sigc::connection Glib::SignalTimeout::connect(
                         const sigc::slot&lt;bool&gt;&amp; slot,
                         unsigned int interval,
                         int priority = Glib::PRIORITY_DEFAULT);

sigc::signal&lt;void, bool, int&gt; signal_something;

sigc::signal&lt;void,int&gt;::iterator signal&lt;void,int&gt;::connect( const sigc::slot&lt;void,int&gt;&amp; );

std::list&lt; Glib::RefPtr&lt;Gdk::Pixmap&gt; &gt; listPixmaps;
Glib::RefPtr&lt;Gdk::Pixmap&gt; refPixmap = Gdk::Pixmap::create(window,
width, height, depth);
listPixmaps.push_back(refPixmap);

typedef struct _ExampleWidget ExampleWidget;

struct _ExampleWidget
{
  ...
};

virtual void on_button_clicked(Glib::ustring data);

void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
                           const Glib::RefPtr&lt;PrintOperation&gt;&amp; op)
{
  if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
    // avertir l'utilisateur
  else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
    // mettre à jour PrintSettings avec ceux de cette PrintOperation

  if (! op-&gt;is_finished())
    op-&gt;signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_printoperation_status_changed), op));
}

void ExampleWindow::on_printoperation_status_changed(
            const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; op)
{
  if (op-&gt;is_finished())
    // la tâche d'impression est terminée 
  else
    // obtenir l'état avec get_status() ou get_status_string()

  // mettre à jour l'UI
}

void init()
{
  // Définir le système des types g et la table Glib::wrap().
  Gtk::Main::init_gtkmm_internals();
  // Indiquer à la table Glib::wrap() les classes libsomethingmm.
  wrap_init();
}

void on_button_clicked();

class some_class
{
    void on_button_clicked();
};

some_class some_object;

main()
{
    Gtk::Button button;
    button.signal_clicked().connect( sigc::ptr_fun(&amp;on_button_clicked) );
    button.signal_clicked().connect( sigc::mem_fun(some_object,
                                     &amp;some_class::on_button_clicked) );
}

void on_insert_text(const Glib::ustring&amp; text, int length, int* position);

{
  Gtk::Button aButton;
  aButton.show();
  ...
  kit.run();
}
Colonnes « cachées »# keep this file sorted alphabetically, one language code per line
de
ja#include &lt;gtkmm.h&gt;#m4 _CONVERSION(`GSList*', `Glib::SListHandle&lt;Widget*&gt;', `$2($3, Glib::OWNERSHIP_NONE)')$ ./plug &amp;$ ./socket(En aparté : <application>GTK+</application> appelle ce mécanisme « signalisation » ; le regard avisé du lecteur ayant un certaine expérience des boîtes à outils d'interfaces utilisateur ne manquera pas de noter que cette même conception est souvent rencontrée sous l'appellation de « broadcaster-listener » (émetteur-récepteur) (comme dans l'architecture PowerPlant de Metrowerks pour le Macintosh). Cela fonctionne tout à fait de la même façon : on met en place des <literal>broadcasters</literal> (émetteurs), puis on y connecte des <literal>listeners</literal> (récepteurs) ; l'émetteur conserve une liste des objets qui l'écoutent, et quand quelqu'un donne un message à l'émetteur, il appelle tous les objets de sa liste avec le message. Dans <application>gtkmm</application>, les objets signaux jouent le rôle d'émetteurs et les connecteurs celui de récepteurs — en quelque sorte. Plus à ce sujet plus tard.)(en outre, vous devez avoir dans le dossier <literal>po</literal> des fichiers <literal>ja.po</literal> et <literal>de.po</literal> contenant respectivement la traduction japonaise et allemande)../docextract_to_xml.py -s /gnome/head/cvs/gtk+/gtk/ \
-s /gnome/head/cvs/gtk+/docs/reference/gtk/tmpl/ &gt; gtk_docs.xml
// crée ses propres ajustements
Gtk::TextView textview;
// utilise également l'ajustement nouvellement créé pour la barre de défilement
Gtk::VScrollbar vscrollbar (*(textview.get_vadjustment()));// note to translators: don't translate the "[noun]" part - it is
// just here to distinguish the string from another "jumps" string
text = strip(gettext("jumps[noun]"), "[noun]");//compiler error - no conversion from ustring to int.
int number = row[m_Columns.m_col_text];2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010<application>Gtk::Builder</application> vérifie qu'il ne s'agit pas d'un pointeur NULL et que l'élément graphique est du type attendu ; il affiche des avertissements sur la ligne de commande s'il y a de telles anomalies.<application>gtkmm</application> autorise le programmeur à contrôler la durée de vie (c'est-à-dire, la construction et la destruction) de tout élément graphique de la même manière que celle de n'importe quel objet C++. Cette polyvalence autorise, soit l'utilisation des opérateurs <literal>new</literal> et <literal>delete</literal> pour créer et détruire les objets de manière dynamique, soit l'utilisation de données membres de classes régulières (qui sont détruites automatiquement quand la classe est détruite), soit l'utilisation d'instances locales (qui sont détruites dès que l'instance est hors de portée). Certaines boîtes à outils GUI C++ n'offrent pas cette souplesse : elles restreignent le programmeur à un sous-ensemble des fonctionnalités de gestion mémoire du C++.<application>gtkmm</application> vous permet d'écrire du code en se servant des techniques habituelles du C++ telles que l'encapsulation, la dérivation et le polymorphisme. En tant que programmeur C++, vous avez probablement déjà perçu que ces possibilités conduisent à un code plus clair et mieux organisé.<application>gtkmm</application> fournit également la fonction membre <methodname>set_manage()</methodname> pour tous les éléments graphiques. Il est possible de l'utiliser pour obtenir le même résultat qu'avec <function>manage()</function>, mais c'est plus délicat :<application>gtkmm</application> et Win32Les applications <application>gtkmm</application> prennent facilement en charge plusieurs langues, y compris les langues non-européennes telles que le chinois et les langues s'écrivant de droite à gauche comme l'arabe. Une application <application>gtkmm</application> écrite et traduite de manière appropriée, utilise lors de son exécution la langue définie par l'environnement utilisateur.Les applications <application>gtkmm</application> sont constituées par des fenêtres comportant des éléments graphiques, comme des boutons ou des boîtes de texte. Dans certains autres systèmes, les éléments graphiques sont appelés « contrôles ». Pour chaque élément graphique dans les fenêtres d'une application, il existe un objet C++ dans le code de l'application. Il vous suffit donc d'appeler une fonction membre de la classe de l'élément graphique pour en modifier l'apparence.<application>gtkmm</application> dispose les éléments graphiques de manière hiérarchique en utilisant des <emphasis>conteneurs</emphasis>. Un élément graphique conteneur contient d'autres éléments graphiques. La plupart des éléments graphiques <application>gtkmm</application> sont des conteneurs. Fenêtres, onglets de bloc-notes et boutons sont tous des éléments graphiques conteneurs. Il existe deux sortes de conteneurs : les conteneurs mono-enfant, qui dérivent tous de la classe <classname>Gtk::Bin</classname> et les conteneurs multi-enfants qui héritent de la classe <classname>Gtk::Container</classname>. La plupart des éléments graphiques de <application>gtkmm</application> dérivent de la classe <classname>Gtk::Bin</classname>, y compris <classname>Gtk::Window</classname>.Les classes <application>gtkmm</application> ont été conçues dans l'optique de surdéfinitions ; elles comportent des fonctions membres virtuelles spécialement pensées pour être surdéfinies.<application>gtkmm</application> comparée à <application>Qt</application><application>gtkmm</application> fonctionne actuellement avec le <ulink url="http://mingw.org/">compilateur MingW/GCC3.4</ulink> et Microsoft Visual C++ 2005 ou supérieur (y compris l'édition express disponible gratuitement). Un <ulink url="ftp://ftp.gnome.org/pub/GNOME/binaries/win32/gtkmm">installeur</ulink> de gtkmm est disponible pour Microsoft Windows. Consultez <ulink url="http://live.gnome.org/gtkmm/MSWindows/"> http://live.gnome.org/gtkmm/MSWindows</ulink> pour des instructions sur son utilisation.Les développeurs inclinent à préférer <application>gtkmm</application> à Qt, car <application>gtkmm</application> fait les choses d'une façon plus proche du C++. Qt est né à une époque où le C++ et les bibliothèques standard n'étaient, ni normalisées, ni bien prises en charge par les compilateurs. Ainsi, nombre de choses, aujourd'hui dans la bibliothèque normalisée, sont en double, comme les conteneurs et des définitions de types. Plus significatif encore, Trolltech a modifié le langage C++ afin de fournir des signaux, de sorte que les classes Qt ne se marient pas facilement avec des classes non-Qt. <application>gtkmm</application> a été capable d'utiliser du C++ standard sans modification pour fournir des signaux sans modification du langage C++. Consultez la foire aux questions pour plus de précisions.<application>gtkmm</application> dispose de nombreux éléments graphiques pouvant être visuellement ajustés avec la souris ou le clavier, tels les éléments graphiques <classname>Range</classname> (décrits dans le paragraphe <link linkend="chapter-range-widgets">Éléments graphiques à plage de réglage</link>). Il existe également un petit nombre d'éléments graphiques qui n'affichent qu'une partie ajustable d'une zone plus grande, comme l'élément graphique <classname>Viewport</classname>. Tous ces éléments graphiques sont adossés à un objet <classname>Gtk::Adjustment</classname> pour définir cette part commune du comportement de leur API.Comparé à GTK+, avec l'utilisation des noms de fonctions préfixés et de nombreuses macros de forçage de type, <application>gtkmm</application> nécessite moins de code.<application>gtkmm</application> est un habillage (« wrapper ») C++ pour <ulink url="http://www.gtk.org/">GTK+</ulink>, une bibliothèque servant elle-même à créer des interfaces utilisateur graphique. <application>gtkmm</application> est sous licence LGPL : vous pouvez donc développer des logiciels ouverts, des logiciels libres ou même des logiciels commerciaux non-libres sans acheter de licence.<application>gtkmm</application> est un habillage<application>gtkmm</application> possède une sécurité améliorée pour la typologie des données ; le compilateur détecte donc des erreurs qui ne seraient apparues qu'au moment de l'exécution en C. L'utilisation de ces types spécifiques rend l'API plus claire puisque vous pouvez voir les types à utiliser à la simple lecture de la déclaration d'une fonction membre.<application>gtkmm</application> n'est pas une boîte à outils en C++ natif, mais un habillage C++ d'une boîte à outils en C. Cette séparation entre interface et implémentation a des avantages. Les développeurs <application>gtkmm</application> passent la majeure partie de leur temps à discuter de la manière dont <application>gtkmm</application> peut présenter l'API la plus claire, sans compromis délicat en raison d'obscurs détails techniques. Nous contribuons un peu aux fondements du code GTK+ sous-jacent, mais les codeurs en C, Perl et Python, etc. font de même. Ainsi GTK+ bénéficie d'une base d'utilisateurs plus large que n'aurait une boîte à outils spécifique à un langage — il y a plus d'implémentations, plus de développeurs, plus de testeurs et plus d'utilisateurs.<application>gtkmm</application> facilite la dérivation de nouveaux éléments graphiques par héritage à partir d'une classe d'élément graphique existante, soit par dérivation à partir d'un conteneur et en y ajoutant des éléments graphiques enfants, soit par dérivation d'un élément graphique simple en modifiant son comportement. Mais vous pouvez parfois trouver qu'il n'y a aucun point de départ convenable. Dans ce cas, vous pouvez implémenter un élément graphique de A à Z.<application>gtkmm</application> fournit un moyen simple pour gérer les documents récemment utilisés. Les classes impliquées dans cette fonctionnalité sont <classname>RecentManager</classname>, <classname>RecentChooserDialog</classname>, <classname>RecentChooserMenu</classname>, <classname>RecentChooserWidget</classname> et <classname>RecentFilter</classname>.<application>gtkmm</application> met à votre disposition quatre types basiques de boutons :<application>gtkmm</application> met à votre disposition les fonctions <function>manage()</function> et <methodname>add()</methodname> pour créer et détruire les éléments graphiques. Tout élément graphique, excepté la fenêtre principale, doit être ajouté ou empaqueté dans un conteneur pour être affiché. La fonction <function>manage()</function> marque l'élément graphique empaqueté de sorte que, lorsqu'il est ajouté dans un conteneur, ce conteneur devient responsable de sa destruction.Les gestionnaires de signaux <application>gtkmm</application> sont fortement typés, alors que le code C de <application>GTK+</application> vous autorise à connecter une fonction de rappel avec un nombre de paramètres erroné ou de mauvais type, déclenchant une erreur de segmentation lors de l'exécution. Et, contrairement à <application>Qt</application>, <application>gtkmm</application> réalise cela sans modifier le langage C++.<application>gtkmm</application> se sert de l'utilitaire <command>gmmproc</command> pour générer la plus grande partie de son code source, en utilisant les fichiers .defs définissant les API des bibliothèques fondées sur <classname>GObject</classname>. Il est donc facile de créer des habillages supplémentaires dans le style gtkmm pour les autres bibliothèques fondées sur glib/GObject.<application>gtkmm</application> utilise la bibliothèque libsigc++ pour implémenter les signaux. Voici un exemple de ligne de code qui connecte le signal « clicked » émis par un Gtk::Button à un gestionnaire de signal nommé « on_button_clicked » : <placeholder-1/><application>gtkmm</application> utilise un système d'empaquetage pour résoudre ces problèmes. Plutôt que de définir la position et la taille de chaque élément graphique dans la fenêtre, vous pouvez les disposer en rangées, en colonnes ou en tableaux. <application>gtkmm</application> dimensionne votre fenêtre automatiquement, selon la taille des éléments graphiques qu'elle contient. Les tailles des éléments graphiques sont, à leur tour, déterminées par la quantité de texte contenue ou bien par les tailles minimales ou maximales fixées de même que par les règles voulues pour le partage des espaces libres entre les jeux d'éléments graphiques. Vous pouvez parfaire la disposition en définissant les dimensions des remplissages et des valeurs de centrage pour chacun des éléments graphiques. <application>gtkmm</application> utilise ces informations pour redimensionner et repositionner chaque élément intelligemment et souplement quand l'utilisateur manipule la fenêtre.À l'origine <application>gtkmm</application> s'appelait « gtk-- » étant donné que GTK+ avait déjà un signe « + » dans le nom. Mais, comme « -- » n'est pas facilement indexé par les moteurs de recherche, le paquet logiciel a couramment été désigné par <application>gtkmm</application> et c'est ainsi que nous le désignerons dans la suite.Les classes d'éléments graphiques <application>gtkmm</application> ont des fonctions membres d'accès aux signaux, comme <methodname>Gtk::Button::signal_clicked()</methodname>, qui permettent de se connecter au gestionnaire de signal. Grâce à la souplesse de <application>libsigc++</application>, la bibliothèque utilisée par <application>gtkmm</application>, le gestionnaire de signal peut être n'importe quel type de fonction, mais vous souhaiterez probablement utiliser une fonction membre de la classe. Les programmeurs C de <application>GTK+</application> nomment souvent ces gestionnaires de signal « fonctions de rappel » (callback).<application>gtkmm</application>, comme la plupart des boîtes à outils GUI, est <emphasis>piloté par événements</emphasis>. Lorsqu'un événement survient, comme un clic de bouton de souris, le signal approprié est <emphasis>émis</emphasis> par l'élément graphique pointé. Chaque élément graphique dispose d'un jeu de signaux à émettre. Pour qu'un clic de bouton se traduise par une action, nous mettons en œuvre un <emphasis>gestionnaire de signal</emphasis> pour capturer le signal « clicked » du bouton.Le script <application>intltool</application> / <application>xgettext</application> extrait les chaînes et les place dans un fichier <filename>mon_paquet.pot</filename>. Les traducteurs de votre application créent leur traduction en faisant d'abord une copie du fichier <filename>.pot</filename> dans un fichier <filename>nom_de_locale.po</filename>. Une « locale » identifie une langue et un codage pour cette langue, y compris les formats numériques et de date. Ultérieurement, si le texte de votre code source a été modifié, le script <literal>msmerge</literal> sera utilisé pour mettre à jour les fichiers <filename>nom_de_locale.po</filename> à partir d'une nouvelle génération du fichier <filename>.pot</filename>.Les <classname>ButtonBox</classname> donnent une apparence homogène aux applications en utilisant des réglages normalisés pour l'espacement entre boutons et pour l'empaquetage.<classname>Glib::ListHandle&lt;Gtk::Widget*&gt;</classname> : utilisez <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.<classname>Glib::RefPtr</classname> est un pointeur intelligent. Plus précisément, c'est un pointeur intelligent à décompte de références. Vous connaissez déjà peut-être le <literal>std::auto_ptr&lt;&gt;</literal>, qui est aussi un pointeur intelligent, mais <literal>Glib::RefPtr&lt;&gt;</literal> est plus simple et plus utile. Nous espérons qu'une future version de la Bibliothèque Standard C++ contiendra un pointeur partagé intelligent à décompte de références ; une future version de <application>gtkmm</application> pourrait alors l'utiliser à la place.<classname>Glib::SListHandle&lt;Gtk::Widget*&gt;</classname> : utilisez <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.<classname>Glib::StringArrayHandle</classname> ou <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname> : utilisez <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <literal>const char*[]</literal>, etc.Les <classname>Grid</classname> (grille) vous permettent de disposer des éléments graphiques dans une grille. La grille agence de manière dynamique les éléments graphiques enfants donc les dimensions de la grille n'ont pas besoin d'être indiquée dans le constructeur.<classname>Gtk::Builder</classname> doit être utilisé avec un pointeur <classname>Glib::RefPtr</classname>. Comme toutes les classes de ce type, vous aurez besoin de faire appel à la fonction membre <methodname>create()</methodname> pour en créer un exemplaire. Par exemple, <placeholder-1/> Ceci va initialiser la fenêtre définie dans le fichier .glade, même si elle n'est pas immédiatement affichée à moins que vous ayez défini cette action par l'intermédiaire de la fenêtre <guilabel>Propriétés</guilabel> dans <application>Glade</application>.<classname>Gtk::Button</classname> est aussi un conteneur ; vous pouvez donc y mettre n'importe quel autre élément graphique à l'intérieur, comme une <classname>Gtk::Image</classname>.La classe <classname>Gtk::CheckButton</classname> hérite de la classe <classname>Gtk::ToggleButton</classname>. La seule réelle différence entre les deux classes se situe au niveau de l'aspect graphique du <classname>Gtk::CheckButton</classname>. Vous obtenez, définissez et inversez son état à l'aide des mêmes fonctions membres que <classname>Gtk::ToggleButton</classname>.L'objet <classname>Gtk::Clipboard</classname> est un singleton. Vous ne pourrez en obtenir qu'une seule et unique instance avec <methodname>Gtk::Clipboard::get()</methodname>.<classname>Gtk::Grid</classname> disposent respectivement leurs éléments graphiques enfants en lignes et en colonnes. Utilisez <methodname>attach()</methodname>, <methodname>attach_next_to()</methodname> et <methodname>add()</methodname> pour insérer des éléments graphiques enfants.Les classes <classname>Gtk::Scale</classname> et <classname>Gtk::Scrollbar</classname> dérivent toutes deux de <classname>Gtk::Range</classname>, elles partagent un grand nombre de fonctionnalités. Elles comportent une « glissière » (ou « coulisse ») et un « curseur » (quelquefois nommé « molette » dans d'autres environnements GUI). Vous déplacez le curseur dans la glissière en le faisant glisser à l'aide du pointeur de souris ; si vous cliquez dans la glissière, le curseur avance vers l'endroit cliqué, soit directement, soit d'un pas donné, selon le bouton de souris utilisé. C'est le comportement habituel des barres de défilement.Les éléments graphiques de la classe <classname>Gtk::Scale</classname> (« coulisses », « glissières ») permettent à l'utilisateur de sélectionner et manipuler visuellement une valeur dans une plage donnée. Vous les utilisez, par exemple, pour ajuster le niveau de zoom de l'aperçu d'une image, pour contrôler la luminosité d'une couleur ou bien pour définir le nombre de minutes d'inactivité avant le déclenchement de l'économiseur d'écran.<classname>Gtk::Table</classname> place ses éléments graphiques sur une grille. Utilisez <methodname>attach()</methodname> pour insérer les éléments graphiques.Les objets <classname>Gtk::TargetEntry</classname> contiennent ces informations : <placeholder-1/><classname>Gtk::TextBuffer</classname> est un modèle contenant les données pour <classname>Gtk::TextView</classname>, tout comme <classname>Gtk::TreeModel</classname> utilisé par <classname>Gtk::TreeView</classname>. Cela permet à deux <classname>Gtk::TextView</classname> ou plus de partager le même <classname>TextBuffer</classname> tout en étant affichés de façon légèrement différente. Ou bien encore, vous pouvez disposer de plusieurs <classname>Gtk::TextBuffer</classname> et choisir d'afficher dans le même élément graphique <classname>Gtk::TextView</classname> le contenu de l'un ou l'autre d'entre eux selon les circonstances.<classname>Gtk::TextView</classname> dispose de diverses fonctions membres <methodname>scroll_to_*()</methodname>. Elles vous permettent de vous assurer qu'une zone donnée du texte du tampon est visible. Ainsi, la fonctionnalité Rechercher de votre application pourra utiliser la fonction membre <methodname>Gtk::TextView::scroll_to_iter()</methodname> pour afficher le texte trouvé.<classname>Gtk::ToggleButton</classname> est de grande utilité en tant que classe de base pour les classes <classname>Gtk::CheckButton</classname> et <classname>Gtk::RadioButton</classname>.Les éléments <classname>Gtk::ToolItem</classname> sont ensuite ajoutés au groupement. Ainsi :<classname>Gtk::TreeModel</classname> fournit un conteneur dans le style de la bibliothèque standard C++ pour ses enfants par l'intermédiaire de la fonction membre <methodname>children()</methodname>. Vous pouvez utiliser les fonctions membres habituelles <methodname>begin()</methodname> et <methodname>end()</methodname> pour incrémenter un itérateur, comme ceci :Les modèles <classname>Gtk::TreeStore</classname> peuvent avoir des éléments enfants. Pour les ajouter, servez-vous des fonctions membres <methodname>append()</methodname>, <methodname>prepend()</methodname> ou <methodname>insert()</methodname>, ainsi : <classname>Gtk::TreeView</classname> implémente déjà le simple glisser-déposer lorsqu'on l'utilise avec des modèles <classname>Gtk::ListStore</classname> ou <classname>Gtk::TreeStore</classname>. Mais, si nécessaire, il vous permet d'implémenter des comportements plus complexes lorsque les éléments sont glissés et déposés en utilisant l'API classique du <link linkend="chapter-draganddrop">glisser-déposer</link>.<classname>Gtk::VBox</classname> et <classname>Gtk::HBox</classname> disposent respectivement leurs éléments graphiques enfants verticalement et horizontalement. Utilisez <methodname>pack_start()</methodname> et <methodname>pack_end()</methodname> pour insérer des éléments graphiques enfants.<classname>Gtk::Widget</classname> dispose de plusieurs fonctions membres et signaux préfixés par « drag_ » qui sont utilisés pour le glisser-déposer.Normalement, les menus sont seulement ajoutés à une fenêtre, mais ils peuvent aussi être temporairement affichés lors d'un clic de souris. Par exemple, un menu contextuel peut s'afficher si l'utilisateur clique sur un élément avec le bouton droit de la souris.<classname>MessageDialog</classname> est une classe de commodité, utilisée pour créer des boîtes de dialogues destinées à des messages standards simples ; elles comportent un message, une icône et des boutons pour la réponse de l'utilisateur. Vous pouvez définir le type de message et le texte à afficher dans le constructeur, de même que les boutons standards à utiliser par l'intermédiaire de l'énumération <literal>Gtk::ButtonsType</literal>.À leur création, les objets de la classe <classname>RadioButtons</classname> sont « inactifs », donc, lors de la création du groupe, tous les boutons sont désactivés. N'oubliez donc pas d'en activer un avec <methodname>set_active()</methodname> :Les éléments graphiques <classname>Range</classname> connectent habituellement à ce signal un gestionnaire qui modifie leur apparence pour refléter le changement — par exemple, la taille du curseur dans une barre de défilement va croître ou diminuer en proportion inverse de la différence entre les valeurs <parameter>lower</parameter> et <parameter>upper</parameter> de son <classname>Adjustment</classname>.<classname>RecentChooser</classname> est une interface pouvant être implémentée par les éléments graphiques affichant la liste des fichiers récemment utilisés. <application>gtkmm</application> met à votre disposition trois implémentations intégrées pour le choix des fichiers récents : <classname>RecentChooserWidget</classname>, <classname>RecentChooserDialog</classname> et <classname>RecentChooserMenu</classname>.<classname>RecentChooserWidget</classname> est un simple élément graphique pour un affichage de la liste des fichiers récemment utilisés. <classname>RecentChooserWidget</classname> est l'élément de base de la classe <classname>RecentChooserDialog</classname>, mais vous pouvez l'incorporer dans votre interface utilisateur si vous le souhaitez.La classe <classname>RecentManager</classname> joue le rôle de base de donnée centrale des fichiers récemment utilisés. Vous utilisez cette classe pour enregistrer de nouveaux fichiers, enlever des fichiers de la liste ou rechercher les fichiers récemment utilisés.Les éléments graphiques de la classe <classname>Scale</classname> peuvent afficher la valeur correspondant à la position actuelle du curseur sous forme d'un nombre près de la glissière. C'est le comportement par défaut, mais vous pouvez modifier ce dernier avec la fonction membre <methodname>set_draw_value()</methodname>.Les éléments graphiques <classname>ScrolledWindow</classname> créent une zone qu'il est possible de faire défiler. Vous pouvez insérer n'importe quel type d'élément graphique dans une fenêtre de la classe <classname>ScrolledWindow</classname> ; cet élément graphique restera totalement accessible quelle que soit sa taille grâce aux barres de défilement. Notez que la classe <classname>ScrolledWindow</classname> ne dérive pas de la classe <classname>Gtk::Window</classname>, même si les dénominations peuvent prêter à confusion.Un objet <classname>SpinButton</classname> utilise un objet <link linkend="chapter-adjustment">Ajustement</link> pour mémoriser l'information sur la plage des valeurs permises. Le compteur utilise les attributs de l'objet Adjustment comme suit : <placeholder-1/>Les itérateurs du <classname>TextBuffer</classname> sont généralement invalidés si le texte est modifié ; mais, vous pouvez utiliser un objet <classname>Gtk::TextBuffer::Mark</classname> pour mémoriser une position dans ces cas-là. Par exemple :<classname>TextView</classname> dispose de diverses fonctions membres vous permettant de changer la présentation du contenu du tampon dans cette vue. Certaines peuvent être surdéfinies par les objets <classname>Gtk::TextTag</classname> dans le tampon, si elles définissent les mêmes choses. Par exemple, <methodname>set_left_margin()</methodname>, <methodname>set_right_margin()</methodname>, <methodname>set_indent()</methodname>, etc.Un objet de la classe <classname>ToggleButton</classname> est semblable à un objet de la classe <classname>Button</classname>, mais les boutons bascules restent activés, ou enfoncés, jusqu'à ce qu'ils soient à nouveau cliqués. Ajoutez un <classname>ToolItemGroup</classname> à une palette d'outils par l'intermédiaire de la fonction membre <function>Gtk::Container::add()</function> de la classe de base. Comme ceci :Les <classname>éléments graphiques</classname> sont identifiés en tant que sources ou destinations à l'aide des fonctions membres <classname>Gtk::Widget</classname> suivantes :<command>gmmproc</command> émet un avertissement sur stdout à propos des fonctions que vous avez oubliées d'habiller, pour vous aider à être sûr d'avoir bien habillé la totalité de l'API. Mais si vous ne voulez pas habiller certaines fonctions ou si vous avez choisi de coder à la main certaines fonctions membres, vous pouvez alors utiliser la macro  _IGNORE() pour que <command>gmmproc</command> arrête de se plaindre.<filename>libsomething</filename> : contient le fichier include principal et le fichier pkg-config .pc.<filename>libsomethingmm</filename> : contient les fichiers .h et .cc générés et écrits à la main.<filename>libsomethingmm</filename> : le répertoire de plus haut niveau.<filename>private</filename> : contient les fichiers générés <filename>*_p.h</filename>.<filename>src</filename> : contient les fichiers source .hg et .ccg.<function>_WRAP_METHOD()</function>, <function>_WRAP_SIGNAL()</function> et <function>_WRAP_PROPERTY()</function><function>sigc::bind()</function> n'est pas d'usage courant, mais peut-être le trouverez-vous commode parfois. Si vous êtes un familier de la programmation avec <application>GTK+</application>, vous avez alors probablement noté la similitude avec les paramètres supplémentaires  <literal>gpointer data</literal> que toutes les fonctions de rappel possèdent. Généralement, cette possibilité est utilisée à l'excès dans <application>GTK+</application> pour passer des informations qui devraient être stockées dans une donnée membre d'un élément graphique dérivé, mais la dérivation des éléments graphiques est très difficile en C. Nous avons beaucoup moins besoin de cette façon de faire dans <application>gtkmm</application>.<function>sigc::ptr_fun()</function> génère un objet <classname>sigc::slot</classname>. Un connecteur est un objet qui ressemble et réagit comme une fonction, mais qui, en réalité, est bien un objet. Il est également connu sous le nom d'objet fonction ou « functor ». <function>sigc::ptr_fun()</function> génère un connecteur pour une fonction autonome ou une fonction membre statique. <function>sigc::mem_fun()</function> génère un connecteur pour une fonction membre d'une instance donnée.<literal>$3</literal> sera remplacé par le nom du paramètre lorsque cette conversion est utilisée par gmmproc.<literal>Gtk::UPDATE_CONTINUOUS</literal> — C'est la valeur par défaut. Le signal <literal>value_changed</literal> est émis de manière continue, c'est-à-dire même si le curseur est déplacé d'une quantité infime.<literal>Gtk::UPDATE_DELAYED</literal> — Le signal <literal>value_changed</literal> n'est émis que lorsque l'utilisateur a relâché le bouton de la souris ou si la coulisse n'est pas déplacée pendant un court délai.<literal>Gtk::UPDATE_DISCONTINUOUS</literal> — Le signal <literal>value_changed</literal> n'est émis que lorsque le curseur n'est plus déplacé et que l'utilisateur a relâché le bouton de la souris.<literal>LINGUAS</literal> contient une liste triée alphabétiquement des codes identifiant toutes les langues dans lesquelles votre programme est traduit (les lignes de commentaires débutant par <literal>#</literal> sont ignorées). Chaque code de langue listé dans <literal>LINGUAS</literal> doit avoir un fichier <literal>.po</literal> correspondant. Ainsi, si votre programme a des traductions en allemand et en japonais, le fichier <literal>LINGUAS</literal> ressemblera à :<literal>PACK_EXPAND_PADDING</literal> : l'espace excédentaire est constitué de remplissage. Les éléments graphiques sont régulièrement espacés, mais leurs tailles ne varient pas — des espaces vides sont ménagés entre éléments graphiques.<literal>PACK_EXPAND_WIDGET</literal> : l'espace excédentaire est occupé par une augmentation de la taille des éléments graphiques enfants, sans modifier la répartition de l'espacement entre éléments graphiques.<literal>PACK_SHRINK</literal> : l'espace est condensé à la taille des éléments graphiques enfants. L'élément graphique prend la place qui lui est juste nécessaire et n'est jamais étiré.<literal>POTFILES.in</literal> est une liste des chemins vers tous les fichiers contenant des chaînes marquées pour la traduction, à partir du répertoire racine du projet. Ainsi, par exemple, si les sources du projet sont situées dans un sous-répertoire nommé <literal>src</literal> et si vous avez deux fichiers contenant des chaînes à traduire, votre fichier <literal>POTFILES.in</literal> ressemble à quelque chose comme :<literal>actions</literal> indique les actions de glisser-déposer que cette destination peut accepter — voir la description plus haut.<literal>actions</literal> est une combinaison de valeurs liées avec l'opérateur binaire OR ; elle précise les opérations de glisser-déposer possibles à partir de cette source — par exemple, copier, déplacer ou lier. L'utilisateur peut choisir le type d'opérations avec les touches modificatrices ; ainsi, <keycap>Maj</keycap> permet de transformer la « <literal>copie</literal> » en « <literal>déplacement</literal> » ; ce changement est indiqué par la modification de la forme du pointeur de souris.<literal>begin_print</literal> : vous devez gérer ce signal car c'est à cet instant que vous créez et définissez un objet <classname>Pango::Layout</classname> en utilisant le <classname>Gtk::PrintContext</classname> fourni et que vous y divisez la sortie d'impression en plusieurs pages.<literal>done</literal> : ce signal est émis quand l'impression est terminée, cela signifie que les données de l'impression ont été placées en file d'attente. Notez que la valeur <literal>Gtk::PrintOperationResult</literal> renvoyée peut indiquer qu'une erreur est survenue. Dans tous les cas, vous souhaiterez probablement avertir l'utilisateur du résultat final.<literal>drag_begin</literal> : fournit un objet DragContext.<literal>drag_data_received</literal> : fournit un objet <literal>info</literal> concernant le format des données glissées et une structure <literal>GtkSelectionData</literal> contenant les données déposées. Vous pouvez appeller la fonction membre <methodname>drag_finish()</methodname> sur l'objet <literal>DragContext</literal> pour savoir si l'opération a réussi ou non.<literal>drag_delete</literal> : offre à la source la possibilité de détruire les données initiales si c'est approprié.<literal>drag_drop</literal> : fournit un objet DragContext et les coordonnées.<literal>drag_end</literal> : fournit un objet DragContext.<literal>drag_get</literal> : fournit un objet <literal>info</literal> concernant le format des données glissées et une structure <literal>GtkSelectionData</literal> dans laquelle vous pouvez mettre les données requises.<literal>drag_motion</literal> : fournit un objet DragContext et les coordonnées. Vous pouvez appeler la fonction membre drag_status() de l'objet DragContext pour faire savoir les cibles acceptées.<literal>draw_page</literal> : vous devez gérer ce signal qui fournit un objet <classname>PrintContext</classname> et un numéro de page. L'objet <classname>PrintContext</classname> sera utilisé pour créer un <classname>Cairo::Context</classname> dans lequel la page donnée sera dessinée. Pour le rendu du texte, itérez sur le <classname>Pango::Layout</classname> que vous avez créé dans le gestionnaire du signal <literal>begin_print</literal>.<literal>end_print</literal> : un gestionnaire pour ce signal est une place sûre pour libérer les ressources relatives à <classname>PrintOperation</classname>. Si vous avez une classe personnalisée dérivée de <classname>PrintOperation</classname>, il est évidemment plus simple de faire cela dans le destructeur.<literal>flags</literal> est une combinaison de valeurs liées par l'opérateur binaire OR ; cette combinaison indique comment l'élément graphique répond visuellement aux éléments du glisser-déposer.<literal>lower</literal> : limite inférieure de la plage<literal>page_increment</literal> : valeur de l'incrément/de décrément lors d'un clic avec le bouton 2 de la souris sur une flèche du compteur<literal>page_size</literal> : inutilisé<literal>paginate</literal> : la pagination est en règle générale lente, donc si vous voulez la contrôler, vous pouvez appeler la fonction membre <methodname>PrintOperation::set_show_progress()</methodname> et gérer ce signal.<literal>request_page_setup</literal> : fournit un objet <classname>PrintContext</classname>, un numéro de page et un objet <classname>Gtk::PageSetup</classname>. Gérez ce signal si vous voulez modifier page par page les réglages de la page.<literal>start_button_mask</literal> est une combinaison de valeurs liées avec l'opérateur binaire OR ; ces valeurs définissent quelle touche modificatrice ou quel bouton de souris doit être pressé pour démarrer le glisser.<literal>status_changed</literal> : ce signal est émis chaque fois que l'état d'une tâche d'impression change jusqu'à ce qu'elle soit terminée. Appelez la fonction membre <methodname>PrintOperation::set_track_print_status()</methodname> pour contrôler l'état de la tâche après qu'elle a été placée en file d'attente. Pour afficher l'état, utilisez <methodname>get_status()</methodname> ou <methodname>get_status_string()</methodname>.<literal>step_increment</literal> : valeur de l'incrément/ du décrément lors d'un clic avec le bouton 1 de la souris sur une flèche du compteur<literal>targets</literal> est un conteneur pour éléments <classname>Gtk::TargetEntry</classname> (<classname>std::list&lt;Gtk::TargetEntry&gt;</classname> ou <classname>std::vector&lt;Gtk::TargetEntry&gt;</classname>, par exemple).<literal>upper</literal> : limite supérieure de la plage<literal>value</literal> : valeur initiale du compteur<methodname>Gtk::Widget::show()</methodname> fait savoir à <application>gtkmm</application> que vous avez terminé de définir les attributs de l'élément graphique et qu'il est prêt à être affiché. Vous pouvez utiliser <methodname>Gtk::Widget::hide()</methodname> pour le faire disparaître à nouveau. L'ordre dans lequel vous affichez les éléments graphiques n'a pas d'importance, mais nous suggérons de n'afficher qu'en dernier la fenêtre de plus haut niveau ; ainsi, la fenêtre globale apparaît en ayant tout son contenu déjà dessinée. Sinon, l'utilisateur voit d'abord une fenêtre vierge dans laquelle les éléments graphiques sont tracés progressivement.<methodname>child_type_vfunc()</methodname> : renvoie le type d'enfant pouvant être ajouté.<methodname>forall_vfunc()</methodname> : appelle la même fonction de rappel pour chaque enfant.<methodname>get_preferred_height_for_width_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur compte tenu de la largeur précisée.<methodname>get_preferred_height_for_width_vfunc()</methodname> : calcule la hauteur minimale naturelle de l'élément graphique compte tenu de la largeur précisée.<methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur.<methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle de l'élément graphique.<methodname>get_preferred_width_for_height_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur compte tenu de la hauteur précisée.<methodname>get_preferred_width_for_height_vfunc()</methodname> : calcule la largeur minimale naturelle de l'élément graphique compte tenu de la hauteur précisée.<methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur.<methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle de l'élément graphique.<methodname>get_request_mode_vfunc()</methodname> : (optionelle) renvoie quel est le <literal>Gtk::SizeRequestMode</literal> préféré par l'élément graphique.<methodname>get_request_mode_vfunc()</methodname> : renvoie quel est l'objet <literal>Gtk::SizeRequestMode</literal> préféré par le conteneur.<methodname>get_widget()</methodname> renvoie des éléments graphiques enfants marqués (voir le chapitre sur la <link linkend="chapter-memory">Gestion de la mémoire</link>) par la fonction <function>manage()</function> ; ils seront donc détruits quand leur conteneur parent sera détruit. Donc, si vous n'obtenez qu'un seul élément graphique de <application>Gtk::Builder</application>, au lieu de la totalité de la fenêtre, alors vous devez, soit le placer dans un objet <classname>Container</classname>, soit le détruire. Les objets <classname>Windows</classname> (tout comme les objets <classname>Dialogs</classname>) ne peuvent pas être gérés étant donné qu'ils n'ont pas de conteneur parent ; vous devez donc les détruire à un moment donné.<methodname>on_add()</methodname> : ajoute un élément graphique enfant dans le conteneur.<methodname>on_draw()</methodname> : trace sur l'objet <classname>Cairo::Context</classname> fourni.<methodname>on_map()</methodname>: (optionnelle)<methodname>on_realize()</methodname> : associe un objet <classname>Gdk::Window</classname> à l'élément graphique.<methodname>on_remove()</methodname> : supprime un élément graphique enfant du conteneur.<methodname>on_size_allocate()</methodname>, toutefois, reçoit les vraies hauteur et largeur que le conteneur parent a décidé de donner à l'élément graphique. Cela peut être plus que le minimum ou même plus que la taille naturelle, par exemple, si la fenêtre de haut niveau a été agrandie. Vous pouvez choisir d'ignorer l'espace supplémentaire et laisser la zone inoccupée, ou bien vous pouvez choisir d'agrandir vos éléments graphiques enfants pour remplir cet espace, ou bien encore vous pouvez choisir d'augmenter l'espace libre entre vos éléments graphiques. C'est votre conteneur, à vous de décider. N'oubliez pas d'appeler <methodname>set_allocation()</methodname> à l'intérieur de votre implémentation de <methodname>on_size_allocate()</methodname> pour utiliser effectivement l'espace alloué offert par le conteneur parent.<methodname>on_size_allocate()</methodname> : place les éléments graphiques enfants, compte tenu de la hauteur et de la largeur réellement attribuées au conteneur.<methodname>on_size_allocate()</methodname> : place l'élément graphique, compte tenu de la hauteur et de la largeur réellement attribuées.<methodname>on_unmap()</methodname>: (optionnelle)<methodname>on_unrealize()</methodname> : (optionnelle) détruit l'association avec l'objet <classname>Gdk::Window</classname>.Il se peut que la fonction membre <methodname>run()</methodname> renvoie <literal>PRINT_OPERATION_RESULT_IN_PROGRESS</literal>. Pour suivre l'état et gérer le résultat ou une erreur, vous devez implémenter des gestionnaires pour les signaux <literal>done</literal> et <literal>status_changed</literal> :<methodname>set_row_spacing()</methodname> et <methodname>set_col_spacing()</methodname> définissent l'espacement entre lignes ou entre colonnes pour la ligne ou la colonne indiquée. Notez que, pour les colonnes, l'espacement se situe à droite de la colonne et que, pour les lignes, l'espacement se situe sous la ligne.Les paramètres <parameter>xoptions</parameter> et <parameter>yoptions</parameter> s'utilisent pour définir les options d'empaquetage. Pour définir des options multiples, il convient de les lier entre elles avec l'opérateur binaire OR. Ces options sont :<placeholder-1/> (ou <placeholder-2/> pour les noms de fichiers)<placeholder-1/> Ici, le programmeur détruit pButton pour prévenir une fuite de mémoire.<placeholder-1/> Ainsi, quand des objets du type <classname>MyWidget</classname> sont détruits, le bouton est également détruit. Il n'est plus nécessaire à l'avenir de détruire pButton pour libérer la mémoire occupée par le bouton ; cette opération a été déléguée à l'objet <classname>MyWidget</classname>.Exemple de paquet logiciel <placeholder-1/><literal>GdkEventButton</literal> est une structure contenant les paramètres de l'événement, tels que les coordonnées du pointeur de souris et l'heure où le bouton a été pressé. Les structures <literal>GdkEvent</literal> sont différentes selon les événements.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. C'est le bouton classique, traditionnellement orné d'une étiquette ou d'une image. Le fait de le presser déclenche une action. Consultez le paragraphe <link linkend="sec-pushbuttons">Bouton</link>.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>. Elle agit comme un bouton-bascule, mais affiche son état dans un petit carré. L'étiquette est disposée sur son côté. Elle peut s'utiliser dans la plupart des situations où l'on doit définir un état actif/inactif. Consultez le paragraphe <link linkend="sec-checkboxes">Cases à cocher</link>.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>. Ainsi dénommé d'après le comportement des sélecteurs de stations sur les anciens autoradios, ce bouton s'utilise en groupe pour des choix mutuellement exclusifs. Presser sur l'un d'eux désélectionne tout autre bouton du groupe. Il ressemble à une case à cocher (petit élément graphique avec une étiquette sur le côté), mais il a généralement un aspect différencié. Consultez le paragraphe <link linkend="sec-radio-buttons">Bouton radio</link>.<ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>. Contrairement au précédent, qui se relève après avoir été pressé, un bouton bascule reste en position basse jusqu'à ce que vous le pressiez à nouveau. Il est utile en tant qu'interrupteur marche/arrêt. Consultez le paragraphe <link linkend="sec-toggle-buttons">Bouton bascule</link>.<varname>app_exec</varname> : la ligne de commande à utiliser pour atteindre cette ressource. Cette chaîne peut comporter les caractères d'échappement « f » et « u » ; ils seront respectivement développés sous forme du chemin d'accès à la ressource et de l'URI.<varname>app_name</varname> : le nom de l'application qui a enregistré la ressource.<varname>description</varname> : une courte description de la ressource sous forme d'une chaîne UTF-8.<varname>display_name</varname> : le nom de la ressource à utiliser pour l'affichage sous forme d'une chaîne UTF-8.<varname>groups</varname> : une liste des groupes associés à cet élément. Les groupes sont essentiellement des dénominations arbitraires associées à des ressources particulières. Ils peuvent être pensés en termes de « catégories » (telles que « courriel », « graphiques ») ou de marqueurs pour la ressource.<varname>is_private</varname> : indique si la ressource ne doit être visible que des applications qui l'ont enregistrée ou non.<varname>mime_type</varname> : le type MIME de la ressource.Un fichier .hg inclut habituellement certains fichiers d'en-tête, puis déclare une classe en utilisant certaines macros pour ajouter l'API ou certains comportements pour cette classe. Par exemple, <filename>button.hg</filename> de gtkmm ressemble grossièrement à ceci : <placeholder-1/>Une <classname>ComboBox</classname> peut contenir un élément graphique <classname>Entry</classname> afin de saisir un texte arbitraire en fixant à true (vrai) le paramètre <literal>has_entry</literal> du constructeur.Un élément graphique <classname>Entry</classname> peut offrir une liste déroulante de choix préétablis à partir des premiers caractères saisis par l'utilisateur. Par exemple, une boîte de dialogue de recherche peut suggérer un texte en fonction des recherches antérieures.L'objet <classname>Notebook</classname> est constitué d'un jeu de <literal>pages</literal> empilées, chacune contenant des éléments graphiques. Les onglets étiquetés permettent à l'utilisateur de choisir les pages. <classname>Notebook</classname> permet de placer plusieurs jeux d'éléments graphiques dans un espace réduit, mais en ne montrant qu'une seule page à la fois. Cet objet est souvent utilisé, par exemple, dans les boîtes de dialogue de préférences.Un objet <classname>Plug</classname> est une variété de fenêtre particulière qu'il est possible de greffer dans un objet <classname>Socket</classname>. Outre les propriétés et les fonctions membres habituelles de la classe <classname>Gtk::Window</classname>, l'objet <classname>Plug</classname> fournit un constructeur qui prend comme paramètre l'ID d'un objet <classname>Socket</classname> ; l'objet <classname>Plug</classname> va automatiquement s'incorporer dans l'objet <classname>Socket</classname> qui a l'ID correspondant.Par défaut, un objet <classname>ProgressBar</classname> est disposé horizontalement et le remplissage s'effectue de la gauche vers la droite, mais il est possible de disposer cette barre verticalement avec la fonction membre <methodname>set_orientation()</methodname>.Un objet <classname>RecentInfo</classname> est essentiellement un objet contenant toutes les métadonnées à propos d'un seul fichier récemment utilisé. Vous pouvez utiliser cet objet pour chercher l'une quelconque des propriétés listées ci-dessus. FIXME — ajouter les références croisées.Un objet <classname>Socket</classname> est une sorte d'élément graphique conteneur spécial qui autorise la possibilité d'incorporer des éléments graphiques d'un processus dans un autre de manière totalement transparente pour l'utilisateur.Un objet <classname>SpinButton</classname> permet à l'utilisateur de sélectionner une valeur à l'intérieur d'un segment de valeurs numériques. Il est constitué d'un contrôle saisie de texte avec des boutons flèche en haut et flèche en bas sur le côté. Le fait de cliquer sur un des boutons fait « tourner » la valeur affichée en l'incrémentant ou la décrémentant dans les limites de la plage des valeurs admises. Il est aussi possible de saisir directement une valeur dans l'élément <classname>Entry</classname>.L'objet <classname>ToolPalette</classname> est semblable à un objet <classname>Toolbar</classname>, mais il peut comporter un quadrillage d'éléments classés en groupements. L'utilisateur peut masquer ou développer chaque groupement. Comme dans une barre d'outils, les éléments sont affichés sous forme d'icônes uniquement, texte uniquement ou icônes avec texte.L'ajout d'un élément graphique enfant à un <classname>EventBox</classname> s'effectue avec :Un petit exemple suit. Pour vous servir de cet exemple, lancez-le à partir d'un terminal ; il ne crée pas de fenêtre. Il va créer un tube nommé <literal>testfifo</literal> dans le répertoire actuel. Puis, lancez un autre instance de terminal et saisissez <literal>echo "Hello" &gt; testfifo</literal>. Le terminal de l'exemple affiche chaque ligne saisie dans l'autre instance jusqu'à ce que vous saisissiez <literal>echo "Q" &gt; testfifo</literal>.Une des caractéristiques intéressantes de GLib (une des bibliothèques sous-jacentes à <application>gtkmm</application>) est la possibilité de demander la vérification des données d'un descripteur de fichier à votre intention. La chose est particulièrement utile pour les applications réseau. Pour cette vérification, vous utilisez la fonction membre :Une application correctement internationalisée ne doit pas faire de suppositions sur le nombre d'octets par caractère. Cela signifie que vous ne devez pas faire d'arithmétique de pointeurs pour cheminer parmi les caractères d'une chaîne ; cela signifie aussi que vous ne devez pas vous servir d'objets <classname>std::string</classname> ou de fonctions C standard telles que <function>strlen()</function> car elle se fondent sur de telles suppositions pour effectuer leurs calculs.Un pointeur intelligent se comporte plus ou moins comme un pointeur normal. Voici quelques exemples.Une cible peut se présenter sous des formats binaires divers. Ce chapitre, et ses exemples, supposent que les données sont du texte 8 bits. Cela vous permet d'utiliser un format XML pour les données du presse-papier. Toutefois ce format ne sera certainement pas approprié pour des données binaires comme les images. La classe <classname>Gtk::Clipboard</classname> autorise des sur-définitions permettant de spécifier le format de façon plus détaillée si nécessaire.AM_CPPFLAGSAM_CPPFLAGS = ... -DPROGRAMNAME_LOCALEDIR=\"${PROGRAMNAME_LOCALEDIR}\"AM_CXXFLAGSATKAccès aux éléments graphiquesActionsMode activitéajoutez <literal>INTLTOOL_FILES</literal> à la liste <literal>EXTRA_DIST</literal> de fichiers. Ceci assure que ces commandes seront incluses dans l'archive source quand vous effectuerez <command>make dist</command>.ajoutez <literal>po</literal> à la variable <literal>SUBDIRS</literal>. Sans cela, vos traductions ne seraient pas construites et installées lors de la construction du programme.ajoute des fonctions membres pour habiller des parties de l'API C.Ajoutez des lignes au modèle avec les fonctions membres <methodname>append()</methodname>, <methodname>prepend()</methodname> ou <methodname>insert()</methodname>.Ajout d'éléments à la liste des fichiers récentsAjout de lignesAjout de colonnes à la vueAjout de colonnes enfantsAjouter des propriétés en s'assurant qu'elles interagissent proprement entre elles est relativement difficile à corriger dans une bibliothèque C, mais c'est possible ; faites remonter un rapport d'anomalie avec si possible un correctif au mainteneur concerné.Ajout d'éléments graphiquesdes marqueurs additionnels en ligne de commande passés au script  <filename>generate_wrap_init.pl</filename>, tels que le nom de l'espace de noms C++ et le préfixe du répertoire parent des fichiers include.De plus, il est possible d'utiliser le bouton 3 de la souris pour sauter directement aux valeurs <literal>upper</literal> ou <literal>lower</literal>.À l'intérieur des ajustementsAjustementsAprès la création d'objets <classname>Socket</classname> ou <classname>Plug</classname>, vous pouvez obtenir leur ID avec la fonction <methodname>get_id()</methodname>. Cet ID peut ensuite être partagé avec d'autres processus afin que ces processus sachent comment se connecter les uns aux autres.Après avoir ajouté des lignes à ce modèle, intégrez le modèle dans l'objet <classname>ComboBox</classname> avec la fonction membre <methodname>set_model()</methodname>. Puis, servez-vous des fonctions membres <methodname>pack_start()</methodname> ou <methodname>pack_end()</methodname> pour définir les colonnes à afficher dans la boîte combinée. Comme avec une vue arborescente vous pouvez, soit utiliser le moteur de rendu par défaut en passant le <classname>TreeModelColumn</classname> aux fonctions membres d'empaquetage, soit créer un exemplaire particulier de <classname>CellRenderer</classname> en définissant une correspondance personnalisée avec <methodname>add_attribute()</methodname> ou <methodname>set_cell_data_func()</methodname>. Notez que ces fonctions membres font partie de la classe de base <classname>CellLayout</classname>.Après avoir construit et lancé ce programme, essayez de redimensionner la fenêtre pour voir son comportement. Également, essayez de jouer avec les options de la fonction membre <methodname>pack_start()</methodname> après avoir lu le paragraphe relatif aux <link linkend="sec-boxes">boîtes</link>.Après avoir tracé le pourtour, nous parcourons la circonférence du cadran et traçons des marques pour chaque heure, avec une marque plus importante pour midi, trois, six et neuf heures. Nous sommes maintenant prêts pour implémenter la fonctionnalité horloge de notre cadran : cela consiste à obtenir la valeur actuelle des heures, minutes et secondes et à tracer les aiguilles avec les angles adéquats.Après avoir incorporé ces lignes de code source dans <literal>simple.cc</literal>, vous pouvez compiler ce programme avec la commande : <placeholder-1/> Notez qu'il est impératif d'entourer l'appel à <literal>pkg-config</literal> d'apostrophes inverses. Elles demandent à l'interpréteur de commandes d'exécuter la commande entourée et d'intégrer au même emplacement la sortie correspondante dans la ligne de commande.Après avoir sélectionné l'élément de menu <guimenuitem>Boîte de dialogue fichiers récents</guimenuitem>, vous voyez quelque chose de semblable à la fenêtre ci-après.Après avoir défini le module correct, vous devez indiquer à <application>jhbuild</application> quel est ou quels sont les modules à construire. Pour construire <application>gtkmm</application> et toutes ses dépendances, paramétrez la variable <varname>modules</varname> ainsi : <placeholder-1/>Après avoir lancé <filename>socket</filename>, vous devriez voir les sorties suivantes sur le terminal :Après cette action, vous devriez voir s'afficher :Après avoir créé et réglé le filtre pour qu'il corresponde uniquement aux fichiers souhaités, vous pouvez appliquer le filtre à l'élément graphique de sélection avec la fonction <methodname>RecentChooser::add_filter()</methodname>.Après avoir terminé la création de votre chemin, vous n'avez encore dessiné rien de visible. Pour rendre le chemin visible, il faut utiliser la fonction <methodname>stroke()</methodname> qui dessine le tracé actuel avec une ligne d'épaisseur et de style précisés dans l'objet <classname>Cairo::Context</classname>. Après le traçage, le chemin actuel est effacé ; vous pouvez donc en débuter un nouveau.Après installation de toutes les dépendances, téléchargez le code source de <application>gtkmm</application>, extrayez-le et déplacez vous dans le nouveau répertoire. <application>gtkmm</application> se construit et s'installe en saisissant cette suite de commandes :Après avoir installé la version git de <application>gtkmm</application>, vous êtes prêt à commencer à l'utiliser et le tester. Pour utiliser la nouvelle version de <application>gtkmm</application> que vous venez d'installer, il est nécessaire de paramétrer certaines variables d'environnement pour que le script <filename>configure</filename> sache où trouver les nouvelles librairies. Fort heureusement, <application>jhbuild</application> offre une solution élégante à ce problème. L'exécution de la commande <command>jhbuild shell</command> ouvre un nouveau shell avec toutes les variables d'environnement correctement fixées. Maintenant si vous re-configurez et construisez votre projet comme vous avez l'habitude de faire, il fera l'édition des liens avec les bibliothèques nouvellement installées. Pour revenir dans votre environnement précédent, sortez simplement du shell <application>jhbuild</application>.AlignementTous les programmes <application>gtkmm</application> doivent inclure certains fichiers d'en-tête <application>gtkmm</application> ; <literal>gtkmm.h</literal> inclut la totalité du jeu d'en-têtes <application>gtkmm</application>. En règle générale, ce n'est pas une bonne idée parce que cette façon de faire inclut à peu près un mégaoctet d'en-têtes, mais pour des programmes simples, c'est acceptable.Tous les éléments conteneurs dérivent de la classe <classname>Gtk::Container</classname>, mais pas toujours directement. Quelques éléments conteneurs, tels que  <classname>Gtk::Table</classname>, peuvent incorporer plusieurs éléments graphiques enfants ; leur interface est donc bien évidemment plus complexe. D'autres, comme <classname>Gtk::Frame</classname>, ne comportent qu'un seul élément graphique enfant.Toutes les mentions de <varname>skeleton</varname> doivent être remplacées par le nom adéquat de la bibliothèque C que vous habillez, comme « something » ou « libsomething ». De la même manière, toutes les occurrences de <varname>SKELETON</varname> doivent être remplacées par « SOMETHING » ou « LIBSOMETHING » et celles de <varname>Skeleton</varname> par « Something ».En outre, la valeur peut être placée à diverses positions par rapport à la glissière ; la position se définit avec la fonction membre <methodname>set_value_pos()</methodname>.Autrement, si la liste complète des saisies possibles est trop grande ou trop délicate à produire, il est possible de définir l'emplacement d'une fonction de rappel à l'aide de la fonction membre <methodname>set_match_func()</methodname>, dont le paramètre est un pointeur sur la-dite fonction de rappel. Cela peut se révéler utile si vous souhaitez chercher une concordance sur une partie de chaîne littérale autre que son début.Sinon, vous pouvez confier au conteneur d'élément graphique le contrôle du moment où il sera détruit. Dans la plupart des cas, vous voulez qu'un élément graphique dure aussi longtemps que son conteneur. Pour déléguer la gestion de la durée de vie d'un élément graphique à son conteneur, créez-le avec <function>manage()</function> et empaquetez-le dans son conteneur avec <methodname>add()</methodname>. Ainsi, l'élément graphique sera détruit au moment où son conteneur sera détruit.Même si les instances d'éléments graphiques <application>gtkmm</application> ont des durées de vie et des portées comme toute autre classe C++, <application>gtkmm</application> dispose d'une fonctionnalité optionnelle que vous pourrez observer dans certains exemples ; elle permet de gagner du temps. <function>Gtk::manage()</function> vous permet d'indiquer qu'un élément graphique enfant est détenu par le conteneur dans lequel vous le placez. Cela permet de créer l'élément graphique avec <function>new</function>, l'ajouter au conteneur et ne pas vous préoccuper de sa destruction. Vous en apprendrez plus au sujet des techniques de gestion de la mémoire dans <application>gtkmm</application> dans le chapitre <link linkend="chapter-memory">Gestion de la mémoire</link>.Même si Cairo peut afficher du texte, il n'a pas été conçu pour être un remplaçant de Pango. Pango est un meilleur choix si vous devez exécuter des rendus de texte complexes comme des textes enveloppants ou inscrits dans une ellipse. L'écriture avec Cairo doit être réservée à des textes intégrés dans un graphique.Bien que le signal <literal>custom_widget_apply</literal> fournisse un pointeur sur l'élément graphique précédemment créé, pour simplifier les choses, vous pouvez conserver en tant que membres de la classe, les éléments graphiques présumés contenir des entrées utilisateur. Par exemple, disons que nous avons un <classname>Gtk::Entry</classname> nommé <literal>m_Entry</literal> membre de votre classe <classname>CustomPrintOperation</classname> : <placeholder-1/>Même si le nom <classname>EventBox</classname> met en valeur l'aspect gestion des événements, cet élément graphique peut être utilisé pour la délimitation des contours (ou plus ; voir l'exemple ci-dessous).Même si nous avons indiqué la commande de compilation pour cet exemple simple, vous devriez vraiment utiliser les outils <application>automake</application> et <application>autoconf</application> tels que décrits dans « Autoconf, Automake, Libtool » par G.V. Vaughan et autres. Les exemples utilisés dans le présent ouvrage sont incorporés dans le paquet logiciel de <application>gtkmm</application>, avec les fichiers de construction appropriés ; nous ne mentionnerons donc pas ces commandes dans le futur. Il conviendra simplement de trouver le répertoire convenable, de s'y placer et de saisir <literal>make</literal>.Même s'il est possible de préciser la disposition et l'apparence des fenêtres ainsi que des éléments graphiques dans le code C++, vous trouverez certainement plus pratique de concevoir vos interfaces utilisateur avec <literal>Glade</literal> et de les charger avec <literal>Gtk::Builder</literal> à l'exécution de l'application. Consultez le chapitre <link linkend="chapter-builder">Glade et Gtk::Builder</link>.Même si vous pouvez théoriquement implémenter votre propre modèle, vous utiliserez normalement, soit la classe modèle <classname>ListStore</classname>, soit la classe modèle <classname>TreeStore</classname>.Même si vous pouvez utiliser du code C++ pour instancier et disposer les éléments graphiques, cela devient vite répétitif et fastidieux. De plus, il est nécessaire de compiler à nouveau pour voir les modifications. L'application <application>Glade</application> vous permet de disposer les éléments graphiques à l'écran et d'enregistrer une description XML de l'arrangement. Votre application peut alors utiliser l'API <application>Gtk::Builder</application> pour charger ce fichier XML au lancement de l'application et obtenir un pointeur sur les instances de l'élément graphique précisément désigné.Même si votre conteneur possède sa propre fonction membre pour définir ses éléments graphiques enfants, vous devez quand même fournir une implémentation des fonctions membres virtuelles <methodname>on_add()</methodname> et <methodname>on_remove()</methodname> de la classe de base de façon à ce que les fonctions membres add() et remove() fassent quelque chose d'approprié si elles sont appelées.Même si, dans la plupart des cas, le programmeur préfére allouer des conteneurs pour détruire automatiquement leur contenu avec la fonction <function>manage()</function> (voir ci-dessous), l'utilisation de cette fonction n'est pas obligatoire. Les opérateurs traditionnels <literal>new</literal> et <literal>delete</literal> peuvent également être utilisés.Un objet <classname>Assistant</classname> divise une opération complexe en étapes successives. À chaque étape correspond une page, avec un en-tête, un élément graphique enfant et une zone d'action. La zone d'action de l'assistant possède des boutons de navigation qui se mettent à jour automatiquement selon le type de page fixé avec <methodname>set_page_type()</methodname>.Un élément graphique <classname>Entry</classname> peut afficher une barre de progression dans la zone de saisie du texte, en arrière plan du texte. La barre de progression est affichée en faisant appel aux fonctions membres <methodname>set_progress_fraction()</methodname> ou <methodname>set_progress_pulse_step()</methodname>.Un élément graphique <classname>Entry</classname> peut afficher une icône au début ou à la fin de la zone de texte. L'icône est définie par des fonctions membres telles que <methodname>set_icon_from_pixbuf()</methodname> ou <methodname>set_icon_from_stock()</methodname>. Une application peut répondre à un utilisateur qui clique sur l'icône en prenant en charge le signal <methodname>signal_icon_press</methodname>.Un objet <classname>InfoBar</classname> permet d'afficher de courts éléments d'informations ou de poser de brèves questions. Contrairement à l'objet <classname>Dialog</classname>, il apparaît au dessus de la fenêtre actuelle au lieu d'ouvrir une nouvelle fenêtre. Son API est tout à fait semblable à celle de l'objet <link linkend="chapter-dialogs">Gtk::Dialog</link>.Un Hello World amélioréAnastasovAutre chose à noter dans cet exemple : nous appelons <methodname>connect()</methodname> deux fois pour le même objet signal. Cela est parfaitement correct — quand le bouton est cliqué, les deux gestionnaires de signal sont appelés.L'autre façon d'interrompre la connexion est fournie par le gestionnaire de signal qui doit être du type <classname>sigc::slot&lt;bool&gt;</classname>.Comme vous le voyez dans la définition, le gestionnaire de signal doit renvoyer une valeur du type <literal>bool</literal>. Une définition d'une fonction exemple pourrait ressembler à quelque chose comme : <placeholder-1/>Une autre manière de contourner ce problème consiste à ajouter une fonction <function>*_construct()</function> que le constructeur C++ peut appeler après avoir instancié son propre type. Par exemple, <placeholder-1/>Tout fichier source <filename>.h</filename> et <filename>.cc</filename> non généré automatiquement doit être placé dans <filename>skeleton/skeletonmm/</filename> et énuméré dans <filename>skeleton/skeletonmm/filelist.am</filename>, traditionnellement dans les variables <varname>files_extra_h</varname> et <varname>files_extra_cc</varname>.Durée de vie d'une applicationApplication des balisesComme auparavant, la plupart des choses intéressantes se passent dans le gestionnaire des événements d'exposition <methodname>on_expose_event()</methodname>. Avant de creuser ce gestionnaire, notez que le constructeur de l'élément graphique <classname>Clock</classname> connecte sa fonction de rappel <methodname>onSecondElapsed()</methodname> à un séquenceur qui se déclenche toutes les 1000 millisecondes (1 seconde). Cela signifie que <methodname>onSecondElapsed()</methodname> sera appelée toutes les secondes. La seule responsabilité de cette fonction consiste à invalider la fenêtre de façon à ce que <application>gtkmm</application> soit obligé de la retracer.Comme mentionné plus haut, chaque <classname>TextView</classname> possède un <classname>TextBuffer</classname> et un ou plusieurs <classname>TextView</classname> peuvent partager le même <classname>TextBuffer</classname>.Comme mentionné plus haut, <classname>Gtk::Adjustment</classname> peut émettre des signaux. C'est pourquoi, bien entendu, les mises à jour se font automatiquement quand vous partagez un objet ajustement entre un <classname>Scrollbar</classname> et un autre élément graphique ajustable ; tous les éléments graphiques ajustables connectent leurs gestionnaires de signaux au signal <literal>value_changed</literal> de l'ajustement, comme pourrait le faire le programme.De la même manière que nous avons renommé les répertoires, nous devons renommer certains fichiers sources. Par exemple : <placeholder-1/> Un certain nombre de fichiers squelettes doivent être complétés plus tard avec les données spécifiques au contenu du projet.Ainsi que nous l'expliquons dans le chapitre <link linkend="chapter-adjustment">Ajustements</link>, tous les éléments graphiques à plage de réglage disposent d'un objet <classname>Adjustment</classname> associé. Pour modifier les valeurs minimale, maximale ou actuelles associées à la position du curseur dans l'élément graphique, vous devez utiliser les fonctions membres de la classe <classname>Adjustment</classname> dont on obtient le pointeur avec <methodname>get_adjustment()</methodname>. Les constructeurs d'un élément graphique à plage de réglage créent automatiquement, par défaut, un objet <classname>Adjustment</classname> ; vous pouvez aussi désigner un objet <classname>Adjustment</classname> préexistant, en vue peut-être de le partager avec un autre élément graphique. Consultez le chapitre <link linkend="chapter-adjustment">Ajustements</link> pour de plus amples détails.Comme pour les objets de la classe <classname>Scrollbar</classname>, il existe un type distinct pour l'élément graphique d'allure horizontale et celui d'allure verticale — <classname>Gtk::HScale</classname> et <classname>Gtk::VScale</classname>. Le constructeur par défaut crée un objet <classname>Adjustment</classname> dont toutes les valeurs sont fixées à <literal>0,0</literal>. Ce n'est pas utilisable en l'état : vous devez définir certains détails de l'objet <classname>Adjustment</classname> pour obtenir un comportement signifiant.Cadre proportionnéAssistantHypothèse concernant la taille d'affichage des chaînesOpérations asynchronesAu moment de l'installation, les fichiers <filename>.po</filename> sont convertis dans un format binaire (avec l'extension <filename>.mo</filename>) et placés dans un répertoire système pour les fichiers d'environnement linguistique, par exemple <filename>/usr/share/locale/</filename>.Au niveau développement d'une application, l'API impression de <application>gtkmm</application> fournit des boîtes de dialogue cohérentes entre applications et autorise l'API de dessin courant de Cairo avec un moteur de rendu de texte piloté par Pango. Pour l'implémentation courante de cette API, sont utilisés des moteurs de traitement particuliers à la plate-forme et des pilotes d'imprimantes spécifiques au périphérique.Pour le moins, la fonction <function>_new()</function> ne doit pas utiliser une quelconque API privée (fonctions uniquement dans un fichier .c). Même s'il n'y a pas de fonctions, nous pouvons ré-implémenter 2 ou 3 lignes de code dans une fonction <function>_new()</function> pour autant que ces lignes de code utilisent une API disponible pour nous.À ce moment, nous disposons d'outils séparés pour générer les diverses parties des fichiers <filename>.defs</filename>, nous les éclatons donc en fichiers séparés. Par exemple, dans le répertoire <filename>gtk/src</filename> des sources de <application>gtkmm</application>, vous trouvez ces fichiers : <placeholder-1/>Cellules modifiables à enregistrement automatique.Équivalents des types de baseTypes de baseFondamentauxÉtant donné que l'utilisateur peut saisir n'importe quel texte, une ligne active du modèle ne suffit pas pour indiquer quel est le texte saisi par l'utilisateur. C'est pourquoi, vous devez retrouver l'élément graphique <classname>Entry</classname> avec la fonction membre <methodname>ComboBoxEntry::get_entry()</methodname> et appeler <methodname>get_text()</methodname> sur cet objet.Cette transformation automatique n'est pas toujours appropriée ; vous serez amené à rédiger un texte pour des fonctions membres particulières. Vous pouvez faire cela en copiant le nœud XML concernant la fonction du fichier <filename>something_docs.xml</filename> vers le fichier <filename>something_docs_override.xml</filename> et en modifiant son contenu.Avant de procéder à l'installation de <application>gtkmm</application> 2.4, il se peut que vous ayez besoin d'installer au préalable d'autres paquets logiciels.Ci-dessous se trouve un court exemple pour illustrer ces fonctions. Cet exemple utilise l'élément graphique cadre pour mieux séparer les styles d'étiquettes (l'élément graphique cadre est exposé au paragraphe <link linkend="sec-frame">Cadre</link>).BernhardOutre l'indication du taux de progression d'une tâche, la barre de progression peut aussi s'utiliser pour indiquer qu'il y a une certaine activité ; cela s'effectue en mettant la barre de progression en <emphasis>mode activité</emphasis>. Dans ce mode, la barre de progression affiche un petit rectangle se déplaçant d'une extrémité à l'autre de la barre. Ce mode est utile dans les cas où le taux de progression d'une opération ne peut pas être calculé sous forme de valeur numérique (par exemple, pour la réception d'un fichier de taille inconnue).Liaison avec des paramètres supplémentairesBjarne Stroustrup, « The C++ Programming Language » - chapitre 14.4.2Empaquetage dans boîte n°1Empaquetage dans boîte n°2BoîtesConstruction de <application>gtkmm</application> sur Win32Mais contrairement à la plupart des pointeurs, vous ne pouvez pas utiliser l'opérateur <literal>*</literal> pour avoir accès à l'instance sous-jacente.Mais contrairement aux pointeurs normaux, les <classname>RefPtr</classname> sont automatiquement initialisés à NULL ; vous n'avez pas à faire cela vous-même.BoutonLes boîtes à boutons sont un moyen commode de disposer rapidement un groupe de boutons. Il en existe deux types : un horizontal (<classname>Gtk::HButtonBox</classname>) et un vertical (<classname>Gtk::VButtonBox</classname>). Ils sont tout à fait semblables ; ils ne différent que par leur nom et leur orientation.Les boîtes à boutons prennent en charge divers styles de dispositions. Le style peut être obtenu et modifié avec les fonctions membres <methodname>get_layout()</methodname> et <methodname>set_layout()</methodname>.Boîte à boutonBoîtes à boutonsBoutonsLes boutons sont insérés dans l'objet <classname>ButtonBox</classname> à l'aide de la fonction membre <methodname>add()</methodname>.Par convention, les objets de style glib/GTK+ possèdent des fonctions <function>*_new()</function>, comme par exemple <function>example_widget_new()</function>, qui ne font rien de plus qu'appeler <function>g_object_new()</function> et renvoyer le résultat. Les paramètres en entrée sont fournis à la fonction <function>g_object_new()</function> en même temps que les noms des propriétés dont elles sont les valeurs. Par exemple, <placeholder-1/>Par convention, les structures sont déclarées comme suit dans les en-têtes de style glib/GTK+ : <placeholder-1/>Par défaut, <application>gtkmm</application> est installé dans le répertoire <filename>/usr/local</filename>. Sur certains systèmes, il sera peut-être nécessaire de l'installer à un autre emplacement. Par exemple, sur les systèmes Linux Red Hat, vous utiliserez peut-être l'option <literal>--prefix</literal> avec configure, ainsi : <screen>
# ./configure --prefix=/usr
</screen>Par défaut, la configuration de <application>jhbuild</application> est déterminée pour installer tous les logiciels construits avec son aide avec le préfixe de dossier <filename>/opt/gnome2</filename>. Vous pouvez opter pour un préfixe différent, mais il est recommandé de le différencier de celui utilisé pour les autres logiciels installés (n'utilisez pas <filename>/usr</filename> !). Si vous avez suivi les instructions de jhbuild, ce préfixe vous appartient en tant qu'utilisateur ; vous n'aurez donc pas besoin d'être <literal>root</literal> pour lancer <application>jhbuild</application>.Par défaut, <methodname>PrintOperation::run()</methodname> rend la main quand l'opération d'impression est terminée. Si vous voulez lancer une opération d'impression non-bloquante, appelez <methodname>PrintOperation::set_allow_async()</methodname>. Notez que <methodname>set_allow_async()</methodname> n'est pas pris en charge sur toutes les plates-formes, bien que le signal <literal>done</literal> soit toujours émis.Par défaut, vous ne pouvez sélectionner qu'une seule ligne, mais la sélection multiple est possible en activant le mode correspondant, comme ceci : <placeholder-1/>Par défaut, les gestionnaires de signaux sont appelés successivement. Toutefois cela peut conduire à des difficultés avec les signaux des événements X. Par exemple, le gestionnaire de signal existant, ou le gestionnaire par défaut, peut renvoyer une valeur empêchant l'appel des autres gestionnaires de signal. Pour indiquer qu'un gestionnaire de signal doit être appelé avant les autres ou bien appelé dans tous les cas, vous pouvez indiquer <literal>false</literal> pour le paramètre optionnel <literal>after</literal>. Par exemple, <placeholder-1/>En dérivant directement de la classe <classname>Gtk::Widget</classname>, vous pouvez faire tous les dessins voulus directement dans votre élément graphique plutôt que seulement placer des éléments graphiques enfants. Par exemple, un objet <classname>Gtk::Label</classname> écrit directement le texte de l'étiquette sans passer par l'intermédiaire d'autres éléments graphiques.En surdéfinissant <methodname>forall_vfunc()</methodname> vous permettez aux applications d'opérer sur tous les éléments graphiques enfants du conteneur. Par exemple, <methodname>show_all_children()</methodname> utilise cette possibilité pour trouver tous les éléments graphiques enfants et les afficher.Les programmeurs C se servent de la fonction <function>sprintf()</function> pour composer et concaténer des chaînes. Le C++ favorise les flux, mais malheureusement, cette approche rend la traduction difficile, parce que chaque fragment de texte est traduit séparément sans permettre aux traducteurs de les ré-agencer selon la grammaire de la langue.Types CTypes C++Cairo et PangoAppelez la fonction membre <methodname>add_drag_dest()</methodname> pour permettre le glisser-déposer d'éléments ou de groupes depuis une palette d'outils jusqu'à un élément graphique destination donné. Puis vous pouvez vous servir de <methodname>get_drag_item()</methodname> pour savoir quel outil élémentaire ou quel groupe a été glissé. Un <literal>dynamic_cast</literal> vous permet de savoir s'il s'agit d'un élément ou d'un groupe. Ainsi, dans le gestionnaire du signal <literal>drag_data_received</literal> vous utilisez ce forçage de type pour ajouter un élément déposé ou pour afficher une icône adaptée pendant le glissé.Appelez <methodname>show()</methodname> pour afficher l'élément graphique.Forçage de typeCedricDes cellules d'un objet <classname>TreeView</classname> peuvent être modifiées in-situ par l'utilisateur. Pour permettre ce comportement, utilisez les fonctions membres <classname>Gtk::TreeView</classname><methodname>insert_column_editable()</methodname> et <methodname>append_column_editable()</methodname> au lieu de <methodname>insert_column()</methodname> et <methodname>append_column()</methodname>. Quand ces colonnes sont modifiées, les nouvelles valeurs sont immédiatement enregistrées dans le modèle. Notez que ces fonctions membres sont des prototypes qui ne peuvent être utilisés que dans le cas de types de colonnes simples tels que des <classname>Glib::ustring</classname>, des <literal>int</literal> et des <literal>long</literal>.Modifier la disposition d'une fenêtre « à la volée », pour faire apparaître quelques éléments graphiques supplémentaires, par exemple, est compliqué. Cela demande un nouveau calcul ennuyeux de la position de chaque élément graphique.Modification de la sélectionChapitre « Tracés avec Cairo ».Chapitre « Impression ».Chapitre « Documents récents ».Chapitre « Fonctions à délai échu ».Chapitre « Installation sur Win32 ».Chapitre « Travail sur le code source de gtkmm »Case à cocherCase à cocherVérification du pointeur NULL Les enfants peuvent occuper plusieurs lignes ou colonnes en utilisant la méthode <methodname>attach()</methodname> ou être ajoutés à côté d'un élément graphique existant dans la grille avec la méthode <methodname>attach_next_to()</methodname>. Les lignes et colonnes de la grille peuvent être paramétrées de manière individuelle pour avoir une hauteur ou largeur uniforme avec <methodname>set_row_homogeneous()</methodname> et <methodname>set_column_homogeneous()</methodname>. Paramétrez les propriétés <emphasis>margin</emphasis> et <emphasis>expand</emphasis> des <classname>éléments graphiques</classname> qui sont ajoutés à la grille afin de contrôler la gestion de la géométrie.Éléments graphiques à portée de classeMacros de classesPresse-papier - IdéalPresse-papier - SimpleBoîte de dialogue Sélection de couleurBoîtes combinéesComboBoxBoîte combinée avec saisieBoîte combinée avec saisieBoîte combinée avec saisie de texteComparaison avec les autres systèmes de signalisationComposition de chaînesConnectez tout signal que vous souhaitez utiliser aux gestionnaires appropriés.Branchement des greffons et des connecteursConnexion aux gestionnaires de signalObjets const utilisés par l'intermédiaire d'un <classname>RefPtr</classname> : si l'objet ne doit pas être modifié par la fonction, assurez-vous que l'objet est const, même si le <classname>RefPtr</classname> est déjà const, par exemple, <code>const Glib::RefPtr&lt;const Gtk::Action&gt;&amp; action</code>.ConstanceConstructeurMacros de constructeursConstructeursÉléments graphiques conteneursComment contribuerCopieCopieCopie du squelette du projetcréer un objet <classname>Plug</classname> de manière indépendante de tout <classname>Socket</classname> particulier et passer l'ID du <classname>Plug</classname> aux processus qui souhaitent l'utiliser. L'ID de l'objet <classname>Plug</classname> peut être associé à un objet <classname>Socket</classname> donné avec la fonction <methodname>Socket::add_id()</methodname>. C'est l'approche utilisée dans l'exemple qui suit.créer un objet <classname>Socket</classname> dans un processus et passer l'ID de ce <classname>Socket</classname> à un autre processus pour qu'il puisse créer un objet <classname>Plug</classname> en précisant ledit ID du <classname>Socket</classname> dans son constructeur. Il n'est pas possible d'attribuer un <classname>Plug</classname> à un <classname>Socket</classname> après sa création, il faut donc transmettre l'ID du <classname>Socket</classname> au constructeur du <classname>Plug</classname>.Créez un sous-répertoire nommé <literal>po</literal> dans le répertoire racine de votre projet. Ce répertoire contiendra en phase finale toutes les traductions. Dans celui-ci, créez un fichier nommé <literal>LINGUAS</literal> et un fichier nommé <literal>POTFILES.in</literal>. Il est aussi de pratique courante de créer un fichier <literal>ChangeLog</literal> dans le répertoire <literal>po</literal> pour que les traducteurs puissent garder trace des modifications de traduction.Créez vos propres signaux au lieu de transmettre des pointeurs. Les objets peuvent communiquer entre eux par l'intermédiaire de signaux et de gestionnaires de signaux. C'est plus simple que des objets enregistrant des pointeurs vers d'autres objets, et vice versa, en appelant mutuellement leurs fonctions membres. Les classes de <application>gtkmm</application> utilisent une version spéciale de <classname>sigc::signal</classname>, mais vous pouvez utiliser les signaux normaux tels que décrits dans la documentation de <application>libsigc++</application>.Création des fichiers .hg et .ccgCréation d'un objet AdjustmentCréation de vos propres signauxCummingActuellement, <application>gettext</application> ne prend pas en charge les caractères non-ASCII (c'est-à-dire tout caractère de code supérieur à 127) dans le code source. Par exemple, vous ne pouvez pas utiliser le signe de copyright (©).Conteneur personnaliséConteneurs personnalisésÉlément graphique personnaliséÉléments graphiques personnalisésDISTCLEANFILES = ... intltool-extract \
                 intltool-merge \
                 intltool-update \
                 po/.intltool-merge-cacheDanielDéclarer une variable du type de l'<classname>Élément graphique</classname> que vous souhaitez utiliser, généralement en tant que variable membre d'une classe conteneur dérivée. Vous pouvez également déclarer un pointeur sur le type de l'élément graphique et le créer avec <literal>new</literal> dans votre code. Même si vous utilisez l'élément graphique par l'intermédiaire d'un pointeur, ce sera probablement mieux de faire en sorte que ce pointeur soit une variable membre d'une classe conteneur ; vous pouvez ainsi y accéder ultérieurement.Format par défautdéfinissez <literal>INTLTOOL_FILES</literal> égal à : <placeholder-1/>définit une cible de presse-papier personnalisée, même si le format de cette cible est toujours du texte,DépendancesDéréférencementdes concepteurs sans capacité particulière de programmation peuvent créer et modifier des UI.Boîtes de dialogueLes boîtes de dialogue s'utilisent en tant que fenêtres accessoires pour donner des informations particulières ou pour poser des questions. Les fenêtres <classname>Gtk::Dialog</classname> contiennent des éléments graphiques pré-incorporés pour assurer une certaine cohérence ; elles disposent également d'une fonction membre <methodname>run()</methodname> bloquante jusqu'à ce que l'utilisateur ferme la boîte de dialogue.Diverses applications contiennent divers types de données ; elles peuvent mettre ces données à disposition sous des formats variés. <application>gtkmm</application> appelle ces types de données des « <literal>targets</literal> » (cibles).Différents types de raccord dans CairoDéconnexion des gestionnaires de signalDétermination des cibles admissibleseffectue un appel supplémentaire à reference() sur la valeur de retour au cas où la fonction C ne fournirait pas de référence.ne pas générer une fonction membre virtuelle <function>on_something()</function> pour faciliter la surdéfinition du gestionnaire de signal par défaut. Ce paramètre est à utiliser quand l'ajout d'un signal avec son gestionnaire par défaut casserait l'ABI (Application Binary Interface) en augmentant la taille de la table des fonctions virtuelles de la classe.DocumentationStructure de construction de la documentationGlisser-déposerDragContextTracé des arcs et des cerclesZone de dessin ‑ ArcsZone de dessin ‑ LignesTracé de courbesAffichage d'imagesAffichage d'images avec GdkTracé de droitesTracé de textesTracé de texte avec PangoTracé en sens inverse des aiguilles d'une montreTracé en coordonnées relativesPendant un <literal>déplacement</literal>, l'élément graphique source émet également le signal : <placeholder-1/>Allocation dynamique avec manage() et add()Allocation dynamique avec new et deleteChaque <classname>Cairo::Context</classname> est associé à une fenêtre <classname>Gdk::Window</classname> donnée ; ainsi, la première ligne de l'exemple ci-dessus crée un élément graphique <classname>Gtk::DrawingArea</classname> et la deuxième ligne utilise son objet <classname>Gdk::Window</classname> associé pour créer un objet <classname>Cairo::Context</classname>. Les deux dernières lignes modifient les caractéristiques graphiques du contexte.Chaque <classname>Gtk::TextBuffer</classname> utilise un objet <classname>Gtk::TextBuffer::TagTable</classname> contenant les balises pour ce tampon. Deux objets <classname>TextBuffer</classname> ou plus peuvent partager le même objet <classname>TagTable</classname>. Quand vous créez un objet <classname>Tag</classname> vous devez l'incorporer dans l'objet <classname>TagTable</classname>. Par exemple :Chaque objet <classname>Gtk::TreeView</classname> possède un objet <classname>Gtk::TreeModel</classname> associé ; il contient les données à afficher par l'objet <classname>TreeView</classname>. Tout <classname>Gtk::TreeModel</classname> peut être utilisé par plus d'un <classname>Gtk::TreeView</classname>. Par exemple, il est possible d'afficher et modifier simultanément sous deux formes différentes les mêmes données sous-jacentes ; ou bien encore, les deux vues peuvent afficher des colonnes différentes à partir du même modèle de données, tout comme deux requêtes SQL (ou « vues ») sont susceptibles d'afficher des champs différents à partir d'une même base de données.Chaque élément, dans la liste des fichiers récemment utilisés, est identifié par son URI et peut posséder des métadonnées associées. Les métadonnées peuvent être utilisées pour définir la façon dont le fichier doit être affiché, une description du fichier, son type MIME, quelle application l'a enregistré, s'il appartient en propre à l'application qui l'a enregistré et diverses autres informations.Chaque ligne est constituée d'une boîte horizontale (<classname>HBox</classname>) avec plusieurs boutons. Chacun des boutons de la ligne est empaqueté dans l'objet <classname>HBox</classname> avec les mêmes paramètres à l'aide de la fonction membre <methodname>pack_start()</methodname>.Cellules modifiablesElstnerÉmis quand le bouton est enfoncé et relâché.Émis quand le bouton est enfoncé.Émis quand le bouton est relâché.Émis lorsque le pointeur de souris sort de la fenêtre du bouton.Émis quand le pointeur de souris entre dans la fenêtre du bouton.Champ de saisieComplétion de saisieExemple de complétion de saisieExemple d'icône dans un champ de saisieIcône dans un champ de saisieSaisie avec barre de progressionExemple de saisie avec barre de progressionLes éléments graphiques <classname>Entry</classname> permettent à l'utilisateur de saisir du texte. Vous pouvez en modifier le contenu avec la fonction membre <methodname>set_text()</methodname> et en lire le contenu actuel avec la fonction membre <methodname>get_text()</methodname>.Saisie avec icôneSaisie avec barre de progressionénumérations.EventBoxExempleExemple d'application : création d'un cadran d'horloge avec CairoExemplesEn attendant UTF8Exportation au format PDFExtension de la boîte de dialogue d'impressionBoîte de dialogue Sélection de fichierBoîte de dialogue Sélection de fichierFiltrage des fichiers récentsPour terminer, vérifiez l'état. Par exemple : <placeholder-1/>Pour terminer, pour permettre à votre programme d'utiliser la traduction pour l'adaptation locale en cours, ajoutez ce code au début de votre fichier <filename>main.cc</filename> pour initialiser gettext : <placeholder-1/>Créez tout d'abord un objet <classname>Action</classname> et ajoutez-le à un <classname>ActionGroup</classname> avec <methodname>ActionGroup::add()</methodname>.Tout d'abord nous créons un exemplaire d'un objet nommé <literal>kit</literal>. Il est du type <classname>Gtk::Main</classname>. Tout programme <application>gtkmm</application> doit en posséder un. Nous passons les paramètres en ligne de commande à son constructeur. Il prélève les arguments dont il a besoin et vous laisse le reste, comme nous l'avons expliqué plus haut.Boîte de dialogue Sélection de policePour un « CellRendererToggle », vous paramétrez la propriété <emphasis>activatable</emphasis> à la place.Pour chacune de ces fonctions membres, le premier paramètre est le <classname>Gdk::GC</classname>. Le second est l'objet de type approprié à copier : <classname>Gdk::Drawable</classname>, <classname>Gdk::Bitmap</classname> ou <classname>Gdk::Image</classname>. Les deux paramètres suivants sont les coordonnées x et y du point de départ de la copie dans l'image à copier , puis les coordonnées x et y du point de destination de la copie dans la zone de dessin et enfin la largeur et la hauteur de la région à copier.Pour chacune des classes <classname>RecentChooser</classname>, si vous ne souhaitez pas afficher tous les éléments de la liste des fichiers récents, vous pouvez filtrer la liste pour ne montrer que ce que vous souhaitez. Vous pouvez filtrer la liste avec l'aide de la classe <classname>RecentFilter</classname>. Cette classe vous permet de filtrer les fichiers par le nom (<methodname>add_pattern()</methodname>), leur type MIME (<methodname>add_mime_type()</methodname>), l'application qui les a enregistrés (<methodname>add_application()</methodname>) ou par une fonction de filtrage personnalisée (<methodname>add_custom()</methodname>). Elle offre aussi la possibilité de filtrer sur la date de dernière modification et sur les groupes dont le fichier fait partie.Pour chaque page devant être imprimée, les signaux suivants sont émis : <placeholder-1/>Par exemple, dans <filename>dialog.hg</filename> : <placeholder-1/>Par exemple, dans <filename>progress.hg</filename> : <placeholder-1/>Par exemple, dans <filename>rectangle.hg</filename> : <placeholder-1/>Par exemple : <placeholder-1/>Pour des informations sur l'implémentation de vos propres signaux au lieu d'une simple connexion aux signaux prédéfinis de <application>gtkmm</application>, consultez cette <link linkend="chapter-custom-signals">annexe</link>.Par exemple,Par exemple, <placeholder-1/>Par exemple, pour <classname>Gdk::Color</classname> : <placeholder-1/>Par exemple, pour <classname>Gdk::Rectangle</classname> : <placeholder-1/>Par exemple, pour <classname>Gdk::Region</classname> : <placeholder-1/>Par exemple, pour <classname>Pango::AttrIter</classname> : <placeholder-1/>Par exemple, pour <classname>Pango::Coverage</classname> : <placeholder-1/>Par exemple, pour un CellRendererText, vous définissez la propriété <emphasis>editable</emphasis> égale à <literal>true</literal>, comme ceci :Par exemple, à partir de <filename>accelgroup.hg</filename> : <placeholder-1/>Par exemple, à partir de <filename>button.hg</filename> : <placeholder-1/>Par exemple, pour <filename>buttonbox.hg</filename> : <placeholder-1/>Par exemple, pour <filename>celleditable.hg</filename> : <placeholder-1/>Par exemple, pour <filename>container.hg</filename> : <placeholder-1/>Par exemple, pour <filename>entry.hg</filename> : <placeholder-1/>Par exemple, pour <filename>pixbuf.hg</filename> : <placeholder-1/>Par exemple, pour <filename>widget.hg</filename> : <placeholder-1/>Par exemple, <application>gedit</application> peut fournir et recevoir la cible <literal>« UTF8_STRING »</literal> ; vous pouvez donc coller dans <application>gedit</application> des données de toute application fournissant cette cible. Ou bien, deux applications différentes de modification d'images peuvent fournir et recevoir divers formats d'image en tant que cibles. Tant qu'une application peut recevoir une des cibles que l'autre fournit, vous pouvez copier des données de l'une vers l'autre.Par exemple, disons que nous habillons une bibliothèque C nommée libexample. Elle fournit une API fondée sur <classname>GObject</classname> dont les types sont nommés, par exemple, <classname>ExampleThing</classname> et <classname>ExampleStuff</classname>.Par exemple, ce code risque d'être sujet à problèmes :Par exemple, pour créer un signal qui envoie 2 paramètres, un de type <literal>bool</literal> et un de type <literal>int</literal>, déclarez juste un <classname>sigc::signal</classname>, ainsi : <placeholder-1/>Par exemple :Pour plus de détails à propos des signaux, consultez cette <link linkend="chapter-signals">annexe</link>.Pour une sélection multiple, vous aurez besoin de définir une fonction de rappel et de la fournir en paramètre à <methodname>selected_foreach()</methodname>, <methodname>selected_foreach_path()</methodname> ou <methodname>selected_foreach_iter()</methodname>, ainsi :À titre de référence, il est possible de générer un fichier qui contienne toutes les chaînes apparaissant dans votre code, même si elles ne sont pas marquées pour la traduction, avec le nom du fichier et le numéro de la ligne où elles se situent. Pour générer ce fichier que nous appelons <literal>my-strings</literal>, exécutez la commande suivante dans le répertoire du code source : <placeholder-1/>Pour une simple sélection, appelez simplement la fonction membre <methodname>get_selected()</methodname>, comme suit :Pour la saisie de mots de passe, phrases de passe et autres informations que vous ne souhaitez pas voir reprises à l'affichage, l'appel de la fonction membre <methodname>set_visibility()</methodname> avec <literal>false</literal> comme paramètre provoque le masquage du texte.CadreLes cadres, avec un intitulé en option, peuvent entourer un ou un groupe d'éléments graphiques dans une boîte. Par exemple, vous pouvez placer un groupe de <classname>RadioButton</classname> ou de <classname>CheckButton</classname> dans un objet <classname>Frame</classname>.Parfois, il peut se révéler utile de pouvoir incorporer un élément graphique d'une autre application dans votre propre application. <application>gtkmm</application> permet cela grâce aux classes <classname>Gtk::Socket</classname> et <classname>Gtk::Plug</classname>. Il est peu vraisemblable que beaucoup d'applications aient besoin de cette fonctionnalité, mais dans les rares cas où vous auriez besoin d'afficher un élément graphique fonctionnant dans un processus tout à fait différent, ces classes peuvent être d'une grande aide.Exemple completÉléments graphiques à portée de fonctionGTK+ 3.0GTK+ et <application>gtkmm</application> ont été conçus pour bien fonctionner avec Windows Microsoft ; les développeurs poussent à son utilisation sur les plates-formes win32. Mais, Windows ne dispose d'aucune norme d'installation pour les bibliothèques de développement. Consultez les pages spécifiques relatives aux instructions et notes spécifiques à l'<ulink url="http://live.gnome.org/gtkmm/MSWindows">Installation sous Windows</ulink>.GTK+ utilise l'API de dessin <ulink url="http://cairographics.org">Cairo</ulink>. Avec gtkmm, vous pouvez faire usage de l'API C++ pour cairo nommée <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink>.GeneGénération des fichiers .defsGénération des .defs pour les énumérationsGénération des .defs pour les fonctions membresGénération des .defs pour les signaux et les propriétésGénérer du code source pour un habillage d'API dans le style gtkmm requiert l'utilisation d'outils tels que <command>gmmproc</command> et <filename>generate_wrap_init.pl</filename>. En théorie, vous pouvez écrire vos propres fichiers de construction pour utiliser ces outils de manière appropriée, mais l'utilisation de l'infrastructure de construction fournie par le module mm-common est un meilleur choix. Prendre un module de liaison existant à titre d'exemple et l'examiner est un bon début.recueillez les données des éléments graphiques dans le gestionnaire de signal <literal>custom_widget_apply</literal>.Obtenir de l'aide avec les traductionsObtention des valeursGlade et Gtk::BuilderGlib::IO_ERR - appelle la fonction membre quand une erreur est arrivée sur le descripteur de fichier.Glib::IO_HUP - appelle la fonction membre quand il y a une interruption (la connexion a été interrompue généralement pour les tubes et les connecteurs).Glib::IO_IN - appelle la fonction membre quand il y a des données prêtes en lecture dans le descripteur de fichier.Glib::IO_OUT - appelle la fonction membre quand le descripteur de fichier est prêt pour l'écriture.Glib::IO_PRI - appelle la fonction membre quand le descripteur de fichier a des données à lire d'urgence.Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

// Cibles :
std::list&lt;Gtk::TargetEntry&gt; listTargets;
listTargets.push_back( Gtk::TargetEntry("example_custom_target") );
listTargets.push_back( Gtk::TargetEntry("UTF8_STRING") );

refClipboard-&gt;set( listTargets,
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_get),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_clear) );Glib::RefPtr&lt;Gtk::ListStore&gt; refListStore =
    Gtk::ListStore::create(m_Columns);Glib::RefPtr&lt;Gtk::RecentManager&gt; recent_manager = Gtk::RecentManager::get_default();
recent_manager-&gt;add_item(uri);Glib::RefPtr&lt;Gtk::TextBuffer::Mark&gt; refMark =
    refBuffer-&gt;create_mark(iter);Glib::RefPtr&lt;Gtk::TextBuffer::Tag&gt; refTagMatch =
    Gtk::TextBuffer::Tag::create();
refTagMatch-&gt;property_background() = "orange";Glib::RefPtr&lt;Gtk::TextBuffer::TagTable&gt; refTagTable =
    Gtk::TextBuffer::TagTable::create();
refTagTable-&gt;add(refTagMatch);
// Avec un peu de chance une future version de <application>gtkmm</application> 
// disposera d'une fonction membre set_tag_table(),
// à utiliser après la création du tampon.
Glib::RefPtr&lt;Gtk::TextBuffer&gt; refBuffer =
    Gtk::TextBuffer::create(refTagTable);Glib::RefPtr&lt;Gtk::TextChildAnchor&gt; refAnchor =
    refBuffer-&gt;create_child_anchor(iter);Glib::RefPtr&lt;Gtk::TreeModelSort&gt; sorted_model =
    Gtk::TreeModelSort::create(model);
sorted_model-&gt;set_sort_column(columns.m_col_name, Gtk::SORT_ASCENDING);
treeview.set_model(sorted_model);Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
    m_TreeView.get_selection();Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager =
    Gtk::UIManager::create();
m_refUIManager-&gt;insert_action_group(m_refActionGroup);
add_accel_group(m_refUIManager-&gt;get_accel_group());Glib::ustringGlib::ustring et std::iostreamsGlib::ustring strText = row[m_Columns.m_col_text];
int number = row[m_Columns.m_col_number];Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;menubar name='MenuBar'&gt;"
    "    &lt;menu action='MenuFile'&gt;"
    "      &lt;menuitem action='New'/&gt;"
    "      &lt;menuitem action='Open'/&gt;"
    "      &lt;separator/&gt;"
    "      &lt;menuitem action='Quit'/&gt;"
    "    &lt;/menu&gt;"
    "    &lt;menu action='MenuEdit'&gt;"
    "      &lt;menuitem action='Cut'/&gt;"
    "      &lt;menuitem action='Copy'/&gt;"
    "      &lt;menuitem action='Paste'/&gt;"
    "    &lt;/menu&gt;"
    "  &lt;/menubar&gt;"
    "  &lt;toolbar  name='ToolBar'&gt;"
    "    &lt;toolitem action='Open'/&gt;"
    "    &lt;toolitem action='Quit'/&gt;"
    "  &lt;/toolbar&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;popup name='PopupMenu'&gt;"
    "    &lt;menuitem action='ContextEdit'/&gt;"
    "    &lt;menuitem action='ContextProcess'/&gt;"
    "    &lt;menuitem action='ContextRemove'/&gt;"
    "  &lt;/popup&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);GrilleGroupesGtk::Adjustment(float value,
                float lower,
                float upper,
                float step_increment = 1,
                float page_increment = 10,
                float page_size = 0);Gtk::Alignment
Gtk::Arrow
Gtk::Bin
Gtk::Box
Gtk::Button
Gtk::CheckButton
Gtk::Fixed
Gtk::Image
Gtk::Item
Gtk::Label
Gtk::MenuItem
Gtk::Notebook
Gtk::Paned
Gtk::Pixmap
Gtk::RadioButton
Gtk::Range
Gtk::ScrolledWindow
Gtk::Separator
Gtk::Table
Gtk::Toolbar
Gtk::AspectFrame
Gtk::Frame
Gtk::VBox
Gtk::HBox
Gtk::VSeparator
Gtk::HSeparatorGtk::Box(bool homogeneous = false, int spacing = 0);Gtk::Button* pButton = new Gtk::Button("_Quelquechose", true);Gtk::Button* pButton = new Gtk::Button(Gtk::Stock::OK);Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
int cols_count = m_TreeView.append_column("Alex", *pRenderer);
Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
if(pColumn)
{
  pColumn-&gt;add_attribute(pRenderer-&gt;property_active(),
      m_columns.alex);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_visible(),
      m_columns.visible);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_activatable(),
      m_columns.world);Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
pRenderer-&gt;signal_toggled().connect(
    sigc::bind( sigc::mem_fun(*this,
        &amp;Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
);Gtk::DrawingArea myArea;
Cairo::RefPtr&lt;Cairo::Context&gt; myContext = myArea.get_window()-&gt;create_cairo_context();
myContext-&gt;set_source_rgb(1.0, 0.0, 0.0);
myContext-&gt;set_line_width(2.0);Gtk::EXPANDGtk::EventBox();Gtk::FILLGtk::Label prend en charge les mises en forme simples comme la graisse, la couleur et la taille de la police. Il suffit de fournir une chaîne de caractère à la fonction membre <methodname>set_markup()</methodname> en utilisant la <ulink url="http://library.gnome.org/devel/pango/unstable/PangoMarkupFormat.html">syntaxe de balisage Pango</ulink>. Par exemple, <code> &lt;b&gt;texte gras&lt;/b&gt; et &lt;s&gt;texte barré&lt;/s&gt; </code> .Gtk::Main kit(argc, argv);Gtk::Main::run(window);Gtk::RecentInfo info = recent_manager-&gt;lookup_item(uri);
if (info)
{
  // l'élément a été trouvé
}Gtk::SHRINKGtk::Table(int rows = 1, int columns = 1, bool homogeneous = false);Gtk::TreeModel::Children children = row.children();Gtk::TreeModel::Row row = *iter;Gtk::TreeModel::Row row = m_refModel-&gt;children()[5]; // 5ième ligne.
if(row)
  refTreeSelection-&gt;select(row);Gtk::TreeModel::iterator iter = m_Combo.get_active();
if(iter)
{
  Gtk::TreeModel::Row row = *iter;

  // Obtenir les données de la ligne choisie grâce à notre 
  // connaissance du modèle d'arborescence :
  int id = row[m_Columns.m_col_id];
  set_something_id_chosen(id); // Votre fonction.
}
else
  set_nothing_chosen(); // Votre fonction.Gtk::TreeModel::iterator iter = m_refListStore-&gt;append();Gtk::TreeModel::iterator iter = m_refModel-&gt;children().begin()
if(iter)
  refTreeSelection-&gt;select(iter);Gtk::TreeModel::iterator iter_child =
    m_refListStore-&gt;append(row.children());Gtk::TreeView::Column* pColumn =
    Gtk::manage( new Gtk::TreeView::Column("Symbole") );

// m_columns.icon et m_columns.symbol sont des colonnes du modèle.
// pColumn est la colonne dans l'objet TreeView :
pColumn-&gt;pack_start(m_columns.icon, false); //false = ne pas développer.
pColumn-&gt;pack_start(m_columns.symbol);

m_TreeView.append_column(*pColumn);Gtk::TreeView::Column* pColumn = treeview.get_column(0);
if(pColumn)
  pColumn-&gt;set_sort_column(m_columns.m_col_id);Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
pBox-&gt;add(*pMenuBar, Gtk::PACK_SHRINK);Gtk::Window window;GustinFichiers sources codés à la mainConstructeurs codés à la mainGestion du signal <literal>button_press_event</literal>La gestion des événements X n'affecte pas les autres signaux de l'élément graphique. Si vous gérez <literal>button_pressed_event</literal> pour <classname>Gtk::Button</classname>, vous serez encore en mesure de gérer le signal <literal>clicked</literal>. Ils sont émis (pratiquement) simultanément.Fichiers d'en-têtes et édition des liens Hello WorldHello World 2Hello World en <application>gtkmm</application>HelloWorld::HelloWorld()
:
  m_button ("Hello World")
{
  set_border_width(10);
  m_button.signal_clicked().connect(sigc::mem_fun(*this,
    &amp;HelloWorld::on_button_clicked));
  add(m_button);.
  m_button.show();
}Voici quelques exemples de gestion traditionnelle de la mémoire en C++ :Voici une liste de quelques uns de ces éléments graphiques :Voici un exemple simple qui place 100 boutons bascules dans une fenêtre à défilement. Essayez de redimensionner la fenêtre pour voir comment les barres de défilement réagissent.Voici un petit bout de code pour lier l'ensemble : (notez qu'habituellement, vous ne procédez pas au chargement de l'image à chaque fois dans le gestionnaire de l'événement d'exposition ! Ici, c'est uniquement pour que le code soit complet)Voici un exemple très simple montrant une opération de glisser-déposer avec <literal>copie</literal> :Voici un exemple de fonction de rappel :Voici quelques exemples de code extraits de <filename>demos/gtk-demo/example_stockbrowser.cc</filename>, qui possède une icône pixelisée et du texte dans une même colonne :Voici le code source de l'exemple qui a servi à générer la capture d'écran ci-dessus. Quand vous lancez cet exemple, indiquez un nombre entre 1 et 3 en option de ligne de commande pour voir les diverses options d'empaquetage utilisées.Ici nous définissons une nouvelle classe nommée <classname>OverriddenButton</classname> qui hérite de <classname>Gtk::Button</classname>. La seule chose que nous modifions est la fonction membre <methodname>on_clicked()</methodname> ; cette fonction membre est appelée chaque fois qu'un objet <classname>Gtk::Button</classname> émet le signal <literal>clicked</literal>. Elle affiche « Hello World » sur <literal>stdout</literal>, puis appelle la fonction membre originelle pour que <classname>Gtk::Button</classname> fasse ce qu'il a à faire quand il n'est pas surdéfini.Voici un exemple simple : <placeholder-1/>Voici un exemple un peu plus développé de connecteurs en action :Voici un exemple de <classname>SpinButton</classname> en action :Voici un exemple de gestionnaire de signal connecté à un signal :Voici un exemple de programme simple traçant un arc, un cercle et une ellipse sur une zone de dessin.Voici un exemple de cette technique :Voici le constructeur des éléments graphiques de la boîte : <placeholder-1/> Si le paramètre <parameter>homogeneous</parameter> est défini à <literal>true</literal>, tous les éléments graphiques de la boîte auront la même taille. <parameter>spacing</parameter> représente le nombre de pixels (minimum) à laisser entre chaque élément graphique.Comment fonctionne gettextComment utiliser GNOME CVS pour traduireToutefois, <application>Glib</application> définit des macros de prise en charge de <function>gettext()</function> qui sont des enveloppes plus brèves et de forme plus commode à utiliser. Pour utiliser ces macros, incluez <literal>&lt;glibmm/i18n.h&gt;</literal>, puis, par exemple, remplacez : <placeholder-1/> par : <placeholder-2/>Toutefois, cela ne vous donne aucun contrôle sur les éléments qu'il est possible de faire glisser et sur l'emplacement où ils peuvent être déposés. Si vous avez besoin de ce contrôle supplémentaire, vous devez créer un <literal>Gtk::TreeModel</literal> dérivé de <literal>Gtk::TreeStore</literal> ou <literal>Gtk::ListStore</literal> et opérer une surdéfinition des fonctions membres virtuelles <literal>Gtk::TreeDragSource::row_draggable()</literal> et <literal>Gdk::TreeDragDest::row_drop_possible()</literal>. Vous examinez alors les <literal>Gtk::TreeModel::Path</literal> fournis et autorisez/interdisez le glisser ou le déposer en renvoyant <literal>true</literal> ou <literal>false</literal>.Mais, il est plus simple d'utiliser la macro <function>PKG_CHECK_MODULES()</function> dans un fichier standard <filename>configure.ac</filename> avec <application>autoconf</application> et <application>automake</application>. Par exemple : <placeholder-1/> Cette commande vérifie la présence de <application>gtkmm</application> et définit les variables MYAPP_LIBS et MYAPP_CFLAGS à utiliser dans vos fichiers <filename>Makefile.am</filename>.Toutefois, vous pouvez vouloir que les nouvelles valeurs ne soient pas immédiatement enregistrées. Vous voulez, par exemple, limiter la saisie à certains caractères ou plages de valeurs.Même si vous avez certainement déjà délaissé les tableaux de <literal>char*</literal> vides et l'arithmétique des pointeurs en vous servant de <classname>std::string</classname>, vous devez maintenant utiliser à la place des objets <classname>Glib::ustring</classname>. Voyez le chapitre concernant les <classname>Glib::ustring</classname> dans les <link linkend="sec-basics-ustring">Fondamentaux</link>.I've been embedded.
A plug was addedINTLTOOL_FILES = intltool-extract.in \
                 intltool-merge.in \
                 intltool-update.inIT_PROG_INTLTOOL([0.35.0])

GETTEXT_PACKAGE=nom_programme
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                   [Domaine de portée de gettext])
AM_GLIB_GNU_GETTEXT

PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
AC_SUBST(PROGRAMNAME_LOCALEDIR)IdéalL'idéal serait que vous <ulink url="http://www.gtkmm.org/bugs.shtml">fournissiez un patch</ulink> pour le fichier <filename>docs/tutorial/C/gtkmm-tutorial-in.xml</filename>. Ce fichier est actuellement dans le module <literal>gtkmm-documentation</literal> du dépôt git de GNOME.Fonctions de temporisationSi un programmeur ne souhaite pas utiliser d'élément graphique à portée de classe, il peut aussi se servir d'éléments graphiques à portée de fonction. Les avantages de la portée de fonction par rapport à la portée de classe sont un masquage accru des données et une réduction des dépendances. <placeholder-1/>Si un programmeur n'a pas besoin d'allocation dynamique de mémoire, il peut se servir d'éléments graphiques automatiques à portée de classe. Un des avantages des éléments graphiques automatiques à portée de classe est que la gestion de la mémoire est regroupée en un seul endroit. Le programmeur ne risque pas de fuites de mémoire en oubliant un <literal>delete</literal> sur un élément graphique.Si tout fonctionne correctement, vous devez être capable de construire <application>gtkmm</application> et toutes ses dépendances à partir du dépôt git en exécutant la commande <command>jhbuild build</command> (ou, si vous n'avez pas précisé <application>gtkmm</application> dans la variable <varname>modules</varname>, avec la commande <command>jhbuild build gtkmm</command>). Si, pour une quelconque raison, l'objet <classname>Socket</classname> ne peut pas recevoir l'objet <classname>Plug</classname>, la fenêtre ressemblera à :Si l'énumération n'est pas du type <classname>GType</classname>, vous devrez passer comme troisième paramètre NO_GTYPE. C'est le cas lorsqu'il n'existe pas de fonction <function>*_get_type()</function> pour l'énumération C ; mais, faites attention au fait qu'il n'est pas suffisant d'inclure un en-tête supplémentaire pour cette fonction. Vous devez également faire un rapport d'anomalie concernant l'API C étant donné que toutes les énumérations doivent être enregistrées en tant que GTypes.Si la cellule du tableau est plus grande que l'élément graphique et si <literal>Gtk::FILL</literal> est indiqué, l'élément graphique sera étiré pour utiliser toute la place disponible.Si l'élément graphique tableau dispose de moins de place que nécessaire (parce que l'utilisateur a redimensionné la fenêtre), les éléments graphiques dans les cellules vont être cachés par le bas de la fenêtre. Si <literal>Gtk::SHRINK</literal> est indiqué, les éléments graphiques vont rétrécir avec le tableau.À la première utilisation d'un programme se servant de la structure des Fichiers récents, la boîte de dialogue peut initialement être vide. Sinon, elle devrait afficher la liste des documents récemment utilisés enregistrés par d'autres applications.Si vous êtes intéressé par une participation au développement de <application>gtkmm</application> ou par des corrections d'anomalies dans <application>gtkmm</application>, vous aurez certainement besoin de construire la version de développement de <application>gtkmm</application>. Toutefois, vous ne devez pas installer une version de développement sur votre version stable. Vous devez l'installer à côté de l'installation existante de <application>gtkmm</application> dans un dossier séparé.Si vous utilisez <application>gettext</application> directement, vous ne pouvez marquer pour traduction que les chaînes situées dans les fichiers de code source. Mais, si vous vous servez de <application>intltool</application>, vous pouvez marquer des chaînes pour traduction dans divers autres formats de fichier, y compris les fichiers d'interface utilisateur <application>Glade</application>, xml, <ulink url="http://standards.freedesktop.org/desktop-entry-spec/latest/">.desktop</ulink> et de nombreux autres. Donc si vous avez conçu une partie des interfaces utilisateur du projet à l'aide de <application>Glade</application>, ajoutez également vos fichiers <filename>.glade</filename> dans la liste du fichier <literal>POTFILES.in</literal>.Si vous faites appel à la fonction membre <methodname>Gtk::TreeView::set_reorderable()</methodname>, les éléments d'un objet TreeView peuvent être déplacés au sein même de la vue arborescente. Ceci est montré dans l'exemple <classname>TreeStore</classname>.Si vous avez copié l'arborescence des squelettes sources de mm-common et substitué le texte à remplacer, vous disposez déjà de fichiers <filename>Makefile.am</filename> et <filename>Doxyfile.in</filename> convenables. Avec le paramétrage de construction de mm-common, la liste des fichiers d'entrée Doxygen n'est pas définie dans le fichier de configuration Doxygen, mais passée de <command>make</command> à l'entrée standard de <command>doxygen</command>. La liste des fichiers en entrée est définie par la variable <varname>doc_input</varname> du fichier <filename>Makefile.am</filename>.Si vous copiez un <classname>RefPtr</classname>, par exemple <placeholder-1/> ou si vous le passez en tant que paramètre de fonction ou en tant que type de retour, alors le pointeur <classname>RefPtr</classname> fera tout référencement nécessaire pour assurer que cette instance ne soit pas détruite avant que le <classname>RefPtr</classname> ne soit pas hors de portée.Si vous décidez de contribuer, veuillez poster votre contribution sur la liste de diffusion de <application>gtkmm</application> à l'adresse <ulink url="mailto:gtkmm-list@gnome.org">&lt;gtkmm-list@gnome.org&gt;</ulink>. Également, prenez note que la totalité de ce document est libre et que tout ajout que vous feriez doit également être libre. Ce qui signifie que quiconque peut se servir de tout ou partie de vos exemples dans ses programmes et que les copies de ce document (y compris votre contribution) peuvent être diffusées gratuitement.Si vous ne voulez pas rechercher un URI donné, mais au lieu de cela, voulez obtenir la liste de tous les éléments récemment utilisés, <classname>RecentManager</classname> dispose de la fonction <methodname>get_items()</methodname>. La valeur renvoyée peut être assignée à n'importe quel conteneur standard C++ (par exemple, <classname>std::vector</classname>, <classname>std::list</classname>, etc) ; elle contient la liste de tous les fichiers récemment utilisés jusqu'à la limite indiquée par l'utilisateur [FIXME : quelle est la limite par défaut ?]. Le code ci-après montre comment obtenir une liste des fichiers récemment utilisés :Si vous avez créé un <classname>Tag</classname> et l'avez ajouté à l'objet <classname>TagTable</classname>, vous pouvez appliquer cette balise sur une partie du texte du <classname>TextBuffer</classname> et faire ainsi en sorte que ce texte soit affiché avec ce format. Vous définissez le début et la fin de la plage de texte en définissant des marqueurs du type  <classname>Gtk::TextBuffer::iterator</classname>. Par exemple :Si vous partagez une structure d'ajustement entre un élément Scrollbar et un élément TextView, la manipulation de la barre de défilement ajustera comme par magie l'élément TextView. Vous pouvez définir cela comme suit :Si vous utilisez un gestionnaire de signal pour capter le même signal à partir de plusieurs éléments graphiques, vous pouvez souhaiter que le gestionnaire de signal reçoive des informations supplémentaires. Par exemple, savoir quel bouton a été cliqué. Vous pouvez réaliser cela avec <function>sigc::bind()</function>. Voici du code extrait de l'exemple <link linkend="sec-helloworld2">helloworld2</link> déjà rencontré plus haut. <placeholder-1/> Ce code indique que nous voulons que le signal envoie une valeur supplémentaire de type <classname>Glib::ustring</classname> au gestionnaire et que sa valeur soit égale à « bouton 1 ». Bien évidemment, nous devons ajouter ce paramètre supplémentaire dans la déclaration de fonction de notre gestionnaire de signal : <placeholder-2/> Bien évidemment encore, un gestionnaire normal de signal « clicked » ne comporterait pas de paramètre.Si vous souhaitez participer au développement de <application>gtkmm</application> ou expérimenter de nouvelles fonctionnalités, vous pouvez installer <application>gtkmm</application> à partir du dépôt « git ». La plupart des utilisateurs n'ont jamais besoin de faire ainsi, mais si vous êtes intéressé par une participation au développement de <application>gtkmm</application>, consultez l'annexe <link linkend="chapter-working-with-source">Travail sur le code source de gtkmm</link>Si vous voulez enregistrer un fichier avec ses métadonnées, passez un paramètre <classname>RecentManager::Data</classname> à la fonction membre <methodname>add_item()</methodname>. Les métadonnées pouvant être définies sur un élément fichier donné sont :Si vous voulez définir une fonction membre appelée quand il n'y aucune autre activité en cours, utilisez :Si vous voulez en savoir plus à propos des pointeurs intelligents, vous pouvez consulter les ouvrages suivants : <placeholder-1/>Si vous avez tiré une série de traits formant un chemin, vous pouvez vouloir les raccorder d'une certaine façon. Cairo offre trois façons différentes de raccorder les lignes entre elles : l'onglet, le biseau et l'arrondi. Voyez-les ci-dessous :Si vous n'avez jamais utilisé auparavant un utilitaire d'empaquetage, son utilisation nécessitera une prise en main. Toutefois, vous constaterez probablement que, contrairement à d'autres boîtes à outils, il n'y a pas besoin de faire appel à un éditeur de type visuel.Si votre distribution ne met pas à disposition un paquet pré-compilé de <application>gtkmm</application>, ou bien si vous souhaitez installer une version différente de celle fournie, vous pouvez installer <application>gtkmm</application> à partir des sources. Le code source de <application>gtkmm</application> est téléchargeable à partir de <ulink url="http://www.gtkmm.org/"/>.Si votre programme est un logiciel libre, il existe un sous-projet complet <literal>GNOME</literal> dédié à l'aide à la traduction, le <ulink url="http://developer.gnome.org/projects/gtp/">Projet de traduction <literal>GNOME</literal></ulink> (GNOME Translation Project).Implémentation d'une logique personnalisée pour les cellules modifiables.Dans <filename>configure.ac</filename>, <placeholder-1/>dans <filename>skeleton/skeletonmm/Makefile.am</filename>, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :dans <filename>skeleton/src/Makefile.am</filename>, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :En plus de la possibilité d'intégrer des éléments dans la liste, vous pouvez aussi faire une recherche d'éléments déjà présents dans la liste, les modifier ou les enlever.En plus de modifier l'URI d'un fichier, vous pouvez enlever des éléments de la liste, soit un à un, soit tous à la fois. La première opération s'effectue avec <methodname>remove_item()</methodname>, la dernière avec <methodname>purge_items()</methodname>.En plus du tracé élémentaire de droites, vous pouvez personnaliser un certain nombre de choses dans les tracés de lignes. Nous avons déjà vu des exemples de paramétrage de couleur et d'épaisseur de trait, mais il en existe bien d'autres.Outre la possibilité de tracer des droites, Cairo vous permet de tracer facilement des lignes courbes (techniquement une courbe de Bézier d'ordre 3) avec les fonctions <methodname>Cairo::Context::curve_to()</methodname> et <methodname>Cairo::Context::rel_curve_to()</methodname>. Ces fonctions prennent en paramètres les coordonnées des extrémités ainsi que celles de deux points de « contrôle ». Ce sera plus facile à expliquer sur un exemple, alors lançons-nous.En règle générale, les projets du style gtkmm utilisent Doxygen, qui lit les commentaires dans un format particulier et génère une documentation HTML. Vous pouvez écrire ces commentaires doxygen directement dans les fichiers d'en-tête.Dans le paragraphe <link linkend="sec-wrapping-hg-files">Fichiers .hg et .ccg</link> vous pouvez voir la syntaxe utilisée dans ces fichiers.Dans l'exemple ci-dessus nous avons tout tracé en utilisant des coordonnées absolues. Nous pouvons également tracer en coordonnées relatives. Pour une droite, on utilise la fonction <methodname>Cairo::Context::rel_line_to()</methodname>.Dans l'exemple ci-après, nous créons une fenêtre avec trois boutons dans un tableau 2 x 2. Les deux premiers boutons sont placés dans la ligne supérieure. Le troisième bouton est placé dans la ligne inférieure et occupe les deux colonnes.Dans l'exemple ci-après, nous créons une fenêtre avec trois boutons dans une grille. Les deux premiers boutons sont placés dans la ligne supérieure de gauche à droite. Le troisième bouton est attaché sous le premier bouton, dans une nouvelle ligne inférieur et occupe deux colonnes.Dans les directives ci-dessous, nous supposons que vous n'utilisez pas <application>gettext</application> directement, mais <application>intltool</application> qui a été spécialement écrit pour <literal>GNOME</literal>. <application>intltool</application> utilise <function>gettext()</function> pour extraire les chaînes du code source, mais <application>intltool</application> peut aussi combiner, dans les fichiers standards <filename>.pot/.po</filename> de <application>gettext</application>, les chaînes provenant d'autres fichiers : par exemple, des détails de menu du bureau ou de ressources d'interface utilisateur comme les fichiers <application>Glade</application>.Dans le fichier Makefile.am principal : <placeholder-1/>Dans ce cas, vous pouvez ajouter des caractères supplémentaires à la chaîne. Par exemple, écrivez <literal>"jumps[noun]"</literal> et <literal>"jumps[verb]"</literal> au lieu de <literal>"jumps"</literal> uniquement et extrayez-les à nouveau avec un appel à <function>gettext</function>. Si vous ajoutez des caractères supplémentaires, vous devez également ajouter un commentaire pour les traducteurs avant l'appel de <function>gettext</function>. De tels commentaires s'affichent dans les fichiers <filename>.po</filename>. Par exemple :Dans cet exemple, nous allons écrire un programme <application>gtkmm</application> petit, mais pleinement fonctionnel, et tracer quelques lignes dans la fenêtre. Les lignes sont dessinées en créant un chemin, puis en le traçant. Un tracé est créé avec les fonctions <methodname>Cairo::Context::move_to()</methodname> et <methodname>Cairo::Context::line_to()</methodname>. La fonction <methodname>move_to()</methodname> est semblable à l'action de lever la pointe de votre crayon au dessus du papier et de la placer quelque part ailleurs — aucune ligne n'est tracée entre le point où vous étiez et celui où vous vous êtes déplacé. Pour tracer une ligne entre deux points, utilisez la fonction <methodname>line_to()</methodname>.Dans ce paragraphe du tutoriel, nous voyons le modèle du tracé de base Cairo ; nous décrivons chacun des éléments de tracé de base dans le détail (avec des exemples) et ensuite nous présentons une application simple utilisant Cairo pour dessiner un élément graphique d'horloge analogique.Dans votre <literal>src/Makefile.am</literal>, mettez à jour votre variable <literal>AM_CPPFLAGS</literal> en ajoutant la définition de macro préprocesseur suivante :Dans votre fonction de rappel, comparez la liste des cibles disponibles avec celle des cibles que votre application prend en charge pour le collage. Vous pouvez activer ou désactiver un élément de menu Coller selon que le collage est ou n'est pas actuellement possible. Par exemple :Dans le gestionnaire de signal, vous devriez examiner la nouvelle valeur et l'enregistrer dans le modèle si vous la jugez appropriée pour l'application.inclut les autres fichiers.Vues d'un même modèle triées de manière indépendanteInfobarreL'héritage s'utilise pour dériver de nouveaux éléments graphiques. Dans un code C de GTK+, ce processus de dérivation est si complexe et sujet à erreur que quasiment aucun programmeur C ne l'utilise. En tant que développeur C++, vous savez que la dérivation est une technique essentielle dans la programmation orientée objet.InitialisationInstallationInstallation de <application>gtkmm</application> avec <application>jhbuild</application>Installation à partir des sourcesInstallation et utilisation de la version git de <application>gtkmm</application>Au lieu de connecter laborieusement les gestionnaires de signal aux signaux, vous pouvez simplement créer une nouvelle classe qui hérite d'un élément graphique — disons, un bouton —, puis surdéfinir le gestionnaire de signal par défaut, tel que Button::on_clicked(). Cela peut se révéler plus simple que d'accrocher des gestionnaires de signal pour chaque chose.Types intermédiairesInternationalisation et adaptation localeInternationalisation des applications GNOMEFichier README de IntltoolIntroductionIl est de la même forme. Le nombre 3 à la fin du nom du type indique que le gestionnaire de signal nécessite trois paramètres. Le premier type dans la liste des types est <literal>void</literal>, c'est le type de retour du gestionnaire de signal. Les trois types suivants sont les types des paramètres, dans l'ordre. Notre prototype de gestionnaire de signal ressemble à quelque chose comme :il est courant pour les modules de liaison de garder trace du numéro de version de la bibliothèque qu'ils habillent. Ainsi, par exemple, si la bibliothèque C est à la version 1.23.4, alors la version initiale du module de liaison sera 1.23.0. Évitez toutefois de démarrer avec un numéro de version mineur pair, car il indique traditionnellement une version stable.Il est de bonne pratique de placer toute modification de l'état graphique entre des appels aux fonctions <methodname>save()</methodname>/<methodname>restore()</methodname>. Par exemple, si vous avez une fonction qui prend en paramètre une référence à un <classname>Cairo::Context</classname>, vous pouvez l'implémenter comme suit :prend en charge le collage de 2 cibles — d'une part la cible personnalisée, d'autre part une cible texte créant un représentation textuelle arbitraire des données personnalisées,utilise <methodname>request_targets()</methodname> et le signal <literal>owner_change</literal> et désactive le bouton Coller s'il ne peut pas utiliser les données du presse-papier.Il n'est pas possible de prévoir l'espace nécessaire à un texte après traduction en d'autres langues ou après affichage avec une police différente. Sur Unix, il est également impossible d'anticiper les effets de chaque thème ou de chaque gestionnaire de fenêtres.Il est possible que certaines chaînes soient marquées <literal>fuzzy</literal> (approximatives) dans le fichier <filename>.po</filename>. Les traductions ainsi marquées ne se substituent pas à la chaîne originelle. Pour qu'elles apparaissent, enlevez simplement la marque <literal>fuzzy</literal>.Itération parmi les colonnes du modèleItérateursJonathonJongsmaappelle simplement la version non-const de la même fonction au lieu de générer du code dupliqué.Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur <classname>RefPtr</classname> ne pointe sur rien.ÉtiquetteLes étiquettes sont le moyen essentiel pour placer du texte non-modifiable dans une fenêtre, par exemple pour placer un intitulé à côté de l'élément graphique <classname>Entry</classname>. Vous pouvez définir le texte dans le constructeur ou, plus tard, à l'aide des fonctions membres <methodname>set_text()</methodname> ou <methodname>set_markup()</methodname>.Perte de propriétésLaursenelle requiert moins de code C++,Regardons un exemple de surdéfinition :Regardons un <literal>helloworld</literal> légèrement perfectionné en se servant de nos nouvelles connaissances.Examinons à nouveau la fonction membre <literal>connect</literal> d'un signal :De même que les cases à cocher, les boutons radio héritent aussi des propriétés des <classname>Gtk::ToggleButton</classname>, mais les boutons radio fonctionnent en groupe et, dans un groupe, un seul et unique bouton radio peut être sélectionné à un moment donné.Comme pour un <classname>TreeView</classname>, vous pouvez placer l'objet <classname>TextView</classname> dans un objet <classname>ScrolledWindow</classname> pour permettre à l'utilisateur d'explorer la totalité du texte à l'aide de barres de défilement.De même, remplacez toutes les occurrences de <varname>Joe Hacker</varname> par le nom du détenteur du copyright — vous, probablement. Faites de même pour l'adresse courriel <varname>joe@example.com</varname>.Les fins de ligne peuvent avoir différents styles également. Le style par défaut est de débuter et arrêter la ligne exactement aux points de définition. On nomme cela la coupe droite. Les autres options sont l'arrondi (utilise une terminaison en demi-cercle, le centre du demi-cercle étant au point terminal de la ligne) ou le carré (utilise une terminaison carrée diagonale, le centre du carré étant au point terminal de la ligne). Ce paramétrage est défini avec la fonction <methodname>Cairo::Context::set_line_cap()</methodname>.Styles de traitListStoreModèle listStore, pour des colonnesChargement du fichier .gladeExamen des éléments de la liste des fichiers récentsNombre de programmeurs ont besoin d'implémenter des menus contextuels s'ouvrant d'un clic droit de souris sur des objets <classname>TreeView</classname>. Pour vous faire gagner du temps, nous allons expliquer ici comment faire. À un ou deux points près, cela ressemble tout à fait à un menu contextuel normal tel que décrit dans le <link linkend="sec-menus-popup">chapitre Menus</link>.Menu principalExemple de menu principalFichiers Makefile.amÉléments graphiques gérésBeaucoup de fonctions de dessin de Cairo disposent d'une variante <methodname>_preserve()</methodname>. Normalement, les fonctions de dessin telles que <methodname>clip()</methodname>, <methodname>fill()</methodname> ou <methodname>stroke()</methodname> effacent le chemin actuel. Si vous utilisez la variante <methodname>_preserve()</methodname>, le chemin actuel sera préservé de sorte que vous pouvez à nouveau l'utiliser avec une autre fonction de dessin.Beaucoup de boîtes à outils GUI exigent que les éléments graphiques soient placés avec précision dans une fenêtre, avec un positionnement absolu, souvent en utilisant un utilitaire visuel. Plusieurs problèmes en découlent :Marquage des chaînes à traduireMarkoMarquagesIl est possible que l'utilisateur n'ait pas le droit de sélectionner tous les éléments d'une liste ou d'une arborescence. Ainsi, dans le programme gtk-demo, vous pouvez choisir un exemple pour voir le code source, mais choisir une catégorie d'exemples n'a pas de sens.L'utilisation des instances membres simplifie la gestion de la mémoire. Tous les éléments graphiques C de GTK+ sont traités en utilisant des pointeurs. Vous savez, comme tout programmeur C++, que les pointeurs doivent, si possible, être évités.Gestion de la mémoireMenus et barres d'outilsBoîte de dialogue MessageMacros pour fonctions membresFonctions membresWindows MicrosoftÉléments graphiques diversMélange des API C et C++Modèle colonnesModelColumns()
{ add(m_col_id); add(m_col_name); }

  Gtk::TreeModelColumn&lt;int&gt; m_col_id;
  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
};

ModelColumns m_columns;Modification des fichiers de constructionModification de la liste des fichiers récentsFonctions de contrôle des entrées/sortiesDes informations supplémentaires sur le processus d'internationalisation et de localisation sont présentées et commentées dans : <placeholder-1/>Plus d'une colonne de modèle par colonne de vueLa plupart des applications ne disposent que d'une fenêtre de la classe <classname>Window</classname>, ou uniquement une fenêtre principale. Ces applications peuvent utiliser la surdéfinition de <methodname>Gtk::Main::run(Gtk::Window&amp;)</methodname>. Elle affiche la fenêtre et rend la main quand la fenêtre a été cachée. Ceci se produit quand l'utilisateur ferme la fenêtre ou quand le code applique la fonction <methodname>hide()</methodname> sur la fenêtre. Vous pouvez empêcher l'utilisateur de fermer la fenêtre (par exemple, s'il y a des modifications non enregistrées) en surdéfinissant <methodname>Gtk::Window::on_delete_event()</methodname>.La plupart des éléments graphiques personnalisés nécessitent leur propre <classname>Gdk::Window</classname> pour tracer dessus. Alors vous pouvez appeler <methodname>Gtk::Widget::set_has_window(true)</methodname> dans votre constructeur (c'est la valeur par défaut). Si vous n'appelez pas <methodname>set_has_window(false)</methodname>, vous devez surdéfinir <methodname>on_realize()</methodname> et appeler à partir de là <methodname>Gtk::Widget::set_realized()</methodname> et <methodname>Gtk::Widget::set_window()</methodname>.La plupart de nos exemples utilisent cette technique.La plupart des chapitres de cet ouvrage traitent d'éléments graphiques spécifiques. Consultez la section <link linkend="chapter-container-widgets">Éléments graphiques conteneurs</link> pour de plus amples précisions sur la manière de placer des éléments graphiques dans des conteneurs.La plupart des fonctions membres utiles de cette classe sont en fait dans la classe de base <classname>Gtk::FileChooser</classname>.Beaucoup d'empaquetages utilisent des boîtes comme dans l'exemple précédent. Ce sont des conteneurs invisibles dans lesquels nous pouvons placer les éléments graphiques. Si nous empaquetons dans une boîte horizontale, les objets seront insérés horizontalement de la gauche vers la droite ou inversement selon que l'on utilise <methodname>pack_start()</methodname> ou <methodname>pack_end()</methodname>. Dans une boîte verticale, les éléments graphiques sont empaquetés du haut vers le bas ou vice versa. Vous pouvez utiliser toute combinaison de boîtes dans ou à côté d'autres boîtes pour créer les effets voulus.DéplacementConteneurs multi-élémentsLes éléments graphiques conteneurs multi-éléments héritent de la classe <classname>Gtk::Container</classname> ; comme avec <classname>Gtk::Bin</classname>, vous utilisez les fonctions membres <methodname>add()</methodname> et <methodname>remove()</methodname> pour ajouter ou supprimer des éléments graphiques du conteneur. Mais, contrairement à <methodname>Gtk::Bin::remove()</methodname>, la fonction membre <methodname>remove()</methodname> de la classe <classname>Gtk::Container</classname> exige un paramètre désignant l'élément graphique à enlever.MurrayMurray CummingPuis nous appelons la fonction membre <methodname>set_border_width()</methodname> de l'objet Window. Elle fixe la dimension de l'espace entre les côtés de la fenêtre et l'élément graphique qu'elle contient.Ensuite nous définissons un objet de la classe <classname>HelloWorld</classname> dont le constructeur ne prend pas de paramètres ; il n'est pas encore visible. Quand nous appelons Gtk::Main::run(), avec comme paramètre la fenêtre helloworld, la fonction main() affiche la fenêtre et démarre la <emphasis>boucle des événements</emphasis> <application>gtkmm</application>. Lorsque la boucle des événements <application>gtkmm</application> est inactive, elle est en attente des actions de l'utilisateur pour y répondre de façon appropriée. Quand l'utilisateur ferme la fenêtre, la fonction run() retourne et déclenche l'exécution de la dernière ligne de la fonction main(). Et le programme se termine.Ensuite nous devons adapter les divers fichiers <filename>Makefile.am</filename> : <placeholder-1/>Vous devez ensuite créer un <classname>UIManager</classname> dans lequel vous ajoutez les objets <classname>ActionGroup</classname> avec <methodname>insert_action_group()</methodname>. Il est judicieux d'indiquer à cet instant à la fenêtre parent de répondre aux raccourcis claviers avec la fonction membre <methodname>add_accel_group()</methodname>.Puis, nous utilisons la fonction membre <methodname>add()</methodname> avec l'objet Window pour y placer le <literal>m_button</literal> (<methodname>add()</methodname> est une fonction membre de la classe <classname>Gtk::Container</classname> que nous décrirons dans le chapitre des éléments graphiques conteneurs). La fonction <methodname>add()</methodname> place l'élément graphique dans la fenêtre, mais elle ne l'affiche pas. Les éléments graphiques <application>gtkmm</application> sont toujours invisibles à leur création — pour les afficher, vous devez faire appel à la fonction <methodname>show()</methodname>, ce que nous faisons à la ligne suivante.Nicolai M. Josuttis, « The C++ Standard Library » - chapitre 4.2Gestion classique de la mémoire en C++Notez aussi que tous les éléments graphiques ne reçoivent pas tous les événements X par défaut. Pour recevoir des événements X supplémentaires, vous pouvez utiliser <methodname>Gtk::Widget::set_events()</methodname> avant d'afficher l'élément graphique ou <methodname>Gtk::Widget::add_events()</methodname> après. Toutefois, certains éléments graphiques doivent préalablement avoir été placés dans un élément graphique <classname>EventBox</classname>. Consultez le chapitre <link linkend="chapter-widgets-without-xwindows">Éléments graphiques sans fenêtre-X</link>.Notez que UTF-8 n'est pas compatible avec des encodages 8 bits comme ISO-8859-1. Par exemple, les trémas de l'allemand ne font pas partie de la gamme des caractères ASCII ; ils nécessitent plus d'un octet en UTF-8. Si votre code comporte des chaînes littérales sur 8 bits, vous devez les convertir en UTF-8 (par exemple, la formule de salut bavaroise « Grüß Gott » devient « Gr\xC3\xBC\xC3\x9F Gott »).Notez que les fichiers avec l'extension <filename>.in</filename> seront utilisés pour générer des fichiers de même nom, mais sans extension, en remplaçant certaines variables par leur vraie valeur pendant la phase de traitement par le script configure.Notez que si vous mentionnez des modules complémentaires en plus de ceux pour gtkmm-2.4, ils doivent être séparés par des espaces et non des virgules.Notez que dans ce cas, nous avons pratiquement tout exprimé en termes de hauteur et de largeur de la fenêtre, y compris la largeur des lignes. En raison de cela, quand vous redimensionnez la fenêtre, tous les objets se mettent à l'échelle. Également, il y a trois parties concernant les tracés dans la fonction et chacune est entourée avec une paire <methodname>save()</methodname>/<methodname>restore()</methodname> pour revenir à un état bien défini après chaque tracé.Notez que la plupart des équipes de traducteurs ne sont constituées que de 1 à 3 personnes ; donc, si votre programme comporte beaucoup de chaînes, cela peut prendre beaucoup de temps avant que quelqu'un ait le temps d'y jeter un coup d'œil. De plus, pas mal de traducteurs ne souhaitent pas dilapider leur temps (la traduction est une tâche très consommatrice de temps) donc, il ne prendront en charge votre projet que s'il est vraiment sérieux (dans le sens, travaillé et maintenu) ; si ce n'est pas le cas il peuvent décider de s'occuper sur d'autres projets.Notez que l'origine du système de coordonnées est l'angle supérieur gauche.Notez que les exemplaires de colonnes (tels que m_Columns ici) ne sont habituellement pas qualifiés « static », étant donné qu'ils doivent être instanciés après que glibmm l'ait été lui-même.Notez que les noms des actions, tels qu'ils seront vus par l'utilisateur dans les menus et les barres d'outils, est précisé ici. En les plaçant dans la macro _(), ces chaînes pourront être traduites. Quand vous utilisez les éléments du catalogue Gtk::Stock, les traductions sont, bien entendu, automatiquement accessibles.Notez que pour construire <application>gtkmm</application> à partir du dépôt git, il vous sera nécessaire de construire toutes ses dépendances à partir de git également. <application>jhbuild</application> facilite également cette opération par comparaison avec ce qu'elle représenterait normalement sans lui, mais la construction et l'installation du tout demande tout de même pas mal de temps. Vous serez probablement confrontés à des problèmes de construction, mais ils sont en règle générale rapidement corrigés si vous les rapportez.Notez que nous découpons la surface nécessitant d'être redessinée exactement comme nous l'avions fait dans l'exemple précédent. Après découpe, toutefois, nous faisons appel à <methodname>Cairo::Context::scale()</methodname> en passant à cette fonction la largeur et la hauteur de cette surface de tracé. Le système de coordonnées de l'espace utilisateur est ainsi gradué de telle sorte que la hauteur et la largeur du élément graphique ont tous deux une mesure de 1,0 « unité ». Il n'y avait pas de raison particulière de modifier la graduation du système de coordonnées dans notre cas, mais cela peut quelquefois faciliter les opérations de tracé.Notez que nous ne passons pas directement un pointeur sur <methodname>on_button_clicked()</methodname> à la fonction membre <methodname>connect()</methodname> du signal. À la place, nous faisons appel à <function>sigc::ptr_fun()</function> et passons le résultat à <methodname>connect()</methodname>.Notez qu'il n'est pas possible d'écrire simplement <placeholder-1/> étant donné que <methodname>set_group()</methodname> modifie le groupe et qu'en conséquence, le pointeur n'est pas constant.Notez que vous devez définir des actions pour les éléments de sous-menus de la même manière que pour les menus.Notez qu'en raison du système des thèmes d'apparence de GTK+, l'aspect de ces éléments graphiques peut varier. Dans le cas des cases à cocher et des boutons radio, les variations peuvent être conséquentes.Notez, toutefois, que la vue arborescente fournit des itérateurs sur le modèle trié. Vous devez les convertir en itérateurs du modèle enfant sous-jacent pour effectuer des opérations sur ce modèle. Par exemple :Bloc-noteNotez que la valeur de retour est du type <classname>sigc::signal&lt;void,int&gt;::iterator</classname>. Celle-ci peut être implicitement convertie en <classname>sigc::connection</classname> qui peut, à son tour, être utilisée pour contrôler la connexion. En conservant un objet connexion, vous pouvez déconnecter son signal associé avec la fonction membre <methodname>sigc::connection::disconnect()</methodname>.Notez que nous appelons <command>gmmproc</command> avec comme paramètre le chemin vers les fichiers .m4 convertis, le chemin vers les fichiers .defs, le nom du fichier .hg, le répertoire source et le répertoire destination.Notez que nous avons utilisé une instruction d'initialisation pour étiqueter l'objet <literal>m_button</literal> avec « Hello World ».Maintenant examinons la fonction <function>main()</function> du programme. La voici, sans commentaire :Maintenant ré-examinons la connexion :Regardons maintenant le code qui effectue en fait le tracé. La première partie de <methodname>on_expose_event()</methodname> doit maintenant vous être familière car il s'agit de code « standardisé » pour obtenir le <classname>Gdk::Window</classname>, créer le <classname>Cairo::Context</classname> et découper la zone que nous souhaitons retracer. À nouveau cet exemple inscrit son système de coordonnées dans un carré unité : il est ainsi plus facile de tracer le cadran en proportion de la taille de la fenêtre qui est automatiquement mise à l'échelle en cas de redimensionnement. Mieux, le système de coordonnées est gradué de façon à ce que l'origine (0, 0) soit situé au centre réel de la fenêtre.Maintenant que vous disposez d'un endroit où mettre vos traductions, il est nécessaire d'initialiser <application>intltool</application> et <application>gettext</application>. Ajoutez le code ci-après dans votre fichier <literal>configure.ac</literal>, en mettant le nom de votre programme à la place de « nom_programme » :Maintenant que nous connaissons les bases de la bibliothèque graphique Cairo, nous voilà prêts pour débuter un tracé. Commençons par le plus simple des éléments de tracé : la droite. Mais d'abord, il est nécessaire d'en savoir un peu plus sur le système de coordonnées de Cairo. L'origine du système de coordonnées de Cairo se situe dans l'angle supérieur gauche de la fenêtre avec les valeurs positives de x vers la droite et de y vers le bas. <placeholder-1/>Maintenant que nous avons vu les fondements du tracé avec Cairo, rassemblons le tout et créons une application simple qui fasse effectivement quelque chose. L'exemple qui suit utilise Cairo pour créer un élément graphique <classname>Clock</classname> classique. L'horloge dispose d'aiguilles pour les secondes, les minutes et les heures ; elle se met à jour toutes les secondes.Maintenant que nous avons vu les signaux et les gestionnaires de signal dans <application>gtkmm</application>, vous aimeriez peut-être utiliser la même technique pour interagir entre vos propres classes. C'est vraiment très simple en utilisant directement la bibliothèque <application>libsigc++</application>.Maintenant nous modifions les fichiers pour les adapter à nos besoins. Il se peut que préfériez utiliser un utilitaire rechercher-remplacer agissant sur plusieurs fichiers pour cette opération, comme <command>regexxer</command>. Notez que pratiquement tous les fichiers fournis avec l'arborescence des sources squelettes contiennent du texte à substituer. Ainsi, les substitutions doivent être effectuées globalement et non pas être limitées aux fichiers Automake et Autoconf.Oui, dites-vous, c'est bien beau, mais que faire si je souhaite créer mes propres gestionnaires pour répondre à la modification par l'utilisateur d'un élément graphique <classname>Range</classname> ou <classname>SpinButton</classname>. Pour avoir accès à la valeur du paramètre <parameter>value</parameter> d'un <classname>Gtk::Adjustment</classname>, utilisez les fonctions membres <methodname>get_value()</methodname> et <methodname>set_value()</methodname>.objets et fonctionsLes objets du type <classname>Gdk::Bitmap</classname> ne peuvent être instanciés qu'avec la fonction <methodname>create()</methodname>. Par exemple, <placeholder-1/>Objets utilisés par l'intermédiaire d'un <classname>RefPtr</classname> : passez le <classname>RefPtr</classname> en tant que référence const, par exemple, <code>const Glib::RefPtr&lt;Gtk::Action&gt;&amp; action</code>.Parfois, vous voudrez que le contenu d'un élément graphique <classname>Entry</classname> soit en lecture seule. Vous obtenez ce résultat en passant le paramètre <literal>false</literal> à la fonction membre <methodname>set_editable()</methodname>.Cela signifie bien sûr que vous pouvez stocker les <classname>RefPtrs</classname> dans des conteneurs standards tels que <classname>std::vector</classname> ou <classname>std::list</classname>.Bien entendu, le conteneur de haut niveau n'est pas intégré dans un autre conteneur. Le programmeur est responsable de la destruction du conteneur de haut niveau en utilisant les techniques habituelles du C++. Ainsi, votre fenêtre principale ne peut être qu'une instance dans votre fonction <function>main()</function>.OleSous Unix, le gestionnaire d'aperçu par défaut utilise un programme externe de visualisation. Sous Windows, la boîte de dialogue d'aperçu native est affichée. Si nécessaire, vous pouvez surdéfinir ce comportement et fournir une boîte de dialogue d'aperçu personnalisée. Consultez l'exemple dans le dossier <filename>/examples/book/printing/advanced</filename>.Après avoir construit votre logiciel, vous devez également le lancer dans l'environnement jhbuild. Pour ce faire, vous pouvez une nouvelle fois utiliser la commande <command>jhbuild shell</command> pour ouvrir un nouveau shell dans l'environnement <application>jhbuild</application>. Autrement, vous pouvez lancer une commande à effet unique dans l'environnement <application>jhbuild</application> avec la commande suivante : <command>jhbuild run command-name</command>. Dans ce cas, la commande se déroule avec les variables d'environnement correctement fixées, mais elle retourne dans l'environnement précédent à la sortie du programme.Après avoir configuré <application>jhbuild</application> comme décrit plus haut, la construction de <application>gtkmm</application> devrait être relativement simple. Avant de lancer une première fois <application>jhbuild</application>, effectuez la séquence de commandes suivante pour vous assurer que <application>jhbuild</application> dispose bien des outils voulus et pour vérifier que <application>jhbuild</application> est correctement paramétré : <screen>$ jhbuild bootstrap
$ jhbuild sanitycheck</screen>Un des avantages de UTF-8 est que son utilisation n'est pas obligatoire, sauf à le vouloir ; vous n'avez pas besoin de retoucher tout votre code sur le champ. <classname>std::string</classname> fonctionne toujours bien avec les chaînes ASCII 7 bits. Mais si vous essayez de régionaliser vos applications pour des langues comme le chinois, par exemple, vous constaterez des erreurs étranges, voire des blocages. Alors, il ne vous reste plus qu'à utiliser dès maintenant <classname>Glib::ustring</classname> à la place.Un des avantages majeurs de <application>gtkmm</application> est que <application>gtkmm</application> est multiplate-forme. Les programmes <application>gtkmm</application> écrits sur des plate-formes telles que GNU/Linux peuvent généralement être portées sur Windows (et vice versa) avec peu de modifications des sources.Openismus fournit une <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">Aide sur les fondamentaux avec automake et autoconf</ulink>.Vous pouvez également définir le balisage dès l'insertion du texte : refBuffer-&gt;insert_with_tag(iter, "Un peu de texte", refTagMatch);Autres macros :D'autres macros, telles que <function>_WRAP_METHOD()</function> et <function>_SIGNAL()</function> ne peuvent être utilisées qu'après un appel de la macro <function>_CLASS_*</function>.Autres fonctions membresOutre le nom du signal (<literal>focus</literal>), deux choses sont importantes à noter ici : le nombre suivant le mot <classname>SignalProxy</classname> (1, dans notre cas), et les types de la liste (<literal>bool</literal> et <literal>Gtk::DirectionType</literal>). Le nombre indique le nombre de paramètres que le gestionnaire de signal doit posséder, le premier type, <literal>bool</literal>, est le type de retour du gestionnaire de signal et le suivant, <literal>Gtk::DirectionType</literal>, est le type du premier et unique paramètre de ce signal. En consultant la documentation de référence, vous pouvez également prendre connaissance des noms des arguments.Nos exemples adoptent tous la même structure. Ils suivent ces étapes pour l'utilisation d'un <classname>Élément graphique</classname> :Surdéfinition du gestionnaire de signal par défautAperçuPKG_CHECK_MODULES([MYAPP], [gtkmm-2.4 &gt;= 2.8.0])Empaquetez l'élément graphique dans un conteneur par un appel approprié, par exemple <methodname>Gtk::Container::add()</methodname> ou <methodname>pack_start()</methodname>.EmpaquetageMise en pageVoletsLes volets résultent de la division d'un élément graphique en deux parties délimitées par une séparation mobile. Il existe deux sortes d'éléments graphiques de ce type : <classname>Gtk::HPaned</classname> avec une division horizontale et <classname>Gtk::VPaned</classname> avec une division verticale.PangoParties du chapitre « Internationalisation ».CollerOptions d'empaquetage par enfantOptions d'empaquetage par conteneurPermission vous est donnée de copier, distribuer et/ou modifier ce document selon les termes de la licence de documentation libre GNU, Version 1.2 ou ultérieure publiée par la Free Software Foundation sans section inaltérable, sans texte de première page de couverture ni texte de dernière page de couverture. Vous pouvez obtenir un exemplaire de cette licence en visitant le site Web de cette organisation ou en écrivant à : Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.EmbûchesVeuillez consulter <ulink url="http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm">http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm</ulink> pour des instructions à propos de la construction de gtkmm sur Windows.GreffonsGreffons et connecteursExemple greffons et connecteursMenu contextuelMenu contextuelExemple de menu contextuelMenus contextuelsPaquets logiciels pré-compilésPréparation du projetTout à fait palpitant, n'est-ce-pas ? Examinons le code. D'abord, la classe <classname>HelloWorld</classname> :Empêcher la sélection de lignesAperçuObjet PrintOperationImpressionImpression - SimpleLa prise en charge de l'impression est disponible dans les versions <application>gtkmm</application> 2.10 et ultérieures.La façon la plus courante pour créer un objet <classname>Gdk::Pixbuf</classname> est d'utiliser la fonction <methodname>Gdk::Pixbuf::create_from_file()</methodname>. Elle peut lire un fichier d'image, comme un fichier .png dans un tampon <classname>Gdk::Pixbuf</classname> prêt à être rendu.Problèmes dans l'API CProgrammation avec <application>gtkmm</application>Les barres de progression s'utilisent pour afficher l'avancement d'une opération en cours. Par exemple, un objet <classname>ProgressBar</classname> peut afficher le pourcentage de réalisation d'une tâche.Barres de progressionBouton poussoirplace le code généré dans un bloc  #ifdef. Le texte concernant l'abandon peut être précisé en tant que paramètre optionnel.Bouton radioBouton radioÉléments graphiques à plage de réglageRetour à propos de la surdéfinition des gestionnaires de signal : vous pouvez également réaliser cette surdéfinition en restant dans le domaine strict du C de GTK+ ; le système d'objets de GTK est fait pour cela. Mais dans GTK+, vous devez cheminer par des procédures complexes pour obtenir des fonctionnalités telle que l'héritage et la surdéfinition. En C++, c'est simple, car ces fonctionnalités sont prises en charge dans le langage lui-même ; vous pouvez déléguer au compilateur le soin de faire le « sale boulot ».La prise en charge des « Fichiers récents... » est disponible dans <application>gtkmm</application> version 2.10 et ultérieuresLes versions récentes de <application>gtkmm</application> sont empaquetées par pratiquement toutes les grandes distributions Linux. Donc, si vous êtes un utilisateur de Linux, vous pourrez probablement débuter avec <application>gtkmm</application> en installant son paquet à partir du dépôt officiel de votre distribution. Parmi les distributions qui mettent à disposition <application>gtkmm</application> dans leurs dépôts, citons Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, mais il y en a beaucoup d'autres.La classe RecentChooserLa classe RecentManagerDocuments récentsTechniques recommandéesRéférenceN'oubliez pas qu'avec un système d'exploitation Unix ou Linux, vous aurez besoin d'être <literal>root</literal> (avoir les privilèges administrateur) pour installer le logiciel. La commande <command>su</command> vous confère temporairement le statut d'administrateur après la saisie du mot de passe <literal>root</literal>.Souvenez-vous que ces noms sont uniquement les identifiants utilisés lors de la création des actions. Ce n'est pas le texte que l'utilisateur verra dans les menus et les barres d'outils. Nous avons indiqué les libellés lisibles par l'utilisateur lors de la création des actions.Souvenez-vous que <methodname>get_widget()</methodname> ne crée pas un nouvel exemplaire d'élément graphique ; avec cette fonction, vous obtenez simplement un pointeur sur un élément graphique qui existe déjà. Vous obtenez toujours un pointeur sur le même élément graphique quand vous appelez <methodname>get_widget()</methodname> sur le même <classname>Gtk::Builder</classname>, avec le même nom d'élément graphique. Les éléments graphiques sont créés pendant l'appel à <methodname>Gtk::Builder::create_from_file()</methodname>.Rendu de texteRéarrangement de lignesRessourcesRéponse à une modificationRéutilisation de la documentation CRiederLigne enfantRuebsamenMêmes chaînes, sémantiques différentesÉléments graphiques échelles de valeurÉléments graphiques barres de défilementLa fenêtre déroulante définit une <emphasis>politique de barres de défilement</emphasis> pour indiquer comment son objet <classname>Scrollbar</classname> doit être affiché. Cette politique est définie à l'aide de la fonction membre <methodname>set_policy()</methodname>. Le paramètre <literal>policy</literal> prend l'une des deux valeurs suivantes : <literal>Gtk::POLICY_AUTOMATIC</literal> ou bien <literal>Gtk::POLICY_ALWAYS</literal>. <literal>Gtk::POLICY_AUTOMATIC</literal> déclenche l'affichage de la barre de défilement uniquement si l'élément graphique incorporé est plus grand que la zone visible. Avec <literal>Gtk::POLICY_ALWAYS</literal>, les barres de défilement sont toujours affichées.Fenêtre à défilementDéfilementEnsuite, vérifiez si une erreur est survenue et connectez le signal <literal>status_changed</literal>. Par exemple : <placeholder-1/>Section « Structure de construction » du chapitre « Habillage des bibliothèques C avec gmmproc ».Pour voir exactement comment réaliser ceci, consultez <link linkend="sec-printing-example-simple">cet exemple</link>.Consultez le chapitre <link linkend="chapter-draganddrop">Glisser-déposer</link> pour des considérations générales sur cette fonctionnalité avec gtkmm.Consultez le chapitre sur l'<link linkend="chapter-internationalization">Internationalisation</link> pour des informations concernant les chaînes littérales UTF-8.Consultez cette <link linkend="chapter-refptr">annexe</link> pour une information détaillée concernant les RefPtr.Dans le paragraphe sur les <link linkend="sec-progressbar">Barres de progression</link>, vous pourrez voir un autre exemple d'utilisation de la classe <classname>Alignment</classname>.Définissez les attributs de l'élément graphique. Si l'élément graphique n'a pas de constructeur par défaut, vous devez l'initialiser à l'aide de la liste d'initialisations du constructeur de la classe conteneur.définissez l'intitulé de l'onglet avec <methodname>PrintOperation::set_custom_tab_label()</methodname>, créez un nouvel élément graphique et renvoyez un pointeur sur celui-ci dans le gestionnaire de signal <literal>create_custom_widget</literal>. Vous souhaiterez probablement que ce soit un élément graphique conteneur en empaquetant quelques autres.Définition d'un préfixeParamétrage de jhbuildDéfinition des valeursRessources partagéesVoici un exemple simple sur la manière d'utiliser la classe <classname>RecentChooserDialog</classname> dans un programme. Ce programme élémentaire a une barre de menus avec un élément de menu « Boîte de dialogue fichiers récents ». Quand vous choisissez cet élément de menu, une boîte apparaît : elle affiche les fichiers récemment utilisés.Séquencement des gestionnaires de signauxSignauxsignaux et propriétésLes signaux ont généralement des pointeurs de fonction dans la structure GTK, avec une valeur d'énumération correspondante, et une fonction <function>g_signal_new()</function> dans le fichier .c.SimpleExemple simple de saisieUn exemple simpleExemple simple de l'utilisation de RecentChooserWidgetExemple texte simpleUtilisation simpleLa fonctionnalité de copier-coller du texte brut est incorporée par construction pour des éléments graphiques tels que Gtk::Entry et Gtk::TextView, mais vous devez prévoir un code adapté pour faire des échanges dans le cas de vos propres formats de données. Par exemple, un programme de dessin a besoin de code spécialisé pour permettre le copier-coller dans une vue ou entre documents.Comme un objet <classname>Plug</classname> n'est qu'un type spécial de classe <classname>Gtk::Window</classname>, vous pouvez lui ajouter des conteneurs ou des éléments graphiques exactement comme vous auriez fait pour une autre fenêtre.Étant donné que la bibliothèque graphique Cairo a été écrite pour prendre en charge de multiples cibles en sortie (le système de fenêtrage X, les images PNG, Open GL, etc.), une distinction est faite entre les coordonnées dans l'espace-utilisateur et les coordonnées dans l'espace du périphérique d'affichage. La correspondance entre ces deux systèmes de coordonnées est par défaut de un pour un, de sorte que les valeurs entières du premier système correspondent grosso modo à des pixels à l'écran, mais ce réglage peut être modifié si vous le souhaitez. Quelquefois il peut être commode d'échelonner les coordonnées de sorte que la largeur et la hauteur totale d'une fenêtre se situent tous deux dans la plage de 0 à 1 (carré « unité »), ou tout autre correspondance qui fonctionnerait bien pour votre application. Ces modifications d'échelle sont effectuées à l'aide de la fonction <methodname>Cairo::Context::scale()</methodname>.Comme ceci est tout à fait semblable aux fonctions membres des paragraphes précédents, cette explication doit être suffisante pour comprendre comment cela se passe. Toutefois, voici un petit exemple :Sélection simple ou multipleConteneurs mono-élémentsJusqu'ici nous vous avons montré la réalisation d'actions en réponse à une pression de bouton à l'aide d'un gestionnaire de signal. C'est assurément un bon moyen de réaliser les choses, mais ce n'est pas le seul.Pour implémenter le tri par clic sur l'en-tête d'une colonne d'un objet <classname>TreeView</classname> afin d'ordonner son contenu, appelez <methodname>Gtk::TreeViewModel::set_sort_column()</methodname> en indiquant la colonne du modèle sur laquelle le tri est effectué quand l'en-tête est cliquée. Par exemple :Ainsi pour que les applications puissent réagir à une demande de modification, par exemple quand l'utilisateur déplace le curseur dans la barre de défilement, l'objet <classname>Gtk::Adjustment</classname> émet le signal <literal>changed</literal>. Vous pourrez alors utiliser la fonction membre <methodname>get_changed()</methodname> pour connaître la nouvelle valeur.Comme l'objet <classname>Entry</classname> peut interagir avec la liste déroulante des choix, vous devez indiquer parmi les colonnes de votre modèle quelle est la colonne texte concernée avec <methodname>set_entry_text_column()</methodname>. Par exemple : <placeholder-1/>Vous devez, soit éviter de tels cas, soit revenir à la fonction <function>sprintf()</function> du style C. Une autre solution possible est d'utiliser la <ulink url="http://www.cs.auc.dk/~olau/compose/">bibliothèque compose</ulink> qui prend en charge des syntaxes telles que :Ainsi votre application n'a pas besoin d'attendre pendant les opérations avec le presse-papier, en particulier, entre le moment où l'utilisateur sélectionne Copier et celui plus tard où il fait Coller ; la plupart des fonctions membres <classname>Gtk::Clipboard</classname> prennent comme paramètre <classname>sigc::slot</classname> qui définit les fonctions de rappel. Quand <classname>Gtk::Clipboard</classname> est prêt, il fait appel à ces fonctions membres, soit pour fournir les données requises, soit pour les demander.Ainsi, par exemple, avec un élément graphique <classname>Scale</classname>, si vous voulez modifier la rotation d'une image chaque fois que <literal>value</literal> change, vous créez une fonction de rappel du type :ConnecteursCertains éléments graphiques <application>gtkmm</application> n'ont pas de fenêtre-X associée ; ils sont affichés sur les fenêtres parentes. Pour cette raison, ils ne peuvent pas recevoir d'événements. Ainsi, s'ils ne sont pas correctement dimensionnés, ils ne seront pas rognés : vous observez alors des chevauchements désordonnés, etc. Pour recevoir des événements sur un de ces éléments graphiques, placez-le dans un conteneur <classname>EventBox</classname> et faites appel ensuite à <methodname>Gtk::Widget::set_events()</methodname> sur l'objet EventBox avant de l'afficher.Certains éléments graphiques n'ont pas de fenêtre-X associée ; ils ne sont donc pas capables de recevoir les notifications des événements X. Autrement dit : les signaux décrits au paragraphe <link linkend="sec-xeventsignals">Signaux d'événements X</link> ne seront pas émis. Si vous souhaitez capturer des événements pour ces éléments graphiques, vous devez utiliser un conteneur spécial nommé <classname>Gtk::EventBox</classname> décrit au paragraphe <link linkend="sec-eventbox">EventBox</link>.Quelques macros supplémentaires rendent ceci plus facile et plus cohérent. Regardez dans les fichiers .m4 pour des exemples. Ainsi :<placeholder-1/>Certains objets, tels que les <classname>Gdk::Pixmap</classname> et <classname>Pango::Font</classname>, s'obtiennent à partir d'un stockage partagé. Ainsi, vous ne pouvez pas créer vos propres exemplaires de ces classes. Elles héritent généralement de <classname>Glib::Object</classname>. Plutôt que vous demander de référencer et déréférencer ces objets, <application>gtkmm</application> utilise le « pointeur intelligent » <classname>RefPtr&lt;&gt;</classname>.Certains types de base utilisés dans les API C possèdent une meilleure typologie en C++. Par exemple, il n'est pas nécessaire d'avoir un type <literal>gboolean</literal> puisque le C++ dispose du type <literal>bool</literal>. La liste suivante montre quelques types couramment utilisés dans les API C, types que vous pouvez convertir dans la bibliothèque d'habillage C++.Certaines parties de l'API <application>gtkmm</application> utilisent des conteneurs de données intermédiaires, tels que <classname>Glib::StringArrayHandle</classname>, à la place des conteneurs normalisés spécifiques C++ comme <classname>std::vector</classname> ou <classname>std::list</classname>. Vous ne devez pas déclarer de variables de ces types vous-même — vous devez utiliser à la place n'importe quel conteneur normalisé C++, celui que vous préférez. <application>gtkmm</application> fera les conversions pour vous. Voici quelques-uns de ces types intermédiaires : <placeholder-1/>Quelquefois deux chaînes en anglais sont identiques, mais ont des significations différentes selon le contexte ; elles ne mériteraient donc probablement pas d'être traduites de la même façon. Comme les chaînes en anglais sont utilisées comme clés de recherche, cela pose problème.TrisTri en cliquant sur l'en-tête de colonneCode sourceSources et destinationsprécise le répertoire de destination pour les sources générées et le nom des principaux fichiers .defs que <command>gmmproc</command> doit analyser.Détails pour la définition du CellRendererBouton compteurLancez le programme <filename>plug</filename> et envoyez-le en arrière-plan (ou simplement utilisez un terminal différent) :Les chaînes littérales doivent être saisies en anglais dans le code source, mais englobées dans une macro. L'utilitaire <application>gettext</application> (ou intltool) extrait les chaînes marquées pour traduction et substitue le texte traduit lors de l'exécution.Les chaînes littérales doivent être saisies dans le code source en anglais, mais elles doivent être incorporées dans un appel à la fonction <function>gettext()</function>. Ces chaînes seront extraites pour traduction et les traductions utilisées lors de l'exécution au lieu des chaînes originelles en anglais.Sous-classez vos éléments graphiques pour mieux organiser votre code. Vous devrez probablement sous-classer au moins votre fenêtre principale <classname>Window</classname>. Ensuite, vous pouvez faire des éléments graphiques enfants et des fonctions membres gestionnaires des signaux de cette classe.Le sous-classement n'est pas toujours la meilleure façon de réaliser les choses. Il est uniquement utile quand vous souhaitez que l'élément graphique gère son propre signal par lui-même. Si vous souhaitez qu'une autre classe gère le signal, il faut se connecter à un gestionnaire séparé. C'est encore plus vrai si vous voulez que plusieurs objets gèrent le même signal ou si vous voulez qu'un seul gestionnaire de signal réponde au même signal à partir d'objets différents.TableauLes tableaux permettent de placer les éléments graphiques sur une grille, de manière identique à <classname>Gtk::Grid</classname>.Tableau des balisesBalisagesBalisages et formatsCiblesdemande à <command>gmmproc</command> d'ajouter de manière appropriée quelques définitions de types, constructeurs et fonctions membres standard à cette classe lors de l'habillage d'un type dérivé de GtkObject.indique à <command>gmmproc</command> d'inclure un en-tête à partir du fichier private/button_p.h.Vérification et ajout de traductionsLe texte est tracé par l'intermédiaire des objets « layout » tracé de Pango. Le moyen le plus facile pour créer un objet <classname>Pango::Layout</classname> est d'utiliser <methodname>create_pango_layout</methodname>. Une fois créé, le tracé peut être manipulée de diverses manières en modifiant le texte, les polices, etc. Finalement, le tracé est affiché à l'aide de la fonction membre <methodname>draw_layout</methodname> de la classe <classname>Gdk::Drawable</classname> ; il prend comme paramètres un objet <classname>Gdk::GC</classname>, une position x, une position y et un pointeur sur le tracé lui-même.Le rendu du texte s'effectue avec Pango. L'objet <classname>Pango::Layout</classname> pour l'impression est créé en appelant la fonction membre <methodname>PrintContext::create_pango_layout()</methodname>. L'objet <classname>PrintContext</classname> indique également la métrique de la page par l'intermédiaire des fonctions <methodname>get_width()</methodname> et <methodname>get_height()</methodname>. Le nombre de pages peut être fixé à l'aide de <methodname>PrintOperation::set_n_pages()</methodname>. Pour effectuer le rendu effectif du texte Pango dans <literal>on_draw_page</literal>, obtenez un <classname>Cairo::Context</classname> avec la fonction membre <methodname>PrintContext::get_cairo_context()</methodname> et affichez les objets <classname>Pango::LayoutLine</classname> qui apparaissent dans le nombre de pages demandées.Élément graphique TextViewCette commande crée un fichier nommé <filename>nom_du_programme.pot</filename>. Copiez ensuite ce fichier en lui donnant le nom <filename>code_langue.po</filename>, comme <filename>de.po</filename> ou <filename>hu.po</filename>. Ajoutez également ce code langue dans le fichier <literal>LINGUAS</literal>. Le fichier <filename>.po</filename> comporte un en-tête et une liste des chaînes en anglais, avec des emplacements pour les chaînes traduites à saisir. Assurez-vous que vous avez défini et utilisé <literal>UTF-8</literal> comme codage du fichier <filename>.po</filename> (comme défini dans l'en-tête, mais utilisé dans le contenu).Le signal « changed »L'option « Imprimer dans un fichier » est disponible dans la boîte de dialogue d'impression sans qu'il soit nécessaire de réaliser d'autres implémentations. Toutefois, il est quelquefois utile de générer un fichier .pdf directement dans le code. Par exemple, <placeholder-1/>Les fichiers .h et .cc sont générées à partir des fichiers .hg et .ccg en les traitant de la sorte avec <command>gmmproc</command>, bien que ceci se fasse automatiquement en utilisant la structure de construction suivante : <placeholder-1/>Les fichiers .hg et .ccgLes fichiers sources .hg et .ccg ressemblent tout à fait aux fichiers sources .h et .cc du C++, mais il comportent des macros supplémentaires, telles que <function>_CLASS_GOBJECT()</function> et <function>_WRAP_METHOD()</function>, à partir desquelles <command>gmmproc</command> génére le code source C++ approprié, habituellement à la même position dans l'en-tête. Tout code source C++ sera copié mot pour mot dans le fichier .h ou .cc correspondant.Le paquetage <application>GNU gettext</application> vous permet de marquer des chaînes dans le code source, de les extraire pour traduction et d'utiliser les chaînes traduites dans votre application.Le module de <application>gtkmm</application> est défini dans le jeu de modules GNOME (c'est-à-dire, <filename>gnome-2.xx.modules</filename>) ; modifiez votre fichier <filename>.jhbuildrc</filename> et fixez le paramétrage de votre module prédéfini à la dernière version de GNOME ainsi : <placeholder-1/>L'élément conteneur <classname>Alignment</classname> vous permet de placer dans une fenêtre un élément graphique dont la taille et la position sont mesurés en rapport de celle du conteneur <classname>Alignment</classname> lui-même. Par exemple, vous pourrez l'utiliser pour centrer un contrôle.L'élément graphique de la classe <classname>AspectFrame</classname> est semblable à l'élément graphique <classname>Frame</classname>, mais, en plus, il impose à l'élément graphique enfant de garder un rapport de <emphasis>proportion</emphasis> (rapport de la largeur à la hauteur) constant ; il laisse un espace libre si nécessaire. Par exemple, vous pourrez afficher une photographie sans que l'utilisateur puisse la déformer horizontalement ou verticalement lorsqu'il la redimensionne.La boîte de dialogue <classname>ColorSelectionDialog</classname> permet à l'utilisateur de choisir une couleur.Les éléments graphiques de la classe <classname>ComboBox</classname> offrent une liste (ou un arbre) de choix dans un menu déroulant. Opportunément, elle peut afficher des informations supplémentaires concernant chacun des éléments, comme du texte, une image, une case à cocher ou une barre de progression. L'élément graphique <classname>ComboBox</classname> n'autorise habituellement que les choix prédéfinis, mais il peut à l'occasion posséder une boîte <classname>Entry</classname>, permettant à l'utilisateur de saisir un texte quelconque si aucun de ceux qui sont proposés ne lui conviennent.L'élément graphique <classname>DrawingArea</classname> est une fenêtre vierge qui vous offre la possibilité de créer librement tous les graphiques voulus. Mais, en contrepartie de cette liberté, il vous incombe la responsabilité de gérer les événements d'exposition sur l'élément graphique. Quand un élément graphique est affiché pour la première fois ou quand il est couvert puis découvert, il est nécessaire de le tracer. La plupart des éléments graphiques sont pourvus de code pour effectuer ces opérations, mais l'élément graphique DrawingArea n'en dispose pas ; il vous laisse le soin d'écrire votre propre gestionnaire des signaux d'événements d'exposition pour définir la façon dont le contenu du widget sera tracé. C'est effectué le plus souvent en surdéfinissant la fonction membre virtuelle <methodname>on_expose_event()</methodname>.L'objet <classname>EntryCompletion</classname> peut utiliser une classe <classname>TreeModel</classname> contenant les entrées possibles définies à l'aide de <methodname>set_model()</methodname>. Faites ensuite appel à <methodname>set_text_column()</methodname> pour définir quelles colonnes de votre modèle doivent être utilisées pour chercher une possible concordance avec le texte saisi.La boîte de dialogue de la classe <classname>FileChooserDialog</classname> convient pour une utilisation avec les éléments de menu « Ouvrir » ou « Enregistrer ».La boîte de dialogue <classname>FontSelectionDialog</classname> permet à l'utilisateur de choisir une police de caractères.L'objet <classname>Gdk::Pixbuf</classname> peut être rendu à l'aide de la fonction membre <methodname>render_to_drawable</methodname> ; elle prend peu de paramètres. Cette fonction est une fonction membre de la classe <classname>Gdk::Pixbuf</classname> (et non <classname>Gdk::Drawable</classname>) ; elle diffère des fonctions <methodname>draw_*</methodname> décrites plus haut. Ainsi, son premier paramètre est l'objet à tracer. Le deuxième est encore le contexte <classname>Gdk::GC</classname>. Les deux paramètres suivants définissent le point de départ dans l'image à copier, suivis par le point de destination dans la zone de tracé ainsi que par la largeur et la hauteur à tracer effectivement (ce n'est pas forcément la totalité de l'image, spécialement si vous répondez à un événement d'exposition d'une partie de la fenêtre). Pour terminer, il y a les paramètres de diffusion de l'image. Si vous prenez comme type de diffusion Gdk::RGB_DITHER_NONE, les paramètres de décalage de diffusion seront tous deux égaux à 0.Le constructeur de <classname>Gtk::Adjustment</classname> crée la structure suivante :L'élément graphique <classname>Gtk::Button</classname> émet les signaux suivants, mais la plupart du temps vous ne gérerez que le signal <literal>clicked</literal> (cliqué) :L'élément graphique <classname>Gtk::TreeView</classname> peut incorporer des listes ou des arborescences de données, disposées en colonnes.Un objet <classname>ListStore</classname> contient de simples colonnes de données et chaque colonne n'a pas d'enfant.La classe <classname>PrintOperation</classname> dispose d'une fonction membre nommée <methodname>set_default_page_setup()</methodname> qui choisit par défaut une taille du papier, une orientation et des marges. Pour afficher la boîte de dialogue de mise en page dans l'application, servez-vous de la fonction membre <methodname>Gtk::run_page_setup_dialog()</methodname> qui renvoie un objet <classname>Gtk::PageSetup</classname> avec les réglages choisis. Utilisez cet objet pour mettre à jour un <classname>PrintOperation</classname> et avoir accès aux variables <classname>Gtk::PaperSize</classname>, <literal>Gtk::PageOrientation</literal> choisies ainsi qu'aux marges particulières à l'imprimante.L'objet <classname>SpinButton</classname> crée un objet <classname>Adjustment</classname> par défaut dont le pointeur est accessible avec la fonction membre <methodname>get_adjustment()</methodname>. Vous pouvez également préciser un objet <classname>Adjustment</classname> existant dans le constructeur.La classe <classname>Tag</classname> dispose de nombreuses autres propriétés.L'objet <classname>TextView</classname> crée par défaut son propre <classname>TextBuffer</classname>. Vous y accédez avec la fonction membre <methodname>get_buffer()</methodname>.L'élément graphique <classname>TextView</classname> s'utilise pour afficher et modifier de grosses quantités de texte formatté. Comme l'objet <classname>TreeView</classname>, il y a une correspondance vue/modèle. Dans le cas présent, le modèle est l'objet <classname>TextBuffer</classname>.Il est possible de faire glisser, ou simplement activer, les éléments d'un objet <classname>ToolPalette</classname>. Par exemple, l'utilisateur peut faire glisser des objets sur un canevas pour y créer de nouveaux éléments, ou bien, il peut cliquer sur un élément pour activer une taille de plume donnée dans une application de tracé.La classe <classname>TreeModelColumnRecord</classname> s'utilise pour enregistrer les colonnes et leurs types de données. Vous ajoutez des exemplaires de <classname>TreeModelColumn</classname> au <classname>ColumnRecord</classname>, puis utilisez ces <classname>TreeModelColumns</classname> pour obtenir ou placer les données dans les colonnes du modèle. Vous trouverez certainement commode de dériver un nouveau <classname>TreeModelColumnRecord</classname> incorporant vos exemplaires de <classname>TreeModelColumn</classname> en tant que données membres.L'objet <classname>TreeStore</classname> contient des colonnes de données et chaque colonne peut avoir des colonnes enfants.Nous avons déjà vu que la classe <classname>TreeView</classname> vous permet d'afficher le même <classname>TreeModel</classname> dans deux éléments graphiques <classname>TreeView</classname> distincts. Si vous avez besoin qu'un des TreeView trie le modèle de manière différente de l'autre, vous devez utiliser un objet <classname>TreeModelSort</classname> au lieu d'utiliser uniquement <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>, par exemple. <classname>TreeModelSort</classname> est un modèle contenant une version triée d'un autre modèle. Par exemple, vous pouvez ajouter une autre version triée d'un modèle à un objet <classname>TreeView</classname> ainsi :La classe <classname>Widget</classname> possède certains signaux spéciaux correspondant aux événements de la fenêtre X sous-jacente. Il possèdent le suffixe <literal>_event</literal> ; par exemple, <methodname>Widget::signal_button_pressed_event()</methodname>.Le <emphasis>principe de mise à jour</emphasis> d'un élément graphique de la classe <classname>Range</classname> définit le moment où, au cours des interactions de l'utilisateur, le champ <literal>value</literal> de l'objet <classname>Gtk::Adjustment</classname> sera modifié et le signal <literal>value_changed</literal> (valeur modifiée) émis. Les principes de mises à jour, définis avec la fonction membre <methodname>set_update_policy()</methodname>, sont les suivants : <placeholder-1/>Les fichiers <filename>.defs</filename> sont des fichiers texte, au format lisp, décrivant l'API de la bibliothèque C, y compris ses <placeholder-1/>Le script <filename>configure</filename> effectue une vérification pour s'assurer que toutes les dépendances requises sont déjà installées. Si une quelconque manque, il s'arrête et affiche une erreur.le bloc <function>AC_CONFIG_FILES()</function> doit mentionner les noms de répertoires corrects, tels que décrits ci-dessus.la ligne <function>AC_CONFIG_HEADERS()</function> est utilisée pour générer deux ou plusieurs fichier d'en-tête de configuration. Le premier fichier d'en-tête de la liste comporte toutes les macros de configuration définies pendant le lancement de configure. Les en-têtes restants de la liste ne contiennent qu'un sous-ensemble des macros de configuration et leur fichier <filename>configh.h.in</filename> correspondant ne sera pas généré automatiquement. La raison de cette séparation est que les en-têtes de configuration avec une espace dans le nom sont installées dans votre bibliothèque et définissent des macros visibles publiquement.la ligne <function>AC_CONFIG_SRCDIR()</function> doit mentionner un fichier de votre arborescence source. Vous pouvez modifier cela plus tard si vous ne connaissez pas encore les noms de certains fichiers à créer.il se peut que la ligne <function>AC_SUBST([SOMETHINGMM_MODULES], ['...'])</function> ait besoin d'être modifiée pour vérifier les dépendances adéquates.Les macros <function>_CTOR_DEFAULT()</function> et <function>_WRAP_CTOR()</function> ajoutent des constructeurs, habillant les fonctions C <function>*_new()</function> spécifiées. Ces macros supposent que l'objet C a des propriétés de même nom que les paramètres de la fonction, ce qui est habituellement le cas ; ainsi il peut fournir les paramètres directement pour l'appel de <function>g_object_new()</function>. Ces constructeurs en réalité n'appellent jamais les fonctions C <function>*_new()</function>, car gtkmm doit en fait instancier des types GTypes dérivés et les fonctions C <function>*_new()</function> ne sont conçues que comme fonctions de commodité pour les programmeurs C.L'API du <link linkend="chapter-draganddrop">glisser-déposer</link> utilise les mêmes mécanismes. Vous utiliserez probablement les mêmes formats et cibles de données à la fois pour les opérations avec le presse-papier et pour le glisser-déposer.Le <literal>const ... &amp;</literal> qui entoure les deux expressions est juste une question d'efficacité, c'est comme utiliser <classname>const std::string&amp;</classname> à la place de <classname>std::string</classname> pour un paramètre de fonction pour éviter une recopie non nécessaire.L'exemple « <literal>idéal</literal> » ci-après peut fournir plus d'une cible de presse-papier.La fonction membre <methodname>PrintOperation::run()</methodname> démarre la boucle d'impression au cours de laquelle divers signaux sont émis : <placeholder-1/>Les fonctions membres virtuelles <methodname>get_request_mode_vfunc()</methodname>, <methodname>get_preferred_width_vfunc()</methodname>, <methodname>get_preferred_height_vfunc()</methodname>, <methodname>get_preferred_width_for_height_vfunc()</methodname>, <methodname>get_preferred_height_for_width_vfunc()</methodname> et <methodname>on_size_allocate()</methodname> contrôlent la disposition des éléments graphiques enfants. Par exemple, si votre conteneur possède deux éléments graphiques enfants, l'un au dessus de l'autre, votre fonction membre <methodname>get_preferred_width_vfunc()</methodname> doit renvoyer la plus grande des largeurs des éléments graphiques enfants et <methodname>get_preferred_height_for_width_vfunc()</methodname> la somme des hauteurs. Si vous voulez de l'espace libre autour les éléments graphiques enfants, vous devez également l'additionner à la largeur et à la hauteur. Votre conteneur d'éléments graphiques se sert de ces résultats pour s'assurer que vos éléments graphiques ont assez de place. En examinant chaque parent de l'élément graphique, et les parents de celui-ci, cette logique détermine éventuellement la taille de la fenêtre de plus haut niveau.Les fonctions membres <methodname>pack_start()</methodname> et <methodname>pack_end()</methodname> placent les éléments graphiques dans ces conteneurs. La fonction membre <methodname>pack_start()</methodname> débute l'insertion en haut de l'objet <classname>VBox</classname> et va en descendant ; elle empaquette de gauche vers la droite dans un objet <classname>HBox</classname>. La fonction membre <methodname>pack_end()</methodname> fait l'inverse. Elle empaquette de bas en haut dans un <classname>VBox</classname>, de droite à gauche dans un <classname>HBox</classname>. L'utilisation de ces fonctions membres vous permet de justifier à droite ou à gauche les éléments graphiques. Nous nous servirons de <methodname>pack_start()</methodname> dans la plupart de nos exemples.La fonction membre <methodname>run()</methodname> renvoie un entier <literal>int</literal>. C'est une valeur du type <literal>Gtk::ResponseType</literal> si l'utilisateur a fermé la fenêtre en cliquant sur un bouton standard, ou bien la valeur de réponse personnalisée définie lors de l'appel à la fonction membre <methodname>add_button()</methodname>.La fonction membre <methodname>spin()</methodname> fait « tourner » le <classname>SpinButton</classname>, comme si l'une des flèches avait été cliquée. Il est nécessaire de préciser un <classname>Gtk::SpinType</classname> pour définir le sens de modification ou une nouvelle position du compteur.Les paramètres <parameter>left_attach</parameter> et <parameter>right_attach</parameter> indiquent où placer l'élément graphique et combien de cellules utiliser. Par  exemple, si vous voulez placer un bouton dans la cellule inférieure droite d'un tableau 2 x 2 et souhaitez qu'il occupe <emphasis>uniquement</emphasis> cette cellule, alors <parameter>left_attach</parameter> doit être égal à 1, <parameter>right_attach</parameter> à 2, <parameter>top_attach</parameter> à 1 et <parameter>bottom_attach</parameter> à 2. Si, d'autre part, vous souhaitez que l'élément graphique occupe la totalité de la rangée haute du tableau 2 x 2, vous définirez <parameter>left_attach</parameter> = 0, <parameter>right_attach</parameter> = 2, <parameter>top_attach</parameter> = 0 et <parameter>bottom_attach</parameter> = 1.Le paramètre <parameter>options</parameter> peut prendre une des trois valeurs suivantes : <placeholder-1/>Le paramètre <parameter>padding</parameter> définit la largeur de la bordure libre autour de l'élément graphique empaqueté.Le paramètre <parameter>value</parameter> définit la valeur initiale de l'ajustement ; habituellement, elle correspond à la position la plus haute ou la plus à gauche de l'élément graphique à plage de réglage. Les paramètres <parameter>lower</parameter> et <parameter>upper</parameter> bornent la plage des valeurs que l'ajustement est autorisé à gérer. <parameter>step_increment</parameter> est la plus petite valeur de modification incrémentale de <parameter>value</parameter>, <parameter>page_increment</parameter> la plus grande. Le paramètre <parameter>page_size</parameter> correspond communément à quelque chose comme la partie visible d'un élément graphique panneau. Le paramètre <parameter>upper</parameter> représente la coordonnée la plus basse ou la plus à droite pour un enfant d'un élément graphique panneau.Le tamponLa fonction C (par exemple, <function>gtk_entry_set_text</function>) est décrite plus précisément dans les fichiers .defs et les fichiers <filename>convert*.m4</filename> contiennent la conversion nécessaire des types de paramètres C++ vers les paramètres de type C. Cette macro génère également des commentaires pour la documentation doxygen à partir des fichiers <filename>*_docs.xml</filename> et <filename>*_docs_override.xml</filename>.Le modèle de tracé CairoLe système de coordonnées de Cairo, dans le gestionnaire de <literal>draw_page</literal>, est automatiquement tourné selon l'orientation de la page en cours. Il est normalement situé à l'intérieur des marges de l'imprimante, mais vous pouvez modifier ce réglage avec la fonction membre <methodname>PrintOperation::set_use_full_page()</methodname>. L'unité de mesure par défaut est le pixel du périphérique. Pour choisir d'autres unités, servez-vous de la fonction membre <methodname>PrintOperation::set_unit()</methodname>.Le presse-papierL'élément graphique zone de dessinLe modèleLe pointeur intelligent RefPtrLa sélectionL'élément graphique arborescenceLa présentation UI d'un menu contextuel utilise la balise <literal>popup</literal>. Par exemple :La vueLa vue est l'élément graphique (<classname>Gtk::TreeView</classname>) qui affiche concrètement les données du modèle (<classname>Gtk::TreeModel</classname>) et qui autorise l'utilisateur à interagir. Elle peut afficher, de diverses manières, toutes les colonnes du modèle ou seulement quelques unes.Il est possible, grosso modo, de diviser les éléments graphiques à plage de réglage en, d'une part, ceux dont la structure d'ajustement utilise et nécessite des valeurs précises, et ceux, d'autre part, qui considèrent ces valeurs comme des nombres arbitraires.Les paramètres de <methodname>Action::create()</methodname> définissent le nom de l'action et la manière dont celle-ci apparaîtra dans les menus et barres d'outils. Utilisez des éléments du catalogue si possible ; ainsi, il ne vous sera pas nécessaire de préciser l'étiquette, le raccourci clavier, l'icône et les infobulles ; de plus, vous bénéficierez des traductions existantes.Le concept de base du tracé dans Cairo consiste à définir des chemins « invisibles », puis à les tracer ou les remplir pour les rendre visibles.La structure de constructionL'appel à <methodname>Cairo::Context::curve_to()</methodname> est vraiment explicite en soi. Le premier couple de coordonnées définit le point de contrôle au début de la courbe, le deuxième celui à la fin de la courbe. Le dernier groupe de coordonnées indique les extrémités de la courbe. Pour faire en sorte que le concept des points de contrôle soit plus facile à visualiser, nous avons tracé une droite entre extrémité de la courbe et point de contrôle associé. Notez que ces droites (tangentes aux extrémités de la courbe) sont translucides. Ceci est réalisé à l'aide d'une variante de <methodname>set_source_rgb()</methodname> intitulée <methodname>set_source_rgba()</methodname>. Cette fonction prend un quatrième argument indiquant le coefficient alpha de la couleur (les valeurs correctes s'échelonnent entre 0 et 1).L'élément choisiLa macro de classe déclare la classe elle-même et ses relations avec le type C sous-jacent. Elle génère certains constructeurs internes, la variable membre <varname>gobject_</varname>, des définitions de types, les mécanismes d'accès aux <function>gobj()</function>, l'enregistrement du type et la fonction membre <function>Glib::wrap()</function>, entre autres choses.La fonction de rappel de nettoyage libère la mémoire utilisée par le stockage de vos données quand le presse-papier remplace ses données par d'autres.les options en ligne de commande passées au préprocesseur C.les options en ligne de commande passées au compilateur C++.La communication entre un objet <classname>Socket</classname> et un objet <classname>Plug</classname> s'effectue suivant le protocole XEmbed. Ce protocole a aussi été implémenté dans d'autres boîtes à outils (par exemple, Qt) ; cela permet un niveau d'intégration identique lorsqu'on incorpore un élément graphique Qt dans GTK+ ou vice versa.Le compilateur se plaint si vous utilisez un type inapproprié et génère, par exemple, l'erreur de compilation suivante :Le constructeur de <classname>ExampleWindow</classname> crée le menu en utilisant <classname>UIManager</classname> (consultez le <xref linkend="chapter-menus-and-toolbars"/> pour plus d'informations). Ensuite il ajoute le menu et la barre d'outils à la fenêtre.Le constructeur d'un objet <classname>Gtk::EventBox</classname> est :L'état présent d'un <classname>Cairo::Context</classname> peut être enregistré dans une pile interne de contextes enregistrés et ultérieurement rétablis dans leur état antérieur. Pour réaliser cette opération, utilisez les fonctions membres <methodname>save()</methodname> et <methodname>restore()</methodname>. Ce processus est utile si vous avez besoin de modifier temporairement l'épaisseur de trait ou la couleur (ou toute autre caractéristique graphique) pour tracer un élément puis revenir aux réglages antérieurs. Dans ce cas, appelez <methodname>Cairo::Context::save()</methodname>, modifiez les caractéristiques graphiques, effectuez le tracé, puis appelez <methodname>Cairo::Context::restore()</methodname> pour rétablir l'état graphique initial. Des appels multiples à <methodname>save()</methodname> et <methodname>restore()</methodname> peuvent être imbriqués ; chaque appel à <methodname>restore()</methodname> rétablit l'état correspondant à celui qui prévalait lors de l'appel de <methodname>save()</methodname>. <placeholder-1/>Le comportement par défaut de la classe <classname>CellRenderers</classname> suffit en règle générale, mais vous pouvez dans certains cas avoir besoin d'un contrôle plus fin. Ainsi, cet exemple de code, pris dans <filename>demos/gtk-demo/example_treestore.cc</filename>, construit manuellement un élément graphique <classname>Gtk::CellRenderer</classname> et le programme pour qu'il effectue un rendu avec variations d'aspect selon les données des diverses colonnes du modèle.L'élément graphique destination émet ce signal après que l'élément source a émis le signal <literal>drag_get</literal> : <placeholder-1/>Les signaux de glisser-déposer fournissent un objet  DragContext contenant certaines informations à propos de l'opération de glisser-déposer ; ces informations peuvent être utilisées pour influer sur le processus. Par exemple, vous pouvez faire apparaître l'élément graphique source ou modifier l'icône de glisser-déposer avec <methodname>set_icon()</methodname>. Plus important, vous pouvez faire appel à la fonction membre <methodname>drag_finish()</methodname> dans le gestionnaire du signal <literal>drag_data_received</literal> pour savoir si le dépôt a réussi ou non.<ulink url="http://library.gnome.org/devel/jhbuild/unstable/">jhbuild</ulink> facilite cette opération. <application>jhbuild</application> est un programme qui rend la construction des logiciels GNOME plus aisée en calculant les dépendances et en les construisant dans un ordre correct. Ce paragraphe vous donnera quelques explications sur la manière de paramétrer <application>jhbuild</application> pour construire et installer <application>gtkmm</application> à partir du dépôt des sources (git). Pour actualiser l'information concernant <application>jhbuild</application>, veuillez vous reporter au <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">manuel de jhbuild</ulink>. Si vous avez besoin d'aide pour utiliser <application>jhbuild</application>, adressez-vous à la <ulink url="http://mail.gnome.org/mailman/listinfo/gnome-love">liste de diffusion gnome-love</ulink>.La saisieL'exemple dans le dossier <filename>examples/book/printing/advanced</filename> démontre cette façon d'opérer.Le typedef préliminaire permet l'utilisation de cette structure dans un en-tête sans inclure sa définition complète, simplement en la pré-déclarant, par répétition de la définition de type. Cela signifie que vous n'avez pas à inclure les en-têtes de la bibliothèque C dans la bibliothèque C++ ; vous la gardez ainsi hors de votre API publique. <command>gmmproc</command> suppose qu'on utilise cette technique ; vous verrez donc des messages d'erreurs si ce n'est pas le cas.Les six premières fonctions membres dans le tableau précédent sont également surdéfinies dans les conteneurs personnalisés. Elles sont brièvement décrites dans la section <link linkend="sec-custom-containers">Conteneurs personnalisés</link>.Le premier paramètre est un objet <classname>slot</classname> appelé quand le délai est échu. Le deuxième argument est le nombre de millisecondes entre chaque appel de la fonction. Vous recevez en retour un objet <classname>sigc::connection</classname> qu'il est possible d'utiliser pour désactiver la connexion à l'aide de sa fonction membre <methodname>disconnect()</methodname> :Le premier paramètre est un connecteur qui est sollicité quand survient, sur le descripteur de fichier précisé en second paramètre, l'événement indiqué en troisième paramètre. Ce dernier définit une valeur ou plusieurs (liées avec <literal>|</literal>) parmi les suivantes :Le premier paramètre est le nombre de lignes du tableau, le second le nombre de colonnes. Si <parameter>homogeneous</parameter> est égal à <literal>true</literal>, toutes les cellules du tableau auront la même taille (la taille du plus grand élément graphique du tableau).Le premier paramètre est l'élément graphique que vous souhaitez placer dans la table.Le premier paramètre désigne l'élément graphique à empaquer. Dans notre exemple, ce sont tous des objets <classname>Button</classname>.Le premier appel à <methodname>connect()</methodname> est identique à celui que nous avons vu la fois précédente ; rien de plus à dire.La première ligne correspond à la sortie du programme <filename>plug</filename>, après qu'il a reçu notification qu'il a été incorporé dans l'objet <classname>Socket</classname>. La deuxième ligne a été émise par l'objet <filename>socket</filename> en réponse au signal <methodname>plug_added</methodname>. Si tout a été effectuée comme indiqué ci-dessus, la fenêtre <filename>socket</filename> doit ressembler grosso modo à quelque chose comme :L'exemple suivant montre deux utilisations d'un <classname>EventBox</classname> — création d'une étiquette tronquée dans une petite boîte et configuration pour qu'un clic de souris sur l'étiquette fasse quitter le programme. Le redimensionnement de la fenêtre révèle plus ou moins le contenu de l'étiquette.L'exemple suivant montre comment imprimer une saisie à partir d'une interface utilisateur. Il montre comment implémenter <literal>on_begin_print</literal> et <literal>on_draw_page</literal>, de même que suivre l'état de l'impression et mettre à jour les réglages.L'exemple suivant montre l'utilisation de la classe <classname>RadioButton</classname> :L'exemple ci-après montre comment définir un contexte Cairo avec une couleur de premier plan rouge et une épaisseur de trait de 2. Toute fonction de tracé se servant de ce contexte utilisera ces réglages.L'exemple suivant est une utilisation simple de greffons et connecteurs. La fonction membre de communication entre processus est volontairement sommaire : l'objet <classname>Plug</classname> écrit son ID dans un fichier texte nommé <filename>plug.id</filename> et le processus avec le connecteur lit cet ID à partir de ce fichier. Dans un « vrai » programme, vous utiliseriez certainement des fonctions membres de communication entre processus plus perfectionnées.Le programme suivant utilise un objet <classname>Gtk::AspectFrame</classname> pour afficher une surface de tracé dont les proportions sont toujours égales à 2:1 quelles que soient les dimensions données à la fenêtre principale par l'utilisateur.La fonction <methodname>Cairo::Context::arc_negative()</methodname> est identique à <methodname>Cairo::Context::arc()</methodname> mais les angles tournent dans le sens opposé.La fonction <methodname>Cairo::Context::paint()</methodname> est ici utilisée pour définir la couleur d'arrière-plan de la fenêtre. Cette fonction ne prend aucun paramètre et remplit la surface actuelle (ou la partie tronquée de la surface) avec la couleur source actuellement active. Après avoir défini la couleur de fond, nous traçons un cercle pour délimiter le cadran, le remplissons en blanc et soulignons le pourtour de noir. Notez que ces actions utilisent la variante <methodname>_preserve</methodname> pour conserver le chemin en cours, puis ce même chemin est découpé pour s'assurer que nos prochains tracés ne sortiront pas du pourtour du cadran.Les fonctions <methodname>move_item()</methodname>, <methodname>remove_item()</methodname> et <methodname>purge_items()</methodname> n'ont aucun effet concret sur les fichiers auxquels les URI se référent ; elles ne font que modifier la liste.Il est nécessaire de définir les dimensions de la grille dans le constructeur :Le groupe qui traite ces valeurs comme des nombres arbitraires est celui des éléments graphiques <classname>Range</classname> (les éléments <classname>Scrollbars</classname>, <classname>Scales</classname>, <classname>Progressbar</classname> et <classname>SpinButton</classname>). Ces éléments graphiques sont typiquement ceux qui sont « ajustés » directement par l'utilisateur avec la souris ou le clavier. Ils considèrent les valeurs de <parameter>lower</parameter> et <parameter>upper</parameter> comme étant les bornes de la plage des valeurs dans laquelle l'utilisateur peut définir <parameter>value</parameter>. Par défaut, l'utilisateur ne peut modifier que la grandeur <parameter>value</parameter> de l'ajustement.L'implémentation de la fonction membre <function>wrap_init()</function> dans <filename>wrap_init.cc</filename> sera générée avec <filename>generate_wrap_init.pl</filename>, mais sa déclaration dans <filename>wrap_init.h</filename> doit être codée à la main ; vous avez besoin d'ajuster <filename>wrap_init.h</filename> de sorte que la fonction <function>init()</function> apparaisse dans un espace de noms C++ correct.Le texte de l'étiquette peut être justifié avec la fonction membre <methodname>set_justify()</methodname>. L'élément graphique est également susceptible de prendre en charge le retour à ligne automatique, fonctionnalité activée avec la fonction membre <methodname>set_line_wrap()</methodname>.La dernière classe implémentant l'interface <classname>RecentChooser</classname> est <classname>RecentChooserMenu</classname>. Cette classe vous permet de lister les fichiers récemment utilisés comme un menu.La deuxième ligne affiche la fenêtre et entre dans la boucle principale de traitement, boucle dont on ne sort qu'à la fermeture de la fenêtre.La fonction membre <methodname>set_limit()</methodname> fixe le nombre limite d'éléments renvoyés ; <methodname>get_limit()</methodname> permet d'en prendre connaissance.Le type de raccord est défini avec la fonction <methodname>Cairo::Context::set_line_join()</methodname>.La liste est donnée via un objet <classname>TreeModel</classname> et les colonnes provenant de ce modèle sont insérées dans la vue de la boîte combinée avec la fonction membre <methodname>ComboBox::pack_start()</methodname>. Cela procure beaucoup de souplesse et de sécurité sur les types de données à la compilation ; mais la classe <classname>ComboBoxText</classname> dispose d'un paramétrage texte simple pour les cas où cette souplesse n'est pas recherchée.Les macros sont expliquées plus en détail dans les paragraphes suivants.Les macros employées dans cet exemple effectuent les tâches suivantes : <placeholder-1/>Les macros utilisées dans les fichiers .hg et .ccg ont souvent besoin de savoir comment convertir un type C++ en type C ou vice-versa. gmmproc prend cette information dans un fichier .m4 du répertoire <literal>tools/m4/</literal>. Celle-ci lui permet d'appeler une fonction C dans l'implémentation de votre fonction membre C++, en passant les paramètres appropriés à cette fonction C. Par exemple, cette macro indique à gmmproc comment convertir un pointeur GtkTreeView en pointeur Gtk::TreeView : <placeholder-1/>Le gros du travail dans le processus d'internationalisation est de rechercher les chaînes visibles par l'utilisateur et de les marquer comme traduisibles. Ce travail n'a pas besoin d'être réalisé en une seule fois - si vous réglez l'infrastructure du projet correctement, votre application fonctionnera normalement quel que soit le nombre de chaînes traîtées.Le modèleLe modèle d'une boîte combinée se définit et se remplit exactement comme un objet <classname>TreeView</classname>. Par exemple, vous pouvez dériver à partir de ComboBox une classe comportant une colonne d'entiers et une colonne texte comme suit :le nom de la bibliothèque, comme libsomethingmm.Les noms des paquets <application>gtkmm</application> varient selon les distributions (par exemple, <application>libgtkmm3.0-dev</application> sur Debian et Ubuntu ou <application>gtkmm30-devel</application> sur Red Hat Fedora) ; vérifiez donc avec le programme de gestion de paquets de votre distribution la dénomination correcte, puis installez-le comme vous feriez pour tout autre paquet.La boîte de dialogue d'impression native de GTK+ dispose d'un bouton d'aperçu, mais vous pouvez également lancer l'aperçu directement à partir de l'application : <placeholder-1/>Le suivant est plus intéressant. <function>sigc::mem_fun()</function> est appelé avec deux paramètres. Le premier paramètre est <parameter>some_object</parameter>, qui est l'objet sur lequel notre nouveau connecteur pointe. Le second paramètre est un pointeur sur une de ses fonctions membres. Cette version particulière de <function>sigc::mem_fun()</function> crée un connecteur qui, quand il sera « appelé », fera lui-même appel à la fonction membre pointée de l'objet désigné, dans ce cas <methodname>some_object.on_button_clicked()</methodname>.La ligne suivante : <placeholder-1/> crée un objet <classname>Gtk::Main</classname>, nécessaire pour toutes les applications <application>gtkmm</application>. Le constructeur de cet objet initialise <application>gtkmm</application> et vérifie les paramètres passés à l'application sur la ligne de commande. Il examine les options standard, comme <literal>-display</literal>, les enlève de la liste des paramètres en ne gardant que celles qu'il n'a pas reconnues pour un traitement éventuel par l'application. Cela garantit que toutes les applications <application>gtkmm</application> accepteront le même ensemble de paramètres normalisés.Les deux lignes de code suivantes créent et affichent une fenêtre :Le nombre de décimales est modifié à l'aide de la fonction membre <methodname>set_digits()</methodname>.La seule différence entre cet exemple et l'exemple des droites réside dans la fonction <methodname>on_expose_event()</methodname>, mais quelques nouveaux concepts et fonctions sont introduits ici ; examinons-les brièvement.L'autre groupe comprend les éléments graphiques <classname>Viewport</classname> et <classname>ScrolledWindow</classname>. Tous ceux-ci utilisent des valeurs en pixels dans leur structure <literal>adjustment</literal>. Ils sont, en règle générale, « ajustés » indirectement à l'aide de barres de défilement. Comme tous les éléments graphiques utilisant des ajustements peuvent, soit créer leurs propres structures <literal>adjustement</literal>, soit utiliser celle qui leur est fournie, nous souhaiterons, en règle générale, laisser à cette catégorie particulière d'éléments graphiques le soin de créer elle-même leurs propres structures d'ajustement.Les noms des paquets ne changent pas quand de nouvelles versions de <application>gtkmm</application> compatibles API/ABI(Application Binary Interface) sont publiées. Si ce n'était pas le cas, elles ne seraient pas compatibles. Donc ne soyez pas surpris, par exemple, de trouver la version 2.8 de <application>gtkmm</application> livrée dans le paquet <application>libgtkmm2.4-dev</application> par Debian.Les paramètres de remplissage fonctionnent exactement comme pour la fonction membre <methodname>pack_start()</methodname>.Les principaux inconvénients proviennent du fait que l'utilisation d'éléments graphiques à portée de classe sont en rapport avec l'implémentation de la classe plus que de son interfaçage dans l'en-tête de classe. Les éléments graphiques à portée de classe sont créés automatiquement et souffrent des mêmes inconvénients que n'importe quelle autre variable automatique à portée de classe.L'objet principal est <classname>Gtk::PrintOperation</classname>, alloué pour chaque opération d'impression. Pour gérer le tracé de la page, il faut se connecter à ses signaux, ou bien créer un objet dérivé et surdéfinir les gestionnaires de signaux virtuels fournis par défaut.  <classname>PrintOperation</classname> gère automatiquement tous les paramètres affectant la boucle d'impression.Le processus consistant à écrire un code source autorisant la traduction s'appelle l'<literal>internationalisation</literal>, souvent abrégé en <literal>i18n</literal>. Le processus d'<literal>adaptation locale</literal> (localisation) quelquefois abrégé en <literal>l10n</literal>, met à disposition du texte, fondé sur ce code source, traduit dans d'autres langues.La valeur de retour qui est du type <classname>sigc::connection</classname> peut être utilisée pour arrêter le contrôle sur ce descripteur de fichier avec la fonction membre <methodname>disconnect()</methodname>. Le gestionnaire de signal de <parameter>slot</parameter> doit être déclaré comme suit :Les lignes et les colonnes sont numérotées à partir de zéro. Si vous définissez <parameter>rows</parameter> = 2 et <parameter>columns</parameter> = 2, la disposition ressemble à ceci :Les mêmes principes s'appliquent aux signaux avec plus de paramètres, voici un exemple avec trois paramètres (pris dans le fichier <filename>&lt;gtkmm/editable.h&gt;</filename>) :La deuxième façon pour grouper des boutons radio consiste à créer un groupement au préalable, puis y intégrer les boutons. Voici un exemple :La partie concernant le tracé de l'arc comporte une nouvelle fonction : <methodname>close_path()</methodname>. Cette fonction a pour effet de provoquer le tracé d'une droite entre le point de fin et de début du tracé. Il y a toutefois une différence significative entre l'appel de <methodname>close_path()</methodname> et le tracé à la main d'une ligne jusqu'au point de départ. Si vous utilisez <methodname>close_path()</methodname>, les lignes seront proprement jointes. Si vous utilisez <methodname>line_to()</methodname> à la place, les lignes se rejoindront, mais Cairo ne fera rien de spécial pour les joindre.Les lignes sélectionnéesLe gestionnaire de signal est <methodname>on_button_clicked()</methodname>.Les éléments conteneurs mono-éléments dérivent de la classe <classname>Gtk::Bin</classname> ; cette classe comporte les fonctions membres <methodname>add()</methodname> et <methodname>remove()</methodname> pour les éléments graphiques enfants. Notez que les objets de la classe <classname>Gtk::Button</classname> et <classname>Gtk::Window</classname> sont techniquement des conteneurs mono-éléments ; nous l'avons déjà signalé par ailleurs.L'élément graphique source va émettre ces signaux, dans cet ordre : <placeholder-1/>Les modèles standard d'arborescence (<classname>TreeStore</classname> et <classname>ListStore</classname>) dérivent de la classe <classname>TreeSortable</classname> ; ils offrent donc la possibilité de tri. Par exemple, faites appel à <methodname>set_sort_column()</methodname> pour trier le modèle sur la colonne donnée, ou bien définissez une fonction de rappel pour <methodname>set_sort_func()</methodname> pour implémenter un algorithme de tri plus complexe.La colonne texteL'utilisation du mot clé <literal>const</literal> dans le C++ n'est pas toujours claire.  Vous ne devez pas penser que <literal>const Quelquechose*</literal> déclare un pointeur sur un type <literal>const Quelquechose</literal> ; le pointeur peut être modifié, mais pas le <literal>Quelquechose</literal> sur lequel il pointe.Le nombre de décimales après la virgule de la valeur est ajustable, de même que la valeur de l'incrément. Le <classname>SpinButton</classname> dispose d'une fonctionnalité de « répétition automatique » : si l'option est retenue, le fait de maintenir enfoncée l'une des flèches provoque une accélération des changements de valeur en fonction de la durée d'appui sur le bouton.La valeur affichée par un élément graphique coulisse est, par défaut, arrondie à un chiffre après la virgule ; cette valeur affichée correspond à celle du champ <literal>value</literal> de l'objet <classname>Gtk::Adjustment</classname> associé. Vous pouvez modifier la précision avec la fonction membre <methodname>set_digits()</methodname>.Voici comment il fonctionne : contactez la liste de diffusion gnome-i18n pour indiquer comment les traducteurs pourraient avoir accès à votre sous-répertoire <filename>po/</filename> et pour ajouter votre projet aux grands <ulink url="http://developer.gnome.org/projects/gtp/status/">tableaux d'état</ulink>.Les <classname>Sockets</classname> et <classname>Plugs</classname> collaborent par l'intermédiaire des identifiants de leurs fenêtres. Un objet <classname>Socket</classname> et un objet <classname>Plug</classname> ont tous deux des ID que l'on peut retrouver avec leurs fonctions membres <methodname>get_id()</methodname>. L'utilisation de ces ID sera explicitée plus bas dans la <xref linkend="sec-connecting-plugs-sockets"/>.Les éléments graphiques ne se réarrangent pas par eux-mêmes quand la fenêtre est redimensionnée. Certains éléments graphiques sont masqués quand la fenêtre est rapetissée et des espaces libres inutiles apparaissent quand la fenêtre est agrandie.La largeur de l'étiquette sera ajustée automatiquement. Vous pouvez écrire des étiquettes sur plusieurs lignes en mettant des sauts de ligne (« \n ») dans la chaîne de l'étiquette.The window ID is: 69206019Ensuite, modifiez le fichier <filename>.cc</filename> pour définir les types corrects. Par exemple, il se peut que votre fonction <function>main()</function> ressemble à quelque chose comme ceci : <placeholder-1/>puis lancez le programme <filename>socket</filename> :Ensuite, avec <methodname>append_column()</methodname>, ajoutez la colonne à la vue. Vous noterez que <methodname>Gtk::View::append_column()</methodname> a été surdéfini pour accepter, soit un élément graphique <classname>Gtk::View::Column</classname> préalablement construit, soit uniquement un <classname>TreeModelColumn</classname> à partir duquel cette fonction membre génére un élément graphique <classname>Gtk::View::Column</classname> approprié.Assurez-vous que le fichier <filename>POTFILES.in</filename> dans le sous-répertoire <filename>po/</filename> est à jour (la commande <command>intltool‑update -M</command> peut vous aider pour cela) de façon à ce que les traducteurs aient toujours accès à des fichiers <filename>mon_programme.pot</filename> actualisés et gelez tout simplement les chaînes au moins quelques jours avant de téléverser une nouvelle version en l'annonçant sur gnome-i18n. Selon le nombre de chaînes que votre programme comporte et selon sa popularité, les traductions vont alors commencer à apparaître dans les fichiers <filename>nom_de_langue.po</filename>.Puis, pour ajouter l'élément graphique à la position indiquée, servez-vous de <methodname>Gtk::TextView::add_child_at_anchor()</methodname> :Puis, vous définissez la disposition réelle de l'affichage des menus et des barres d'outils en insérant l'agencement de l'UI dans l'<classname>UIManager</classname>. Cette « chaîne ui » utilise un format XML dans lequel vous mentionnez le nom des actions que vous venez de créer. Par exemple :Il y a deux ou trois fonctions membres de tracé pour positionner les données d'une image dans une zone de dessin. <methodname>draw_pixmap()</methodname> peut copier dans une zone de dessin le contenu d'un objet <classname>Gdk::Drawable</classname> (la fenêtre d'une zone de dessin fait partie de cette classe). <methodname>draw_bitmap()</methodname> permet d'afficher une image bicolore dans une zone de tracé ; utilisez <methodname>draw_image()</methodname> si l'image comporte plus de deux couleurs.Il y a deux choses à noter concernant cet exemple de code. À nouveau, la seule différence entre cet exemple et les précédents se situe dans la fonction <methodname>on_expose_event()</methodname> ; nous limitons donc nos remarques à cette fonction. En outre, la première partie de la fonction est pratiquement identique aux exemples précédents, nous ne la commentons donc pas.Voici quelques erreurs courantes que vous découvririez peut-être par vous-même. Mais il se peut que ce paragraphe vous aide à les éviter.De nombreuses variables d'état graphique peuvent être définies pour un contexte Cairo. Les attributs les plus courants sont la couleur (avec <methodname>set_source_rgb()</methodname> ou <methodname>set_source_rgba()</methodname> pour des couleurs transparentes), l'épaisseur du trait (avec <methodname>set_line_width()</methodname>), le type de pointillé (avec <methodname>set_dash()</methodname>), les bouts de lignes (avec <methodname>set_line_cap()</methodname>), les jonctions de lignes (avec <methodname>set_line_join()</methodname>) et les styles de polices de caractères (avec <methodname>set_font_size()</methodname>, <methodname>set_font_face()</methodname> et autres). Il existe beaucoup d'autres réglages : les matrices de transformation, les règles de remplissage, les types  d'anti-crénelage, etc. Pour plus d'informations, consultez la documentation de l'API <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink>.À la base, il y cinq styles différents comme illustré dans cette figure :Il existe une classe pour les barres de défilement horizontal et une classe pour les barres de défilement vertical — <classname>Gtk::HScrollbar</classname> et <classname>Gtk::VScrollbar</classname>.Vous pouvez encore personnaliser d'autres paramètres, y compris la création de pointillés entre autres. Pour plus d'informations, consultez la documentation de l'API Cairo. Il y a plusieurs classes dérivées de <classname>Dialog</classname> ; vous les trouverez certainement utiles. <classname>Gtk::MessageDialog</classname> s'utilise pour la plupart des simples notifications. Mais, dans d'autres circonstances, vous aurez besoin de dériver vous-même vos propres classes de boîtes de dialogue pour obtenir des fonctionnalités plus élaborées.Il y a plusieurs options régissant la manière dont les éléments graphiques doivent être empaquetés ; cela peut sembler confus au début. Si vous avez des difficultés, nous vous suggérons l'idée de manipuler le concepteur GUI <application>glade</application> pour voir ce qui est possible. Vous pourrez même décider d'utiliser l'API <application>Gtk::Builder</application> pour charger les interfaces utilisateur au lancement du programme.Il existe plusieurs autres conteneurs. Nous en parlerons également.Il y a quelques paramètres optionnels supplémentaires : <placeholder-1/>Les menus et les barres d'outils ont des API distinctes, mais vous pouvez les manipuler simultanément en utilisant l'<classname>UIManager</classname> pour définir une <classname>Action</classname> que vous disposez ensuite à la fois dans le menu et dans la barre d'outils. De la sorte, vous pourrez gérer le déclenchement de l'action d'un coup au lieu d'organiser une réponse séparée aux éléments du menu et à ceux de la barre d'outils. Vous pourrez également activer ou désactiver les éléments de menu et de barre d'outils par l'intermédiaire de l'objet <classname>Action</classname>.Il y a deux stratégies de base utilisables : <placeholder-1/>Il y a deux objets <classname>Mark</classname> prédéfinis — <literal>insert</literal> et <literal>select_bound</literal>, objets auxquels vous aurez accès grâce aux fonctions membres <methodname>get_insert()</methodname> et <methodname>get_selection_bound()</methodname> de la classe <classname>TextBuffer</classname>.Il y a deux façons de créer un bouton. Vous pouvez indiquer la chaîne étiquette dans le constructeur de <classname>Gtk::Button</classname> ou bien la définir plus tard avec <methodname>set_label()</methodname>.Il y a deux façons de définir un groupe de boutons radio. La première est de créer les boutons et de définir leur groupement après-coup. Seuls les deux premiers constructeurs sont utilisés dans ce cas. Dans l'exemple suivant, nous créons une nouvelle classe de fenêtre nommée <classname>RadioButtons</classname> dans laquelle nous plaçons trois boutons radio :Dans le dossier examples/dnd, vous pouvez trouver un exemple un peu plus élaboré.Il y a également une fonction membre pour dessiner à partir d'un objet <classname>Gdk::Pixbuf</classname>. Un tampon <classname>Gdk::Pixbuf</classname> est une enveloppe commode pour un ensemble de pixels. Il peut être lu à partir d'un fichier et manipulé de diverses manières.Vous pouvez parfois avoir besoin de modifier la liste des fichiers récents. Par exemple, si un fichier est déplacé ou renommé, vous pouvez mettre à jour l'emplacement ou le nom du fichier dans la liste des fichiers récents pour éviter de pointer vers quelque chose d'incorrect. Vous pouvez mettre à jour l'emplacement d'un élément avec <methodname>move_item()</methodname>.Il y a un certain nombre de choses à considérer à propos de ce code (non fonctionnel). D'abord identifions les parties concernées :Ainsi, l'équivalent <classname>RefPtr</classname> de <literal>Quelquechose*</literal> pour un paramètre de fonction membre est <literal>const Glib::RefPtr&lt;Quelquechose&gt;&amp;</literal> et l'équivalent de <literal>const Quelquechose*</literal> est <literal>const Glib::RefPtr&lt;const Quelquechose&gt;&amp;</literal>.Ce sont les barres de défilement classiques. Elles ne s'utilisent que pour déplacer un autre élément graphique, comme un <classname>Gtk::Entry</classname> ou un <classname>Gtk::Viewport</classname>, même s'il est habituellement plus facile d'utiliser un élément graphique de la classe <classname>Gtk::ScrolledWindow</classname> dans la plupart des cas.Ces dépendances ont elles-mêmes leurs propres dépendances, comprenant les applications et bibliothèques suivantes :Ces signaux se comportent de façon légèrement différente. La valeur renvoyée par le gestionnaire de signal indique si l'événement a été pleinement « géré ». Si la valeur est <literal>false</literal>, alors <application>gtkmm</application> passe l'événement au gestionnaire de signal suivant. Si la valeur est <literal>true</literal>, aucun autre gestionnaire de signal n'est appelé.Ces éléments graphiques sont essentiellement utilisés pour l'agencement ou la décoration ; la plupart du temps, il ne sera donc pas nécessaire de capturer d'événements sur eux. Ils n'ont pas été pourvus d'une fenêtre-X intentionnellement pour améliorer la performance.Les objets sont glissés à partir de <literal>sources</literal> pour être déposés sur des <literal>destinations</literal>. Chaque source et chaque destination dispose d'informations à propos du format des données qu'elle peut recevoir ou envoyer, informations fournies par les éléments <classname>Gtk::TargetEntry</classname>. Une destination de dépôt n'accepte un élément glissé que s'ils partagent un élément <classname>Gtk::TargetEntry</classname> compatible. Les signaux appropriés sont alors émis, indiquant au gestionnaire de signaux le <classname>Gtk::TargetEntry</classname> qui a été utilisé.Ce fichier <filename>.defs</filename> décrit les types enum et leurs valeurs possibles. Il est généré par le script <filename>enum.pl</filename> que vous trouverez dans le répertoire <filename>tools</filename> de glibmm. Par exemple, <placeholder-1/>Ce fichier <filename>.defs</filename> décrit les objets et leurs fonctions. Il est généré par le script <command>h2def.py</command> que vous trouverez dans le répertoire <filename>codegen</filename> des pygobject. Par exemple, <placeholder-1/>Ce fichier <filename>.defs</filename> décrit les signaux et les propriétés. Il est généré par l'utilitaire spécial <filename>extra_defs</filename> qui se trouve dans tout projet d'habillage, tel que <filename>gtkmm/tools/extra_defs_gen/</filename>. Par exemple  <placeholder-1/>La variable <varname>PROGRAMNAME_LOCALEDIR</varname> sera utilisée plus tard dans le fichier <literal>Makefile.am</literal> pour définir une macro utilisée quand vous initialisez <application>gettext</application> dans votre code source.Cette façon de procéder permet des liaisons de langage pour implémenter leurs propres équivalents (comme les constructeurs C++) sans utiliser les fonctions <function>*_new()</function>. Ceci est souvent nécessaire ; elles peuvent donc instancier en réalité un GType dérivé pour ajouter leurs propres accroches pour les gestionnaires de signal et les fonctions virtuelles.Cet ouvrageCet ouvrage suppose une bonne connaissance du C++, ainsi que des méthodes de création de programmes avec ce langage.Cet ouvrage explicite les concepts-clés de l'API C++ <application>gtkmm</application> pour la création d'interfaces utilisateur. Il présente également les principaux éléments graphiques d'interfaçage utilisateur (« widgets » en anglais, « contrôles » ou « éléments graphiques » en français).Cet ouvrage explicite les concepts-clés de l'API C++ <application>gtkmm</application> pour la création d'interfaces utilisateur. Il présente également les principaux éléments graphiques de l'interfaçage utilisateur (« widgets » en anglais, « contrôles » ou « éléments graphiques » en français). Même s'il est fait mention de classes, de constructeurs et de fonctions membres, ces concepts ne sont pas examinés en détail. Par conséquent, pour une information complète sur l'API, il conviendra de vous reporter à la documentation de référence.Cela demande à <application>gtkmm</application> d'appeler la fonction membre indiquée chaque fois qu'il ne se passe rien d'autre. Vous pouvez définir une priorité (les plus petits nombres correspondent aux priorités les plus élevées). Il y a deux manières de déconnecter le gestionnaire de signal : par l'appel de la fonction membre <methodname>disconnect()</methodname> sur l'objet <classname>sigc::connection</classname> ou en renvoyant <literal>false</literal> dans le gestionnaire du signal, qui doit être déclaré ainsi :Ce chapitre présente quelques aspects parmi les plus importants du codage avec <application>gtkmm</application>. Nous les montrerons à partir d'exemples simples et fonctionnels de code. Ce n'est toutefois qu'un avant-goût et vous aurez besoin d'examiner les autres chapitres pour des informations plus conséquentes.Cette classe implémente la fenêtre « Hello World ». Elle est dérivée de la classe <classname>Gtk::Window</classname> et possède un simple <classname>Gtk::Button</classname> comme membre. Nous avons pris le parti d'utiliser le constructeur pour faire toutes les tâches d'initialisation de la fenêtre, y compris la définition des signaux. Voici le code, les commentaires sont omis :Cette commande construit et installe une série de modules ; cela prend très certainement beaucoup de temps la première fois. Les fois suivantes, toutefois, cela devrait aller un peu plus vite étant donné que vous n'aurez à reconstruire que les fichiers modifiés depuis la dernière opération de construction. Sinon, après avoir construit et installé <application>gtkmm</application> la première fois, vous pouvez construire à nouveau <application>gtkmm</application> lui-même (sans reconstruire toutes ses dépendances) avec la commande <command>jhbuild buildone gtkmm</command>.L'erreur de compilation ressemble à quelque chose comme : <placeholder-1/> ou bien encore : <placeholder-2/>Ce document, comme beaucoup d'autres grands logiciels, a été créé gratuitement par des bénévoles. Si vous avez des compétences sur un des aspects de <application>gtkmm</application> qui ne serait pas déjà documenté, il serait aimable à vous d'envisager une contribution à ce document.Dans cet exemple, des objets <classname>ToolPalette</classname> et <classname>DrawingArea</classname> sont associés à une fenêtre. L'utilisateur est autorisé à faire un glisser-déposer depuis la palette d'outils sur la surface de tracé. La palette d'outils contient divers groupes d'éléments. Des boîtes combinées permettent à l'utilisateur de changer le style et l'orientation de la palette d'outils.Cet exemple permet le copier-coller de données propres à une application, avec une cible texte standard. Il est simple, mais il n'est pas idéal parce qu'il n'identifie pas les données <classname>Clipboard</classname> comme étant d'un type donné.Dans cet exemple, nous créons un objet <classname>Gtk::EntryCompletion</classname> et nous l'associons à un élément graphique <classname>Gtk::Entry</classname>. La complétion fait appel à un objet <classname>Gtk::TreeModel</classname> pour les diverses saisies possibles et quelques actions supplémentaires.Cet exemple crée un bouton avec image et étiquette.Cet exemple crée deux exécutables : <filename>socket</filename> et <filename>plug</filename>. L'idée est que <filename>socket</filename> ait une fenêtre d'application qui accueille un élément graphique issu du programme <filename>plug</filename>. Compte tenu de la manière dont cet exemple est conçu, <filename>plug</filename> doit être lancé avant que <filename>socket</filename> ne démarre. Pour voir cet exemple en action, exécutez les commandes suivantes dans l'ordre indiqué à partir du répertoire de l'exemple :Cet exemple affiche une fenêtre avec trois éléments graphiques coulisses tous connectés au même ajustement. À côté, sont disposés quelques contrôles pour ajuster certains paramètres mentionnés plus haut (et rappelés au chapitre Ajustements) : vous pouvez ainsi voir comment ils modifient la façon dont ces éléments graphiques réagissent vis à vis de l'utilisateur.Voici un exemple d'élément graphique <classname>Gtk::TreeView</classname> avec un modèle <classname>Gtk::ListStore</classname>.Cet exemple implémente un conteneur avec deux éléments graphiques enfants, l'un au dessus de l'autre. Bien entendu, dans ce cas il aurait été de loin beaucoup plus simple d'utiliser <classname>Gtk::VBox</classname>.Cet exemple implémente un élément graphique qui trace un triangle de Penrose.Cet exemple est identique à l'exemple avec <classname>ListStore</classname>, mais il utilise <methodname>TreeView::append_column_editable()</methodname> à la place de <methodname>TreeView::append_column()</methodname>.Cet exemple est tout à fait semblable à l'exemple <classname>ListStore</classname>, excepté qu'il crée un <classname>TreeView</classname> personnalisé par dérivation pour permettre la surdéfinition de <literal>button_press_event</literal> et pour encapsuler le code du modèle d'arborescence dans cette classe dérivée. Consultez le paragraphe <link linkend="sec-treeview-contextmenu">Menu contextuel et TreeView</link>.Cet exemple est similaire à l'exemple <classname>TreeStore</classname>, mais il a deux colonnes supplémentaires, une pour indiquer si la ligne peut être glissée, une pour indiquer si elle accepte des lignes déposées. Il se sert d'une classe <classname>Gtk::TreeStore</classname> dérivée dans laquelle s'opère une surdéfinition  des fonctions virtuelles comme décrit dans le paragraphe <link linkend="sec-treeview-draganddrop">TreeView et glisser-déposer</link>.C'est exemple est tout à fait semblable au précédent, mais il utilise un modèle <classname>Gtk::TreeStore</classname> à la place et il ajoute des enfants aux colonnes.Cet exemple souligne la différence entre fonctions membres de temporisation et fonctions membres à délai échu. Si vous avez besoin de fonctions appelées périodiquement et que la rapidité n'a pas grosse importance, alors servez-vous des fonctions membres à délai échu. Si vous voulez des fonctions membres appelées aussi souvent que possible (comme des fonctions membres de calcul de fractales en arrière-plan), alors utilisez les fonctions membres de temporisation.Cet exemple aligne à droite un bouton dans une fenêtre à l'aide de l'élément conteneur <classname>Alignment</classname>.Cet exemple montre un élément graphique <classname>Gtk::Entry</classname> avec barre de progression.Cet exemple montre un élément graphique <classname>Gtk::Entry</classname> avec une icône « rechercher » prise dans le catalogue. Le texte dans le champ de saisie est reproduit dans la fenêtre du terminal quand l'icône est cliquée.Cet exemple montre comment charger un fichier <application>Glade</application> au lancement et accéder aux éléments graphiques par l'intermédiaire d'une classe dérivée.Cet exemple utilise la classe <classname>Gtk::Entry</classname>. Deux cases à cocher de la classe <classname>CheckButton</classname> vous permettent d'inverser les marqueurs « editable » et « visible ».Cette exception peut alors être déclenchée par des fonctions membres générées par _WRAP_METHOD() avec l'option errthrow.Cette fonction membre présente les avantages suivants : <placeholder-1/>Cela implique divers outils, dont certains sont retors, mais qui au moins fonctionnent ; ils ont été utilisés avec succès par plusieurs projets.Cette façon d'opérer implique l'utilisation des classes <classname>Gtk::ActionGroup</classname>, <classname>Gtk::Action</classname> et <classname>UIManager</classname> ; chacune d'entre elles sera instanciée avec la fonction membre <methodname>create()</methodname> qui renverra un pointeur <classname>RefPtr</classname>.Voici un exemple pleinement fonctionnel définissant et utilisant un signal personnalisé.Ceci est montré dans l'exemple Menu contextuel personnalisé.Cette construction est montrée dans l'exemple du glisser-déposer.C'est facile à corriger dans la bibliothèque C ; n'envoyez pas de correctif au mainteneur concerné.Il est identique à l'exemple simple, mais il <placeholder-1/>C'est un des aspects où la beauté du C++ ressort vraiment. Quelqu'un songerait-il à sous-classer un élément graphique GTK+ uniquement pour surdéfinir ses fonctions membres d'action ? Ce serait s'exposer à trop d'ennuis. Dans GTK+, vous utilisez pratiquement toujours les signaux pour exécuter quelque chose, à moins que vous n'écriviez un nouvel élément graphique. Mais comme la surdéfinition des fonctions membres est si facile en C++, il est tout à fait pratique — et sensé — de sous-classer un bouton pour cette seule raison.Voici la déclaration de la fonction membre <methodname>pack_start()</methodname> :Ce n'est pas à proprement parler un problème <application>gtkmm</application> ou d'interface utilisateur. <application>gtkmm</application> utilise <application>libsigc++</application> pour implémenter ses habillages mandataires du système de signaux <application>GTK+</application>, mais pour des nouveaux signaux non GTK+, vous pouvez créer des signaux C++ purs en utilisant le modèle <classname>sigc::signal&lt;&gt;</classname>.Cette macro peut être utilisée pour habiller les structures n'entrant pas dans une catégorie particulière.Cette macro crée un constructeur avec paramètres, équivalent à la fonction C <function>*_new()</function>. Elle n'appelle pas réellement la fonction <function>*_new()</function>, mais elle crée simplement un constructeur équivalent avec les mêmes types de paramètres. Elle prend en paramètres la signature d'un constructeur C++ et un nom de fonction C.Cette macro crée un constructeur par défaut sans paramètre.Cette macro déclare un habillage pour une structure non-<classname>GObject</classname>, enregistrée avec <function>g_boxed_type_register_static()</function>.Cette macro déclare un habillage pour une structure opaque à décompte de références. L'habillage C++ ne peut pas être directement instancié et ne peut être utilisé qu'avec un pointeur intelligent <classname>Glib::RefPtr</classname>.Cette macro déclare un habillage pour une simple structure assignable comme un <classname>GdkRectangle</classname>. Elle est semblable à <function>_CLASS_BOXEDTYPE</function>, mais la structure C n'est pas allouée dynamiquement.Cette macro déclare un habillage pour un type dérivé de <classname>GObject</classname>, mais non-dérivé de <classname>GtkObject</classname>.Cette macro déclare un habillage pour un type dérivé de <classname>GtkObject</classname>, tel un élément graphique ou une boîte de dialogue.Cette macro déclare un habillage pour une structure opaque possédant des fonctions de copie et de libération. Les fonctions new, copy et free seront utilisées pour instancier le constructeur par défaut, le constructeur de copie et le destructeur.Cette macro génère une énumération C++ pour habiller une énumération C. Vous devez préciser le nom C++ et le nom de l'énumération C subjacente.Cette macro génère une classe d'exception C++, dérivée de Glib::Error, avec un Code enum et une fonction membre code(). Vous devez préciser le nom C++ souhaité, le nom de l'énumération correspondante C et le préfixe pour les valeurs d'énumération C.Cette macro génère le signal C++ de style libsigc++ habillant un signal C GObject. Il génère en fait un mécanisme d'accès public, comme <function>signal_clicked()</function>, qui renvoie un objet mandataire. <command>gmmproc</command> utilise le fichier .defs pour découvrir le type des paramètres du C et les fichiers de conversion .m4 pour découvrir les types de conversion appropriés.Cette macro génère une fonction membre C++ habillant une propriété d'un GObject C. Vous devez indiquer le nom de la propriété et le type C++ souhaité pour la propriété. <command>gmmproc</command> utilise le fichier .defs pour connaître le type C et les fichiers de conversion .m4 pour découvrir les types appropriés de conversion.Cette macro génère une fonction membre C++ habillant une fonction C.Cette macro est comparable à la macro <function>_WRAP_METHOD()</function>, mais elle ne génère la documentation que dans le cas d'une fonction membre C++ habillant une fonction C. Utilisez-la si vous devez coder à la main la fonction membre, mais vous voulez utiliser la documentation qui serait générée si la fonction membre était générée.Cette macro sert quand vous initialisez <literal>gettext</literal> dans votre code source.Cela signifie que toute fonction membre prenant en paramètre un <literal>const Glib::RefPtr&lt;BaseType&gt;</literal> peut également prendre un <literal>const Glib::RefPtr&lt;DerivedType&gt;</literal>. Le forçage est implicite, tout comme pour un pointeur normal.Ce programme ne comporte qu'une seule classe, <classname>MyArea</classname>, sous-classe de <classname>Gtk::DrawingArea</classname> avec une fonction membre <methodname>on_expose_event()</methodname>. Cette fonction membre est appelée chaque fois que l'image dans la zone de tracé a besoin d'être retracée. À cette fonction est passé un pointeur sur une structure <classname>GdkEventExpose</classname> définissant la zone ayant besoin d'être redessinée. Nous utilisons ces valeurs pour créer un chemin de rectangle dans Cairo (avec la fonction <methodname>rectangle()</methodname>) puis découper ce chemin avec <methodname>clip()</methodname>. La fonction <methodname>clip()</methodname> définit une zone de découpe. Cette zone affecte toutes les opérations de tracé en occultant effectivement toute modification sur la surface extérieure à la découpe. Cela nous permet de limiter le retraçage à la zone qui le nécessite. Le code de tracé définit la couleur que nous voulons en fait utiliser avec <methodname>set_source_rgb()</methodname> dont les paramètres définissent les composantes rouge, verte et bleue de la couleur voulue (les valeurs correctes sont comprises entre 0 et 1). Après avoir précisé la couleur, nous créons un nouveau chemin avec les fonctions <methodname>move_to()</methodname> et <methodname>line_to()</methodname> et nous le traçons avec <methodname>stroke()</methodname>.Cet arbre fournit une structure de répertoires pour les fichiers sources .hg et .ccg et pour les fichiers générés .h and .cc ; à l'aide du fichier <filename>filelist.am</filename>, Automake inclut des fichiers qui peuvent indiquer les divers fichiers utilisés sous forme de variables génériques Automake. L'arborescence ressemble alors à quelque chose comme cela après avoir renommé les répertoires de façon appropriée : <placeholder-1/>Ce chapitre est simplement un condensé de pratiques de bon sens, de lignes directrices générales, et de conseils pour créer des applications <application>gtkmm</application>.Cette simple application trace une courbe avec Cairo et affiche les points de contrôle pour chaque extrémité de la courbe.Cet exemple simple montre comment charger un fichier <application>Glade</application> au cours de l'exécution et accéder aux éléments graphiques avec <application>Gtk::Builder</application>.cette variable doit indiquer le nom correct de la bibliothèque, tel qu'utilisé par les noms de variables <varname>_SOURCES</varname>, <varname>_LDFLAGS</varname> et <varname>_LIBADD</varname>. Il est autorisé d'utiliser des variables substituées par <filename>configure</filename> comme <varname>@SOMETHINGMM_API_VERSION@</varname> en tant que partie de noms de variables.Cette option va provoquer l'étalement du tableau jusqu'à occuper tout l'espace libre de la fenêtre.Même s'il est généralement évident que les types C++ devraient être utilisés dans les fonctions membres C++, voici quelques astuces : <placeholder-1/>Fonctions à délai échuFonctions à délai échu, d'entrées/sorties et de temporisationPour accéder à un élément graphique, par exemple pour appeler la fonction <methodname>show()</methodname> sur une boîte de dialogue, utilisez la fonction membre <methodname>get_widget()</methodname> en fournissant le nom de l'élément graphique en paramètre. Ce nom doit avoir été indiqué dans la fenêtre Propriétés de <application>Glade</application>. Si l'élément graphique est introuvable, ou n'est pas d'un type correct, le pointeur sera initialisé à 0. <placeholder-1/>Pour réaliser cela, utilisez les fonctions membres normales <classname>Gtk::TreeView</classname><methodname>insert_column()</methodname> et <methodname>append_column()</methodname>, puis, avec <methodname>get_column_cell_renderer()</methodname>, obtenez le pointeur sur le <classname>Gtk::CellRenderer</classname> utilisé par cette colonne.Pour ajouter un nouveau fichier à la liste des documents récents, dans le cas le plus simple, vous n'avez besoin que de fournir l'URI. Par exemple :Pour ajouter des éléments graphiques dans la zone d'action, utilisez la fonction membre <methodname>add_action_widget()</methodname>. Ils seront empaquetés à côté des boutons par défaut. Servez-vous de la fonction membre <methodname>remove_action_widget()</methodname> pour enlever des éléments graphiques.Comme entrée en matière avec <application>gtkmm</application>, nous débuterons avec le programme le plus simple qui soit. Ce programme crée une fenêtre vide de 200 x 200 pixels.Pour modifier la sélection, précisez un <classname>Gtk::TreeModel::iterator</classname> ou <classname>Gtk::TreeModel::Row</classname>, ainsi :Pour modifier la valeur affichée, utilisez la fonction membre <methodname>set_fraction()</methodname> à laquelle vous passez une valeur de type double comprise entre 0 et 1 pour définir le nouveau pourcentage.Pour contrôler quelles lignes peuvent être sélectionnées, utilisez la fonction membre <methodname>set_select_function()</methodname> et passez lui en paramètre un signal de rappel <classname>sigc::slot</classname>. Par exemple :Pour vérifier que vous avez bien opéré, peut-être voudrez-vous ajouter une traduction pour un nouvel environnement linguistique. Pour réaliser cela, allez dans le sous-répertoire <filename>po</filename> de votre projet et exécutez les commandes suivantes : <placeholder-1/>Pour définir une touche d'accès direct de navigation au clavier, placez un caractère souligné avant l'un des caractères de l'étiquette et définissez à <literal>true</literal> le paramètre optionnel <literal>mnemonic</literal> (mnémonique). Par exemple :Pour détecter un clic du bouton droit de la souris, il faut gérer le signal <literal>button_press_event</literal> et vérifier quel est exactement le bouton pressé. Comme <classname>TreeView</classname> gère normalement ce signal intégralement, vous devrez, soit procéder à la surdéfinition du gestionnaire de signal par défaut dans une classe <classname>TreeView</classname> dérivée, soit utiliser la fonction membre <methodname>connect_notify()</methodname> à la place de <methodname>connect()</methodname>. Vous souhaiterez probablement aussi appeler le gestionnaire par défaut avant de faire quoi que ce soit d'autre ; un clic-droit provoque donc au préalable la sélection de la ligne.Pour connaître la page en cours d'utilisation, servez-vous de la fonction membre <methodname>get_current_page()</methodname>, passez le résultat à <methodname>get_nth_page()</methodname> qui vous renverra un pointeur sur l'élément graphique affiché. Pour changer en cours de programme la page active, utilisez la fonction membre <methodname>set_current_page()</methodname>.Pour connaître la page actuellement affichée, utilisez la fonction membre <methodname>get_current_page()</methodname>. Elle renvoie un numéro de page, puis, en appelant <methodname>get_nth_page()</methodname> avec ce numéro de page, vous obtiendrez un pointeur sur l'élément graphique enfant de la page.Pour savoir quel élément, s'il y lieu, a été sélectionné dans la boîte combinée par l'utilisateur, faites appel à <methodname>ComboBox::get_active()</methodname>. Cette fonction membre renvoie un pointeur sur un <classname>TreeModel::iterator</classname> que vous pouvez déréférencer pour obtenir un objet <classname>Row</classname> afin de lire les valeurs des colonnes. Ainsi, vous pourriez lire à partir du modèle une valeur d'identification sous forme d'un entier, même si vous avez choisi de n'afficher qu'une description littérale dans la boîte combinée. Par exemple :Pour effectuer un tracé dans <application>gtkmm</application> avec Cairo, vous devez au préalable créer un objet <classname>Cairo::Context</classname>. Cette classe contient tous les paramètres d'état graphiques décrivant comment le tracé doit être fait. Ces informations comprennent entre autres l'épaisseur du trait, la couleur, le contour à tracer et de nombreuses autres choses. Cela permet aux fonctions effectives de tracé de ne comporter qu'un minimum de paramètres pour simplifier l'interface. Dans <application>gtkmm</application>, un <classname>Cairo::Context</classname> est créé en appelant la fonction <methodname>Gdk::Window::create_cairo_context()</methodname>. Étant donné que les contextes Cairo sont des objets à décompte de référencement, cette fonction renvoie un objet <classname>Cairo::RefPtr&lt;Cairo::Context&gt;</classname>.Pour basculer dans ce mode, appelez la fonction membre <methodname>pulse()</methodname> à intervalles réguliers. Vous pourrez aussi choisir la durée des intervalles d'appel avec <methodname>set_pulse_step()</methodname>.Pour tracer une ellipse, vous graduez la matrice de transformation de façon différente dans le sens des X et dans le sens des Y. Par exemple, pour tracer une ellipse dans la boîte définie par <varname>x</varname>, <varname>y</varname>, <varname>width</varname>, <varname>height</varname> : <placeholder-1/> Notez que ceci est en contradiction avec la <ulink url="http://www.cairographics.org/manual/cairo-Paths.html#cairo-arc"> directive de la documentation officielle Cairo</ulink>, mais cela semble fonctionner correctement.Pour activer cette fonctionnalité, vous devez créer un objet <classname>EntryCompletion</classname> et le mettre à disposition de l'élément graphique <classname>Entry</classname> par l'intermédiaire de la fonction membre <methodname>set_completion()</methodname>.Pour retrouver quelles sont les lignes sélectionnées par l'utilisateur, obtenez l'objet <classname>Gtk::TreeView::Selection</classname> du <classname>TreeView</classname> ainsi :Pour retrouver quelles sont les cibles actuellement admissibles dans <classname>Clipboard</classname> pour le collage, appelez la fonction membre <methodname>request_targets()</methodname> en indiquant une fonction membre à appeler avec l'information. Par exemple :Pour savoir quel type de gestionnaire de signal vous pouvez connecter, regardez dans la documentation de référence ou dans le fichier d'en-tête. Voici un exemple de déclaration de signal que vous pouvez voir dans les fichiers d'en-tête de <application>gtkmm</application> :Pour forcer le <classname>SpinButton</classname> à arrondir sa valeur au <literal>step_increment</literal> (pas d'incrément) le plus proche, utilisez la fonction membre <methodname>set_snap_to_ticks()</methodname>.Pour créer un objet <classname>Gtk::MenuBar</classname> ou <classname>Gtk::Toolbar</classname> que vous pouvez vraiment afficher, utilisez la fonction membre <methodname>UIManager::get_widget()</methodname> et ajoutez l'élément graphique dans un conteneur. Par exemple :Pour créer juste un exemplaire d'une fenêtre ou d'un élément graphique enfant, vous pouvez indiquer le nom d'un élément graphique en tant que deuxième paramètre. Par exemple, <placeholder-1/>Pour chercher les fichiers récemment utilisés, <classname>RecentManager</classname> dispose de plusieurs fonctions. Pour chercher un élément donné par son URI, utilisez la fonction <methodname>lookup_item()</methodname> qui renvoie un objet de la classe <classname>RecentInfo</classname>. Si l'URI indiqué n'existe pas dans la liste des fichiers récents, l'objet <classname>RecentInfo</classname> sera non valide. <classname>RecentInfo</classname> implémente <methodname>operator bool()</methodname> que vous pouvez utiliser pour tester la validité. Par exemple :Pour que le <classname>SpinButton</classname> « boucle » de la limite supérieure à la limite inférieure de la plage de valeurs (et inversement), utilisez la fonction membre <methodname>set_wrap()</methodname>.Pour obtenir un objet <application>gtkmm</application> à partir d'un élément GObject C, utilisez la fonction  Glib::wrap(). Par exemplePour empaqueter des éléments graphiques dans une boîte de dialogue personnalisée, il convient de les placer dans le <classname>Gtk::VBox</classname>, obtenu par l'intermédiaire de la fonction membre <methodname>get_vbox()</methodname>. Pour simplement ajouter un bouton au bas de l'objet <classname>Dialog</classname>, utilisez la fonction membre <methodname>add_button()</methodname>.Pour placer un élément graphique dans une cellule, utilisez la fonction membre suivante :Pour empêcher l'utilisateur d'entrer des caractères non-numériques dans le champ de saisie, passez le paramètre <literal>true</literal> à la fonction membre <methodname>set_numeric()</methodname>.Pour changer de page sélectionnée au cours du programme, utilisez la fonction membre <methodname>set_current_page()</methodname>.Pour afficher à l'écran plus d'une colonne du modèle dans une colonne de vue, vous aurez besoin de créer un élément graphique <classname>TreeView::Column</classname> manuellement et d'utiliser la fonction membre <methodname>pack_start()</methodname> pour y ajouter les colonnes du modèle.Pour répondre à l'utilisateur qui clique sur une ligne ou une plage de lignes, connectez le signal ainsi :Pour obtenir l'état du <classname>ToggleButton</classname>, utilisez la fonction membre <methodname>get_active()</methodname>. Elle renvoie <literal>true</literal> si le bouton est « enfoncé ». Vous pouvez aussi définir l'état du bouton bascule avec <methodname>set_active()</methodname>. Notez que, si vous faites cet appel et que l'état du bouton est effectivement modifié, le signal « clicked » sera émis : ce comportement est celui habituellement recherché.Pour définir le titre de la page, servez-vous de la fonction membre <methodname>set_page_title()</methodname>. Les images de l'en-tête et du côté de la page sont insérées avec les fonctions membres <methodname>set_page_header_image()</methodname> et <methodname>set_page_side_image()</methodname>.Pour paramétrer <application>jhbuild</application>, suivez les instructions d'installation de base du <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">manuel de jhbuild</ulink>. Après avoir installé <application>jhbuild</application>, recopiez le fichier d'exemple de configuration de <application>jhbuild</application> dans votre répertoire personnel en lançant la commande suivante à partir du répertoire de <application>jhbuild</application> : <command>$ cp sample.jhbuildrc ~/.jhbuildrc</command>Pour afficher le menu contextuel, utilisez la fonction membre <methodname>popup()</methodname> de la classe <classname>Gtk::Menu</classname>. Vous indiquez l'identifiant du bouton de souris et le délai d'activation tels que fournis par le signal <literal>button_press_event</literal>, signal que vous devez gérer de toutes façons. Par exemple :Pour simplifier la compilation, nous utilisons <literal>pkg-config</literal>, présent dans toutes les installations de <application>gtkmm</application> (correctement effectuées). Ce programme « sait » quels sont les commutateurs nécessaires à la compilation des programmes utilisant <application>gtkmm</application>. L'option <literal>--cflags</literal> demande à <literal>pkg-config</literal> de produire la liste des répertoires des en-têtes, répertoires que le compilateur devra parcourir ; l'option <literal>--libs</literal> demande la liste des bibliothèques nécessaires à l'édition des liens par le compilateur ainsi que les répertoires où elles se trouvent. Essayez de lancer directement cette commande à l'invite de votre terminal pour voir les résultats sur votre système.Pour indiquer que du texte dans le tampon doit bénéficier de tel ou tel format, vous devez définir une balise précisant cette information de format, puis appliquer ce balisage à une zone de texte. Ainsi, pour définir le balisage et ses propriétés :Pour utiliser un élément <application>gtkmm</application> avec une fonction C demandant un type d'objet GObject C, servez-vous de la fonction <function>gobj()</function> pour obtenir un pointeur sur l'instance du GObject sous-jacent. Par exemplePour contourner ce problème, vous pouvez écrire un commentaire dans le code source juste avant la chaîne, indiquant au traducteur qu'il peut utiliser le caractère spécial s'il est disponible dans leur langue. Pour l'anglais, vous pouvez ensuite faire une traduction américain-anglais dans <filename>en_US.po</filename> en utilisant ce caractère spécial.Bouton basculeBouton basculeRéférence de ToolItemRéférence de ToolItemGroupPalette d'outilsExemple de palette d'outilsRéférence de ToolPaletteInfobulleRéférence InfobullesInfobullesL'infobulle est un petite fenêtre informative qui apparaît quand vous laissez votre pointeur de souris sur un élément graphique pendant quelques secondes. Servez-vous de la fonction membre <methodname>set_tooltip_text()</methodname> pour définir une chaîne textuelle d'infobulle sur n'importe quel élément graphique de la classe <classname>Widget</classname>. Les objets <classname>Gtk::ToolItem</classname> ne sont pas des objets de la classe <classname>Widget</classname>, mais disposent des mêmes fonctions membres pour des raisons de commodité. <classname>Gtk::Tooltip</classname> s'utilise pour une utilisation plus sophistiquée des infobulles, comme l'affichage d'images et de texte.TreeModel::iterator iter = refTreeSelection-&gt;get_selected();
if(iter) // si quelque chose est sélectionné
{
  TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne.
}Référence de TreeModelSortRéférence de TreeSortableTreeStoreModèle treeStore, pour une hiérarchieTreeView - Glisser-déposerTreeView - Cellules modifiablesTreeView - ListStoreTreeView - Menu contextuelTreeView - TreeStoreQt de Trolltech est le plus proche concurrent de <application>gtkmm</application> ; cela mérite une explication.Essayez d'exécuter l'exemple tout en augmentant la charge de votre système. La barre de progression supérieure doit avancer régulièrement ; l'inférieure devrait ralentir.Essayez de le compiler et de le lancer avant de poursuivre. Vous devriez voir quelque chose comme :Deux paramètres sont optionnels, dans le cas où l'interface dérive d'une autre interface, ce qui doit être le cas quand la GInterface a une autre GInterface prérequise. Par exemple, pour <filename>loadableicon.hg</filename> : <placeholder-1/>Selon la coutume, la librairie habillée s'appellera libsomethingmm. Nous commençons par copier <ulink url="http://git.gnome.org/cgit/mm-common/tree/skeletonmm">l'arborescence des sources squelettes</ulink> à partir du module mm-common. <placeholder-1/>les modifications apportées à l'UI sont visibles plus rapidement, donc plus facilement améliorables,UIManagerImpossibilité de pré-déclarer des structuresMalheureusement, l'intégration avec les flux d'entrée-sortie standards n'est pas d'une utilisation très simple. Si vous dirigez la sortie du flux standard vers un <classname>ostream</classname> avec l'opérateur <function>operator&lt;&lt;</function>, <application>gtkmm</application> convertit les <classname>Glib::ustring</classname> dans un encodage spécifique à l'environnement linguistique (qui généralement n'est pas UTF-8). De la même façon, en récupérant des objets <classname>Glib::ustring</classname> à partir d'un flux <classname>istream</classname> avec l'opérateur <function>operator&gt;&gt;</function>, vous déclenchez la conversion inverse. Mais ce schéma s'effondre si vous passez par un <classname>std::string</classname>, par exemple en dirigeant un flux de texte vers un  <classname>std::string</classname> puis en le convertissant de manière implicite en <classname>Glib::ustring</classname>. Si la chaîne contenait des caractères non-ASCII et que l'environnement linguistique local n'est pas codé en UTF-8, il en résulte un objet <classname>Glib::ustring</classname> corrompu. Vous pouvez contourner ce problème avec une conversion manuelle. Par exemple, pour retrouver l'objet <classname>std::string</classname> à partir d'un <classname>ostringstream</classname> : <placeholder-1/>Unix et LinuxÀ moins que votre conteneur ne soit une fenêtre de haut niveau dérivée de <classname>Gtk::Window</classname>, vous devez également appeler <methodname>Gtk::Widget::set_has_window(false)</methodname> dans le constructeur. Cela signifie que votre conteneur ne crée pas sa propre <classname>Gdk::Window</classname>, mais utilise la fenêtre du parent. (Notez la différence entre <classname>Gtk::Window</classname> et <classname>Gdk::Window</classname>.) Si votre conteneur n'a pas besoin de sa propre <classname>Gdk::Window</classname> et ne dérive pas d'une <classname>Gtk::Window</classname>, vous devez aussi surdéfinir la fonction membre <methodname>on_realize()</methodname> comme cela est décrit dans la section <link linkend="sec-custom-widgets">Éléments graphiques personnalisés</link>. Et, sauf si votre conteneur dessine directement dans la <classname>Gdk::Window</classname> sous-jacente, vous devrez probablement appeler <methodname>set_redraw_on_allocate(false)</methodname> pour améliorer les performances.Contrairement à la solution de l'Unicode UCS-2 de Windows, UTF-8 ne requiert aucune option spéciale de compilation pour le traitement des chaînes de caractères ; en conséquence, il n'existe pas de bibliothèque ou d'exécutable Unicode incompatible avec ceux en ASCII.Contrairement aux autres éléments graphiques de ce chapitre, les éléments graphiques à volet comportent non pas un, mais deux éléments graphiques enfants, un dans chaque volet. C'est pourquoi, vous devez utilisez les fonctions membres <methodname>add1()</methodname> et <methodname>add2()</methodname> au lieu de la fonction membre <methodname>add()</methodname>.Mots inhabituelsPolitiques de mise à jourmettez à jour vos <literal>DISTCLEANFILES</literal> : <placeholder-1/>Utilisez <methodname>Gtk::Builder::get_widget_derived()</methodname> ainsi : <placeholder-1/>Utilisez <application>autoconf</application> et <application>automake</application> de GNU ! Ce sont des amis :) <application>Automake</application> examine les fichiers C, détermine leurs dépendances mutuelles et génère un <filename>Makefile</filename> ; ainsi les fichiers peuvent être compilés dans le bon ordre. <application>Autoconf</application> permet une configuration automatique de l'installation du logiciel en gérant un grand nombre de systèmes exotiques pour augmenter la portabilité.Servez-vous des fonctions membres <methodname>append_page()</methodname>, <methodname>prepend_page()</methodname> et <methodname>insert_page()</methodname> pour ajouter des pages à onglets dans l'objet <literal>Notebook</literal> en précisant l'élément graphique enfant et le nom de l'onglet.Utilisez les fonctions membres <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> et <methodname>insert_page()</methodname> pour ajouter des pages à un objet <classname>Assistant</classname>, tout en indiquant l'élément graphique enfant pour chacune d'entre elles.utilise le dernier paramètre GError* de la fonction C pour déclencher une exception.Si vous habillez une simple structure ou un type de boîte qui autorise un accès direct à ses données membres, utilisez ces macros pour créer les obtenteurs (get) et mutateurs (set) des données membres.Utilisez ces macros pour créer automatiquement des obtenteurs (get) et des mutateurs (set) pour une donnée membre du type pointeur. Pour le mécanisme d'obtention, elle créera deux fonctions membres, une qualifiée <literal>const</literal> et une non-<literal>const</literal>.Utilisez cette macro pour fournir des obtenteurs (get) et des mutateurs (set) pour une donnée membre du type <classname>GObject</classname> nécessitant un référencement avant renvoi.Fonctions membres utilesFacilité d'utilisation des objets AdjustmentUtilisation d'un élément graphique <application>gtkmm</application>Utilisation d'un modèleUtilisation d'éléments graphiques dérivésUtilisation de caractères non-ASCII dans les chaînesUtilisation de la version git de <application>gtkmm</application>Nous supposons également que vous utilisez autotools (c'est-à-dire, <application>automake</application> et <application>autoconf</application>) pour construire le projet et que vous vous servez de <ulink url="http://svn.gnome.org/viewcvs/gnome-common/trunk/autogen.sh?view=markup"><literal>./autogen.sh</literal></ulink> de <application>gnome-common</application>, qui, entre autres choses, effectue certaines initialisations pour <application>intltool</application>.Nous évoquerons également l'élément graphique <classname>Gtk::Paned</classname> qui vous permet de partager une fenêtre en deux « volets » séparés. Cet élément graphique comporte en réalité deux éléments graphiques enfants, mais comme ce nombre est fixe, son classement dans les mono-éléments paraît approprié.Nous venons de vous dire que le signal <literal>clicked</literal> d'un bouton s'attend à appeler une fonction membre sans paramètre d'entrée. Tous les signaux ont des exigences de ce type — vous ne pouvez pas accrocher une fonction avec deux paramètres à un signal n'en attendant aucun (sauf si vous utilisez un adaptateur, tels que <function>sigc::bind()</function>, bien entendu). C'est pourquoi il est important de savoir quel type de gestionnaire de signal vous devez connecter à un signal donné.Nous générons un nouveau groupe par une simple déclaration de variable, <literal>group</literal>, du type <classname>Gtk::RadioButton::Group</classname>, puis nous créons trois boutons radio avec le constructeur indiquant qu'ils font partie du groupe <literal>group</literal>.Il faut mentionner tous les fichiers <filename>.hg</filename> et <filename>.ccg</filename> dans le fichier <filename>skeleton/src/filelist.am</filename>, traditionnellement dans la variable <varname>files_hg</varname>.Vous devez maintenant créer vos premiers fichiers <filename>.hg</filename> et <filename>.ccg</filename> pour habiller quelques objets dans la librairie C. Il y a une paire de fichiers sources à titre d'exemple : <filename>skeleton.ccg</filename> et <filename>skeleton.hg</filename>. Faites des copies de ces fichiers si nécessaire.Ensuite, nous raccordons un gestionnaire de signal pour le signal <literal>clicked</literal> du <literal>m_button</literal>. Le gestionnaire affiche sur <literal>stdout</literal> notre salut amical.Nous indiquons à <application>gtkmm</application> de placer les trois objets <classname>RadioButton</classname> dans un même groupe en obtenant un pointeur sur le groupe avec <methodname>get_group()</methodname> et en utilisant <methodname>set_group()</methodname> pour faire en sorte que les autres <classname>RadioButton</classname> partagent le même groupe.Détaillons maintenant chaque ligne de l'exempleNous souhaitons vivement que vous nous rapportiez tout problème rencontré dans l'apprentissage de <application>gtkmm</application> avec ce document ; cela nous permet d'y apporter des améliorations en conséquence. Veuillez vous reporter au chapitre <link linkend="chapter-contributing">Contribution</link> pour plus d'informations.Nous le raccrochons à l'objet <classname>Gtk::Button</classname> nommé <varname>button</varname>.Nous en savons maintenant assez pour examiner un exemple réel. Pour reprendre une vieille tradition du monde de l'informatique, nous allons maintenant présenter le programme « Hello World » accommodé à la <application>gtkmm</application> :Que se passe-t-il quand un élément graphique reconfigure les champs <parameter>upper</parameter> ou <parameter>lower</parameter> de son <classname>Adjustment</classname>, ou bien, quand un utilisateur ajoute du texte dans un élément graphique texte ? Dans ce cas, l'élément graphique émet le signal <literal>changed</literal>.Quelle est la différence entre espacement (déterminé quand la boîte est crée) et remplissage (défini quand les éléments sont empaquetés) ? L'espacement est inséré entre les objets alors que le remplissage est ajouté sur les côtés du élément graphique. L'illustration ci-après clarifie cela :Quand le <varname>bitmap</varname> est hors de portée, une fonction <methodname>unref()</methodname> se produit en arrière-plan et vous n'avez pas besoin de vous en soucier plus longtemps. Il n'y a pas d'opérateur <literal>new</literal>, il n'est donc pas nécessaire d'appeler <literal>delete</literal>.Quand un constructeur doit être partiellement écrit à la main parce que, par exemple, les paramètres de la fonction C <function>*_new()</function> ne correspondent pas directement aux propriétés de l'objet ou parce que la fonction C <function>*_new()</function> fait plus qu'appeler <function>g_object_new()</function>, la macro <function>_CONSTRUCT()</function> peut s'utiliser dans le fichier .ccg pour s'économiser un peu de travail. La macro <function>_CONSTRUCT</function> prend comme paramètres une série de noms de propriétés et de valeurs. Par exemple, pour <filename>button.ccg</filename> : <placeholder-1/>Quand une destination a accepté un élément glissé, certains signaux vont être émis selon l'action choisie. Par exemple, l'utilisateur peut avoir maintenu enfoncée la touche <keycap>Maj</keycap> pour indiquer un <literal>déplacement</literal> plutôt qu'une <literal>copie</literal>. Souvenez-vous que l'utilisateur ne peut sélectionner que les actions définies dans vos appels à <methodname>drag_dest_set()</methodname> et <methodname>drag_source_set()</methodname>.Quand vous dérivez de la classe <classname>Gtk::Container</classname>, vous pouvez surdéfinir les fonctions membres virtuelles suivantes : <placeholder-1/>Quand vous dérivez de la classe <classname>Gtk::Widget</classname>, vous pouvez surdéfinir les fonctions membres virtuelles. Les fonctions membres marquées (optionnelles) ne nécessitent pas d'être surdéfinies pour tous les éléments graphiques personnalisés. Les fonctions membres de la classe de base peuvent se révéler appropriées. <placeholder-1/>En mode continu, la barre de progression peut aussi afficher un texte configurable dans la glissière, en utilisant la fonction membre <methodname>set_text()</methodname>.Quand le bouton émet le signal <literal>clicked</literal>, <methodname>on_button_clicked()</methodname> est appelé.Quand l'application est lancée, la bibliothèque <application>gettext</application> vérifie dans le répertoire système s'il y a un fichier <filename>.mo</filename> pour l'environnement linguistique de l'utilisateur (environnement que vous pouvez définir avec, par exemple, « export LANG=de_DE.UTF-8 » à partir d'un terminal). Puis, quand le programme atteint un appel <literal>gettext</literal>, il examine s'il existe une traduction pour la chaîne donnée. Si aucune n'est trouvée, la chaîne d'origine est utilisée.Quand la souris est au dessus du bouton et qu'un bouton de souris est pressé, <methodname>on_button_press()</methodname> est appelé.Quand l'utilisateur demande de copier des données, vous devez indiquer à l'objet <classname>Clipboard</classname> quelles sont les cibles disponibles et fournir les fonctions de rappel à utiliser pour obtenir les données. À ce stade, vous stockez une copie des données à fournir quand le presse-papier appelle votre fonction de rappel en réponse à un coller.Quand l'utilisateur demande à coller des données à partir du <classname>Clipboard</classname>, vous devez demander un format défini et fournir une fonction de rappel qui est appelée avec les vraies données. Par exemple :Quand on utilise <function>_CLASS_GOBJECT()</function>, il faut que les constructeurs soient protégés (plutôt que publics) et chaque constructeur doit posséder une fonction correspondante <function>_WRAP_CREATE()</function> dans la section public. Ceci empêche l'instanciation de la classe sans utiliser de <classname>RefPtr</classname>. Par exemple : <placeholder-1/>Si vous vous servez d'un objet <classname>Gtk::TreeStore</classname>, les lignes peuvent avoir des lignes enfants qui, à leur tour, peuvent avoir leur propres enfants. Utilisez <methodname>Gtk::TreeModel::Row::children()</methodname> pour obtenir le conteneur des objets <classname>Row</classname> enfants : <placeholder-1/>En utilisant cette simple surdéfinition de <methodname>append_column()</methodname>, l'objet <classname>TreeView</classname> affiche la donnée du modèle avec un <classname>CellRenderer</classname> approprié. Par exemple, les chaînes littérales et les nombres sont affichés dans un simple contrôle <classname>Gtk::Entry</classname> et les booléens dans un <classname>Gtk::CheckButton</classname>. Cela correspond aux besoins habituels. Pour des colonnes relatives à d'autres types, vous pouvez, soit connecter une fonction de rappel qui convertit avec <methodname>TreeViewColumn::set_cell_data_func()</methodname> le type en chaîne littérale le représentant, soit créer par dérivation un <classname>CellRenderer</classname> personnalisé. Notez que le type <literal>(unsigned) short</literal> n'est pas pris en charge par défaut — à la place, vous pouvez utiliser le type <literal>(unsigned) int</literal> ou <literal>(unsigned) long</literal>.Si vous faites une sélection dans le menu déroulant, la valeur de cette colonne sera placée dans l'élément graphique <classname>Entry</classname>.Chaque fois que cela est possible, vous devez utiliser les éléments du catalogue pour être cohérent avec les autres applications et en améliorer l'aspect en utilisant des icônes. Par exemple, <placeholder-1/> utilise un texte normalisé, dans toutes les langues, avec un raccourci clavier et une icône standard.Pourquoi utiliser <application>gtkmm</application> plutôt que GTK+ ?Référence pour les éléments graphiquesÉléments graphiquesÉléments graphiques sans fenêtre-XÉléments graphiques et ancres pour enfantLes éléments graphiques sont disposés dans des conteneurs tels que cadres et bloc-notes, avec une hiérarchie entre éléments graphiques. Certains de ces conteneurs d'éléments graphiques, comme les <classname>Gtk::Grid</classname>, ne sont pas visibles ‑ ils ne participent qu'à la disposition relative des éléments graphiques. Voici un exemple de code qui place deux contrôles <classname>Gtk::Button</classname> dans un conteneur d'éléments graphiques <classname>Gtk::VBox</classname> : <placeholder-1/> et voici comment ajouter le <classname>Gtk::VBox</classname>, contenant ces boutons, dans un <classname>Gtk::Frame</classname>, qui possède un cadre et un titre visibles : <placeholder-2/>Avec Cairo, on utilise la même fonction pour tracer des arcs, des cercles ou des ellipses : <methodname>Cairo::Context::arc()</methodname>. Cette fonction prend cinq paramètres. Les deux premiers sont les coordonnées du centre de l'arc, le troisième est le rayon et les deux derniers définissent l'angle de début et l'angle de fin de l'arc. Tous les angles sont définis en radians ; ainsi, tracer un cercle est identique au fait de tracer un arc de 0 à 2π radians. L'angle 0 est dans le sens positif des X (dans l'espace utilisateur). L'angle de π/2 radians (90 degrés) est dans le sens positif des Y (dans l'espace utilisateur). Les angles vont croissant en allant de l'axe des X vers l'axe des Y. Ainsi, avec la matrice de transformation par défaut, les angles croissent en tournant dans le sens des aiguilles d'une montre.Travail avec le code source de gtkmmHabillage des paramètres <classname>GList*</classname> et <classname>GSList*</classname> : d'abord, vous devez découvrir quels objets sont contenus dans les champs des données de la liste pour chaque élément, généralement en lisant la documentation de la fonction C. La liste peut être habillée dans un type intermédiaire approprié, tel que <classname>Glib::ListHandle</classname> ou <classname>Glib::SListHandle</classname>. Ce sont des contenus génériques ; vous pouvez donc préciser le type d'élément, par exemple, <code>Glib::ListHandle&lt; Glib::RefPtr&lt;Action&gt; &gt;</code>. Il y a des définitions de type existantes pour quelques types de listes courants. Vous pouvez avoir besoin de définir un type Traits pour préciser comment les types C et C++ doivent être convertis.Habillage des types de retour des <classname>GList*</classname> et <classname>GSList*</classname> : vous devez découvrir comment l'appelant libère la liste et comment il libère les éléments de la liste, à nouveau en lisant la documentation de la fonction C. Avec ces informations vous pouvez choisir le type de propriété (aucun (none), superficiel (shallow), profond (deep)) pour la règle de conversion m4, règle que vous placerez probablement directement dans le fichier .hg parce que le type de propriété dépend plutôt de la fonction que du type, par exemple : <placeholder-1/>Habillage des bibliothèques C avec gmmprocÉcriture de gestionnaires de signalÉcriture des .defs pour les fonctions virtuellesSignaux des événements XOui, ceci est correct : un objet Window peut contenir au plus un élément graphique. Comment, alors, se servir utilement d'une fenêtre ? En y plaçant un conteneur multi-enfants. Les conteneurs d'éléments graphiques les plus utiles sont les objets <classname>Gtk:Grid</classname>, <classname>Gtk:VBox</classname>, <classname>Gtk::HBox</classname> et <classname>Gtk::Table</classname>.Vous allez vraisemblablement rencontrer des problèmes dans la bibliothèque en cours d'habillage, en particulier s'il s'agit d'un nouveau projet. Voici quelques problèmes courants et leurs solutions.Vous n'avez pas la garantie d'obtenir le <literal>Gtk::SizeRequestMode</literal> demandé. C'est pourquoi les quatre fonctions membres <methodname>get_preferred_xxx_vfunc()</methodname> doivent renvoyer des valeurs raisonnables.Il est possible d'ajuster la position de la division avec la fonction membre <methodname>set_position()</methodname> ; vous aurez certainement besoin de le faire.Vous pouvez aussi faire un forçage sur un type dérivé, mais la syntaxe est alors différente de celle pour un pointeur normal.Vous pouvez aussi connecter les signaux du <classname>CellRenderer</classname> pour détecter des actions utilisateur. Par exemple :Vous pouvez également fixer un espacement d'ensemble pour toutes les lignes et toutes les colonnes avec <methodname>set_row_spacings()</methodname> et <methodname>set_col_spacings()</methodname>. Notez qu'avec ces fonctions membres, la dernière ligne et la dernière colonne n'ont pas l'espacement indiqué.Vous pouvez également indiquer le gestionnaire de signal lors de l'appel à <methodname>ActionGroup::add()</methodname>. Ce gestionnaire de signal sera appelé quand l'action sera activée par l'intermédiaire, soit de l'élément de menu, soit du bouton de la barre d'outils.Vous pouvez aussi utiliser <methodname>get_tag_table()</methodname> pour obtenir, et peut-être modifier, l'objet <classname>TagTable</classname> par défaut du <classname>TextBuffer</classname> au lieu d'en créer un explicitement.Vous pouvez appliquer plus d'un objet <classname>Tag</classname> au même texte en utilisant plusieurs fois la fonction membre <methodname>apply_tag()</methodname> ou en utilisant <methodname>insert_with_tags()</methodname>. L'objet <classname>Tag</classname> peut définir des valeurs différentes pour les mêmes propriétés : dans ce cas là, il faut résoudre les conflits avec la fonction membre <methodname>Tag::set_priority()</methodname>.Vous pouvez construire tous les modules GNOME C++ en définissant la valeur de la variable <varname>modules</varname> à celle du méta-paquet nommé <literal>meta-gnome-c++</literal> ou construire tous les modules du noyau de GNOME avec <literal>meta-gnome-desktop</literal>. La variable <varname>modules</varname> indique quels sont les modules à construire quand vous ne précisez pas explicitement quelque chose en ligne de commande. Vous pouvez toujours construire plus tard un module prédéfini différent en le définissant sur la ligne de commande (par exemple, <command>jhbuild build gtkmm</command>).Vous pouvez forcer les <classname>RefPtrs</classname> à des types de base, comme des pointeurs normaux.Vous pouvez copier les <classname>RefPtr</classname>, tout comme des pointeurs normaux. Mais contrairement aux pointeurs normaux, vous n'avez pas à vous soucier de la destruction de l'instance sous-jacente.Il est possible de créer une nouvelle classe <classname>RecentManager</classname>, mais il est plus vraisemblable que vous souhaiterez vous servir de celle par défaut. Vous obtiendrez une référence sur cette dernière avec <methodname>get_default()</methodname>.Vous pouvez déréférencer un pointeur intelligent avec l'opérateur <literal>-&gt;</literal> pour appeler des fonctions membres de l'instance subjacente, comme pour un pointeur normal.Vous pouvez déréférencer l'itérateur pour obtenir la ligne :Avec Cairo, vous pouvez tracer des figures très sophistiquées, mais les fonctions membres pour réaliser cela sont tout à fait simples. Cairo fournit des fonctions membres pour tracer des lignes droites, des lignes courbes et des arcs (y compris des cercles). Ces figures de base peuvent être combinées pour créer des formes complexes et des régions qui peuvent être remplies par des couleurs unies, des dégradés, des motifs et autres choses. En plus, Cairo peut effectuer des transformations complexes, des compositions d'images et effectuer des rendus de texte sans crénelage.Vous pouvez incorporer des éléments graphiques, comme des <classname>Gtk::Button</classname>, dans le texte. Chaque élément graphique de ce type a besoin d'un objet <classname>ChildAnchor</classname>. Les ancrages des (objets) enfants sont associés à des <classname>iterators</classname>. Ainsi, pour créer un ancrage pour un objet enfant à une position donnée, utilisez <methodname>Gtk::TextBuffer::create_child_anchor()</methodname> :Vous pouvez modifier la politique de mise à jour avec la fonction membre <methodname>set_update_policy()</methodname> en choisissant, soit <literal>Gtk::UPDATE_ALWAYS</literal>, soit <literal>Gtk::UPDATE_IF_VALID</literal>. Si vous sélectionnez <literal>Gtk::UPDATE_ALWAYS</literal>, le <classname>SpinButton</classname> ignore les erreurs de conversion en valeur numérique du texte saisi dans la boîte. Par conséquent, ce réglage autorise le <classname>SpinButton</classname> à accepter également des valeurs non-numériques. Vous pouvez forcer une mise à jour immédiate avec la fonction membre <methodname>update()</methodname>.Il est possible de définir la valeur du compteur avec la fonction membre <methodname>set_value()</methodname> et de la récupérer avec <methodname>get_value()</methodname>.Vous pouvez définir le modèle <classname>Gtk::TreeModel</classname> à la construction de l'objet vue <classname>Gtk::TreeView</classname> ou bien vous pouvez utiliser la fonction membre <methodname>set_model()</methodname>, comme suit :Vous pouvez définir un nom pour l'objet <classname>Tag</classname> quand vous appelez la fonction membre <methodname>create()</methodname>, mais ce n'est pas obligatoire.Vous pouvez arrêter l'appel périodique de la fonction en renvoyant <literal>false</literal> à partir du gestionnaire de signal. Mais si vous voulez que la fonction soit réitérée, il faut qu'elle renvoie <literal>true</literal>.Vous pouvez alors connecter le signal « edited » approprié, par exemple, connecter à <methodname>Gtk::CellRendererText::signal_edited()</methodname> ou <methodname>Gtk::CellRendererToggle::signal_toggled()</methodname>. Si la colonne comprend plus d'un <classname>CellRenderer</classname>, vous aurez besoin d'utiliser <methodname>Gtk::TreeView::get_column()</methodname>, puis d'appeler <methodname>get_cell_renderers()</methodname> sur cette colonne de la vue.Vous pouvez ensuite connecter le signal en utilisant la même syntaxe que celle utilisée pour connecter les signaux <application>gtkmm</application>. Par exemple, <placeholder-1/>Puis vous utiliserez ultérieurement la fonction membre <methodname>get_iter()</methodname> pour créer un itérateur pour la nouvelle position de l'objet <classname>Mark</classname>.Vous pouvez utilisez <application>Glade</application> pour placer vos propres éléments graphiques personnalisés, dérivés à partir d'une classe d'élément graphique <application>gtkmm</application>. Vous pouvez ainsi conserver votre code organisé et encapsulé. Bien entendu, vous ne voyez pas l'aspect exact et les propriétés de l'élément graphique dérivé dans <application>Glade</application>, mais vous pouvez indiquer son emplacement, ses éléments graphiques enfants et les propriétés de la classe <application>gtkmm</application> de base.Vous pouvez utiliser des API C, si elles n'ont pas encore d'interfaces C++ commodes. Il n'y a généralement aucun problème avec l'utilisation des API C dans le C++ ; <application>gtkmm</application> vous aide en donnant un accès à l'objet C sous-jacent et en facilitant la création d'un objet C++ enveloppe de l'objet C, à condition que l'API C soit également fondée sur le système GObject.Vous pouvez utiliser la fonction membre <methodname>append_column()</methodname> pour demander à la vue d'afficher certaines colonnes du modèle, dans un certain ordre, avec un certain intitulé.Vous pouvez utiliser la surdéfinition de <methodname>operator[]</methodname> pour obtenir les données d'une colonne particulière dans une ligne, en précisant le <classname>TreeModelColumn</classname> qui a été utilisé pour créer le modèle.Vous pouvez utiliser la surdéfinition de <methodname>operator[]</methodname> pour définir les données d'une colonne désignée dans la ligne en indiquant le <classname>TreeModelColumn</classname> utilisé pour créer le modèle.Utilisez la fonction membre <methodname>toggled()</methodname> pour inverser l'état du bouton, au lieu de l'obliger à être enfoncé ou pas : l'état du bouton est modifié et le signal <literal>toggled</literal> (basculé) est émis.Vous pouvez simplement déclarer ce signal comme une variable membre publique, mais certaines personnes trouvent cela détestable et préfèrent aménager son accessibilité via une fonction membre de mécanisme d'accès, ainsi : <placeholder-1/>Vous pouvez ensuite encapsuler les manipulations des éléments graphiques enfants dans le constructeur de la classe dérivée, avec peut-être <methodname>get_widget()</methodname> ou <methodname>get_widget_derived()</methodname> à nouveau. Par exemple, <placeholder-1/>Il n'est pas toujours nécessaire d'appeler la fonction membre du parent ; certaines fois vous ne le souhaiterez pas. Notez que nous avons appelé la fonction membre du parent <emphasis>après</emphasis> avoir écrit « Hello World », mais nous aurions pu l'appeler avant. Dans cet exemple simple, cela n'a pas beaucoup d'importance, mais parfois si. Avec les signaux, il n'est pas facile de modifier des détails de ce type, et vous pouvez ici faire des choses que vous ne pourrez absolument pas faire avec des gestionnaires de signal connectés : vous pouvez appeler la fonction membre du parent au <emphasis>milieu</emphasis> de votre code personnalisé.Il n'y a pas de moyen d'obtenir un objet <classname>Gdk::Bitmap</classname> vide. Dans l'exemple, <varname>bitmap</varname> est un pointeur intelligent, vous pouvez donc faire ceci, tout comme avec un pointeur normal : <placeholder-1/>Vous pouvez ajouter un onglet personnalisé à la boîte de dialogue d'impression : <placeholder-1/>Peut-être vous demandez-vous comment faire en sorte que <application>gtkmm</application> fasse un travail utile pendant sa période d'inactivité (disons, de sommeil en fait) dans la boucle <methodname>Gtk::Main::run()</methodname>. Il y a heureusement plusieurs possibilités pour cela. En utilisant les fonctions membres suivantes, vous pouvez créer une fonction à délai échu ; elle sera régulièrement appelée avec une périodicité de quelques millisecondes.Peut-être serez-vous surpris d'apprendre que <application>gtkmm</application> n'utilise pas la classe <classname>std::string</classname> dans ses interfaces. À la place, <application>gtkmm</application> utilise la classe <classname>Glib::ustring</classname> ; les deux classes sont tout à fait semblables et tellement amalgamées que vous pouvez vraiment prétendre que chaque Glib::ustring est un <classname>std::string</classname> et ignorer la suite de ce paragraphe. Mais poursuivez la lecture si vous voulez utiliser des langues autres que l'anglais dans vos applications.Vous pouvez avoir besoin de réagir à un changement de sélection dans la boîte combinée, par exemple pour mettre à jour d'autres éléments graphiques. Pour cela, vous devez gérer le signal « changed ». Par exemple :Vous ne devez pas anticiper le besoin de prendre en charge telles ou telles autres langues, mais vous ne devez jamais en exclure l'utilisation. De plus, il est plus facile de développer une application correctement dès le début que de l'améliorer après coup.Vous pouvez trouver occasionnellement utile de gérer les événements X quand il y a quelque chose  que vous ne pouvez pas réaliser avec les signaux normaux. <classname>Gtk::Button</classname>, par exemple, ne renvoie pas les coordonnées du pointeur de souris avec le signal <literal>clicked</literal>, mais en gérant <literal>button_pressed_event</literal>, vous pouvez obtenir cette information. Les événements X sont également souvent utilisés pour gérer les touches pressées.Vous pouvez après cela gérer le signal <literal>clicked</literal> sur l'objet <classname>ToolButton</classname>. Autre possibilité, vous pouvez autoriser le glisser-déposer de l'élément sur un autre élément graphique avec <methodname>Gtk::ToolPalette::add_drag_dest()</methodname>, puis en faisant appel à <methodname>Gtk::ToolPalette::get_drag_item()</methodname> dans le gestionnaire du signal <literal>drag_data_received</literal> de l'autre élément graphique.Vous pouvez associer des données supplémentaires à chaque ligne. Pour ce faire, ajoutez-les en tant que colonne du modèle, mais sans les placer dans la vue.Vous pouvez vouloir être prévenu chaque fois que l'utilisateur saisit du texte dans un contrôle de saisie. À cette fin, <classname>Gtk::Entry</classname> dispose de deux signaux : <literal>activate</literal> (activé) et <literal>changed</literal> (modifié). <literal>activate</literal> est émis quand l'utilisateur presse la touche Entrée dans l'élément graphique, <literal>changed</literal> quand le contenu de l'élément graphique est modifié. Vous pouvez vous servir de ces signaux, par exemple, pour valider ou filtrer le texte que l'utilisateur saisit.Vous voudrez peut-être inclure des fichiers sources additionnels qui n'auraient pas été générés par <command>gmmproc</command> à partir des fichiers <filename>.hg</filename> et <filename>.ccg</filename>. Placez-les simplement dans le répertoire <filename>libsomething/libsomethingmm</filename> et mentionnez-les dans le fichier <filename>Makefile.am</filename> dans les variables <varname>files_extra_h</varname> et <varname>files_extra_cc</varname>.Vous pouvez souhaiter réutiliser la documentation existante de la bibliothèque C que vous êtes en train d'habiller. Les bibliothèques du style C GTK utilisent généralement gtk-doc ; les commentaires de leur code source est donc formaté pour gtk-doc avec de la documentation supplémentaire dans des fichiers .tmpl. Le script docextract_to_xml.py, situé dans le répertoire codegen de pygobject, est capable de lire ces fichiers et de générer un fichier .xml que <command>gmmproc</command> peut utiliser pour générer à son tour des commentaires doxygen. <command>gmmproc</command> essaye même de transformer la documentation pour mieux l'adapter à une API C++.Vous devez faire appel au constructeur de la classe de base dans la liste d'initialisation, en fournissant le pointeur C. Par exemple, <placeholder-1/>Vous devez rédiger le code source de votre propre outil <filename>generate_extra_defs</filename> pour générer les fichiers <filename>.defs</filename> des types C GObject que vous souhaitez habiller. Dans l'arborescence des sources squelettes, le fichier source s'appelle <filename>codegen/extradefs/generate_extra_defs_skeleton.cc</filename>. Si ce n'est pas déjà fait, le fichier doit être renommé en remplaçant la variable de substitution <varname>skeleton</varname> par le nom de base de la nouvelle liaison. Le fichier <filename>codegen/Makefile.am</filename> doit également citer le nouveau nom du fichier source.Il est nécessaire de préciser les caractéristiques de l'objet <classname>Alignment</classname> dans son constructeur, ou bien à l'aide de la fonction membre <methodname>set()</methodname>. En particulier, vous ne noterez aucun effet si vous ne définissez pas un nombre différent de 1.0 pour les paramètres <literal>xscale</literal> et <literal>yscale</literal> ; en effet, 1.0 signifie simplement que l'élément graphique enfant doit prendre tout l'espace disponible.Vous ne savez jamais quel sera l'espace pris à l'écran par une chaîne après traduction. Il est tout à fait possible qu'elle soit deux fois plus longue que la chaîne originelle en anglais. Par chance, la plupart des éléments graphiques <application>gtkmm</application> se redimensionnent à la taille voulue lors de l'exécution.Vous n'aurez probablement pas besoin d'attacher un gestionnaire à ce signal, sauf si vous écrivez un nouveau type d'élément graphique à plage de réglage.Vous devez éviter les arithmétiques de pointeurs dans le style du C et les fonctions comme strlen(). En UTF-8, chaque caractère peut nécessiter de 1 à 6 octets ; il n'est donc pas possible de présupposer que l'octet suivant est un nouveau caractère. <classname>Glib::ustring</classname> se préoccupe de ces détails à votre place ; vous pouvez employer des fonctions membres telles que Glib::ustring::substr() en pensant caractères et non octets.Vous devez éviter les abréviations mystérieuses, l'argot ou du jargon de spécialiste. Ces termes sont généralement difficiles à traduire et souvent même à comprendre pour les autochtones. Par exemple, préférez « application » à « app ».Nous nous abstenons d'inclure le fichier d'en-tête C à partir de l'en-tête C++ pour éviter de polluer l'espace de noms global et pour éviter d'exporter des API publiques non nécessaires. Mais vous aurez besoin d'inclure les en-têtes C nécessaires à partir de votre fichier .ccg.Il faut être très précautionneux si vous faites une installation avec comme préfixe un des répertoires système standard, comme <filename>/usr</filename>. Les distributions Linux installent leurs paquets logiciels dans <filename>/usr</filename> ; donc, le fait d'installer un paquet source dans ce répertoire peut corrompre ou entrer en conflit avec un logiciel installé par le système de gestion des paquets de votre distribution. Dans un monde idéal, vous devriez utiliser un préfixe à part pour tous les logiciels installés à partir des sources.Enregistrez l'objet <classname>Gtk::PageSetup</classname> avec vos choix, ainsi vous pourrez l'utiliser à nouveau si la boîte de dialogue de mise en page est à nouveau affichée.Ensuite vous ferez un forçage du type de ce pointeur <classname>Gtk::CellRenderer*</classname> vers un <classname>CellRenderer</classname> donné, conforme à vos attentes. Vous utilisez ainsi une API particulière.Vous précisez le <classname>ColumnRecord</classname> à la création du modèle, ainsi :Vous aurez encore besoin de code C++ pour gérer les transactions sur l'interface déclenchées par les actions de l'utilisateur, mais l'utilisation de <application>Gtk::Builder</application> pour la disposition des éléments graphiques vous permet de vous concentrer sur l'implémentation des fonctionnalités.Vous avez probablement remarqué que les fenêtres <application>gtkmm</application> semblent « élastiques » — elles peuvent être étirées de diverses manières. Cette propriété résulte du système « d'empaquetage des éléments graphiques ».Votre fonction de rappel fournit alors les données enregistrées quand l'utilisateur décide de coller les données. Par exemple :Votre classe dérivée doit avoir un constructeur prenant comme paramètre un pointeur sur le type C sous-jacent et l'instance de <classname>Gtk::Builder</classname>. Toutes les classes <application>gtkmm</application> en rapport définissent leurs types C sous-jacents en tant qu'objets <classname>BaseObjectType</classname> (par exemple <classname>Gtk::Dialog</classname> défini son type <classname>BaseObjectType</classname> comme <literal>GtkDialog</literal>).Vos connaissances en matière de C++ vous seront d'un bon secours pour <application>gtkmm</application> comme pour toute autre bibliothèque. À moins que nous n'indiquions le contraire, vous pouvez vous attendre à ce que les classes <application>gtkmm</application> aient un comportement identique à celui des autres classes C++ et donc à utiliser vos techniques C++ habituelles avec elles.Votre implémentation de la fonction membre <methodname>child_type_vfunc()</methodname> doit renvoyer le type d'élément graphique pouvant être ajouté à votre conteneur s'il n'est pas encore rempli. Généralement, c'est à <methodname>Gtk::Widget::get_type()</methodname> d'indiquer quelles sont les classes dérivées de <classname>Gtk::Widget</classname> acceptées. Si le conteneur ne peut plus contenir d'autres éléments graphiques, cette fonction membre doit renvoyer la valeur <literal>G_TYPE_NONE</literal>.Avant de pouvoir vous servir de votre bibliothèque, il faut l'initialiser pour enregistrer les nouveaux types à disposition. La bibliothèque C que vous habillez doit aussi avoir sa propre fonction d'initialisation ; vous devrez l'appeler. Vous pouvez effectuer cette opération dans une fonction <function>init()</function> placée dans des fichiers <filename>init.h</filename> et <filename>init.cc</filename> codés à la main. Cette fonction doit initialiser vos dépendances (comme la fonction C et <application>gtkmm</application>) et appeler la fonction <function>wrap_init()</function> générée. Par exemple : <placeholder-1/>_CLASS_BOXEDTYPE_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )_CLASS_BOXEDTYPE_STATIC_CLASS_BOXEDTYPE_STATIC( C++ class, C class )_CLASS_GENERIC_CLASS_GENERIC( C++ class, C class )_CLASS_GOBJECT_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )_CLASS_GTKOBJECT_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )_CLASS_GTKOBJECT()_CLASS_INTERFACE_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )_CLASS_OPAQUE_COPYABLE_CLASS_OPAQUE_COPYABLE( C++ class,
                        C class,
                        new function,
                        copy function,
                        free function )_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, ref function, unref function )_CLASS_OPAQUE_REFCOUNTED_CTOR_DEFAULT_DEFS()_IGNORE()_IGNORE(C function name 1, C function name2, etc)_MEMBER_GET / _MEMBER_SET_MEMBER_GET(C++ name, C name, C++ type, C type)_MEMBER_GET(x, x, int, int)_MEMBER_GET_GOBJECT / _MEMBER_SET_GOBJECT_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)_MEMBER_GET_PTR / _MEMBER_SET_PTR_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)_MEMBER_SET(C++ name, C name, C++ type, C type)_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)_PINCLUDE()_WRAP_CTOR_WRAP_ENUM_WRAP_GERROR_WRAP_METHOD_WRAP_METHOD( C++ method signature, C function name)_WRAP_METHOD_DOCS_ONLY_WRAP_METHOD_DOCS_ONLY(C function name)_WRAP_PROPERTY_WRAP_PROPERTY(C property name, C++ type)_WRAP_SIGNAL_WRAP_SIGNAL( C++ signal handler signature, C signal name)adj.value_changed.connect(sigc::bind&lt;Widget*&gt;(sigc::mem_fun(*this,
    &amp;cb_rotate_picture), picture));adjustment-&gt;changed();et la connectez à l'ajustement de l'élément graphique <literal>Scale</literal> ainsi :puisbinding_namebindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);boolbool DemoWindow::select_function(
    const Glib::RefPtr&lt;Gtk::TreeModel&gt;&amp; model,
    const Gtk::TreeModel::Path&amp; path, bool)
{
  const Gtk::TreeModel::iterator iter = model-&gt;get_iter(path);
  // n'autoriser que la sélection des nœuds d'extrémité
  return iter-&gt;children().empty(); 
}bool ExampleWindow::on_button_press_event(GdkEventButton* event)
{
  if( (event-&gt;type == GDK_BUTTON_PRESS) &amp;&amp;
      (event-&gt;button == 3) )
  {
    m_Menu_Popup-&gt;popup(event-&gt;button, event-&gt;time);
    return true; // Il est géré.
  }
  else
    return false;
}bool myarea::on_expose_event(GdkEventExpose* ev)
{
Glib::RefPtr&lt;Gdk::Pixbuf&gt; image = Gdk::Pixbuf::create_from_file("myimage.png");
image-&gt;render_to_drawable(get_window(), get_style()-&gt;get_black_gc(),
0, 0, 100, 80, image-&gt;get_width(), image-&gt;get_height(),
// tracer la totalité de l'image (de 0,0 à toute la largeur,hauteur) à 100,80
// dans la fenêtre
Gdk::RGB_DITHER_NONE, 0, 0);
return true;
}Exemple de boutoncairocairommcell.property_editable() = true;class HelloWorld : public Gtk::Window
{

public:
  HelloWorld();
  virtual ~HelloWorld();

protected:
  //Gestionnaire de signal :
  virtual void on_button_clicked();

  //éléments graphiques membres :
  Gtk::Button m_button;
};class ModelColumns : public Gtk::TreeModelColumnRecord
{
public:

  ModelColumns()
    { add(m_col_text); add(m_col_number); }

  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_text;
  Gtk::TreeModelColumn&lt;int&gt; m_col_number;
};

ModelColumns m_Columns;class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();

protected:
    Gtk::RadioButton m_rb1, m_rb2, m_rb3;
};

RadioButtons::RadioButtons()
  : m_rb1("Bouton1"),
    m_rb2("Bouton2"),
    m_rb3("Bouton3")
{
    Gtk::RadioButton::Group group = m_rb1.get_group();
    m_rb2.set_group(group);
    m_rb3.set_group(group);
}class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();
};

RadioButtons::RadioButtons()
{
    Gtk::RadioButton::Group group;
    Gtk::RadioButton *m_rb1 = Gtk::manage(
      new Gtk::RadioButton(group,"Bouton1"));
    Gtk::RadioButton *m_rb2 = manage(
      new Gtk::RadioButton(group,"Bouton2"));
    Gtk::RadioButton *m_rb3 = manage(
      new Gtk::RadioButton(group,"Bouton3"));
}clicked (cliqué)configure.acconstversioncontext-&gt;save();
context-&gt;translate(x, y);
context-&gt;scale(width / 2.0, height / 2.0);
context-&gt;arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
context-&gt;restore();deprecateddisplay_message("Getting ready for i18n.");display_message(_("Getting ready for i18n."));doubleenter (entré)énumérationserrthrowevent_box.add(child_widget);drapeaux : utilisé seulement pour le glisser-déposer, il indique si les données peuvent être glisser vers d'autres éléments graphiques et applications ou seulement vers les mêmes éléments graphiques.foo.add( (w=new Gtk::Label("Hello"), w-&gt;set_manage(), &amp;w) );foo.add( manage(new Gtk::Label("Hello")) );fonctionsg++ simple.cc -o simple `pkg-config gtkmm-2.4 --cflags --libs`gbooleangchar*gdk-pixbufgdoubleManuel gettextgintglibgnomemm_hellogtk.defsgtk_enums.defsgtk_methods.defsgtk_signals.defsgtk_vfuncs.defsgtkmmgtkmm-2.4 est le nom de l'actuelle API stable. Il existe une API plus ancienne nommée gtkmm-2-0 qui s'installe en parallèle quand elle est disponible. Il existe plusieurs versions de gtkmm-2.4, comme gtkmm 2.10. Notez que le nom de l'API ne change pas pour chaque version car il y aurait rupture de compatibilité de l'API et ABI. En théorie, une future API gtkmm-3.0 API devrait paraître. Elle s'installera en parallèle avec gtkmm-2.4 sans affecter les applications existantes.gtkmm_helloguintgunicharinfo : un identifiant envoyé aux signaux pour indiquer quel TargetEntry a été utilisé.intint main(int argc, char** argv)
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  Gtk::Main::run(helloworld);

  return 0;
}intltool-update --potest équivalent àlabel.set_text(compose(_("Really delete %1 now?"), filename));leave (quitté)lib_LTLIBRARIESlibsigc++ 2.0Conversions m4m_TextView.add_child_at_anchor(m_Button, refAnchor);m_TreeView.append_column("Messages", m_Columns.m_col_text);m_TreeView.set_model(m_refListStore);m_box.pack_start(m_Button1);
m_box.pack_start(m_Button2);m_button1.signal_clicked().connect( sigc::mem_fun(*this,
  &amp;HelloWorld::on_button_clicked) );m_combo.set_entry_text_column(m_columns.m_col_name);m_combo.signal_changed().connect( sigc::mem_fun(*this,
      &amp;ExampleWindow::on_combo_changed) );m_frame.add(m_box);m_rb2.set_group(m_rb1.get_group()); // ne fonctionne pas !m_refActionGroup = Gtk::ActionGroup::create();

m_refActionGroup-&gt;add( Gtk::Action::create("MenuFile", "_File") );
m_refActionGroup-&gt;add( Gtk::Action::create("New", Gtk::Stock::NEW),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_new) );
m_refActionGroup-&gt;add( Gtk::Action::create("ExportData", "Export Data"),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_open) );
m_refActionGroup-&gt;add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_quit) );m_refTreeSelection-&gt;set_select_function( sigc::mem_fun(*this,
    &amp;DemoWindow::select_function) );modules = [ 'gtkmm', ]moduleset = 'gnome-2.30'no_default_handlerobjets (GObjects, éléments graphiques, interfaces, types de boîtes et structures brutes)oupkg-configpressed (enfoncé)propriétésrefBuffer-&gt;apply_tag(refTagMatch, iterRangeStart, iterRangeStop);refClipboard-&gt;request_contents("example_custom_target",
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_received) );refClipboard-&gt;request_targets( sigc::mem_fun(*this,
    &amp;ExampleWindow::on_clipboard_received_targets) );refTreeSelection-&gt;selected_foreach_iter(
    sigc::mem_fun(*this, &amp;TheClass::selected_row_callback) );

void TheClass::selected_row_callback(
    const Gtk::TreeModel::iterator&amp; iter)
{
  TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne.
}refTreeSelection-&gt;set_mode(Gtk::SELECTION_MULTIPLE);refTreeSelection-&gt;signal_changed().connect(
    sigc::mem_fun(*this, &amp;Example_StockBrowser::on_selection_changed)
);refreturnreleased (relâché)row[m_Columns.m_col_text] = "textedonné";signauxsrc/main.cc
src/other.ccstd::cout &lt;&lt; _("Current amount: ") &lt;&lt; amount
          &lt;&lt; _(" Future: ") &lt;&lt; future &lt;&lt; std::endl;

label.set_text(_("Really delete ") + filename + _(" now?"));std::ostringstream output;
output.imbue(std::locale("")); // utiliser la locale de l'utilisateur pour ce flux
output &lt;&lt; percentage &lt;&lt; " % done";
label-&gt;set_text(Glib::locale_to_utf8(output.str()));std::stringstd::string utilise 8 bits par caractère, mais 8 bits ne sont pas suffisants pour coder des langues telles que l'arabe, le chinois ou le japonais. Même si les codages pour ces langues ont maintenant été définis par le Consortium Unicode, les langages informatiques C et C++ ne fournissent pas encore une prise en charge normalisée de l'Unicode. GTK+ et GNOME ont choisi d'implémenter l'Unicode en utilisant l'UTF-8 ; c'est ce codage qui est intégré dans Glib::ustring. Il fournit une interface pratiquement identique à  std::string, tout en permettant des conversions automatiques de ou vers std::string.std::vector&lt;Gtk::RecentInfo&gt; info_list = recent_manager-&gt;get_items();cible : un nom, tel que « STRING »Géode <Géodebay@gmail.com>, 2010-2011
Bruno Brouard <annoa.b@gmail.com>, 2010-2011typedef Gtk::TreeModel::Children type_children; // minimise la longueur du code.
type_children children = refModel-&gt;children();
for(type_children::iterator iter = children.begin();
    iter != children.end(); ++iter)
{
  Gtk::TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne - voir plus haut pour set/get.
}fonctions virtuelles.fonctions virtuelles (champs de pointeurs membres de fonction dans des structures), écrites à la main.void ExampleWindow::on_button_delete()
{
  Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
      m_treeview.get_selection();
  if(refTreeSelection)
  {
    Gtk::TreeModel::iterator sorted_iter =
        m_refTreeSelection-&gt;get_selected();
    if(sorted_iter)
    {
      Gtk::TreeModel::iterator iter =
          m_refModelSort-&gt;convert_iter_to_child_iter(sorted_iter);
      m_refModel-&gt;erase(iter);
    }
  }
}void ExampleWindow::on_clipboard_get(
    Gtk::SelectionData&amp; selection_data, guint info)
{
  const Glib::ustring target = selection_data.get_target();

  if(target == "example_custom_target")
    selection_data.set("example_custom_target", m_ClipboardStore);
}void ExampleWindow::on_clipboard_received(
    const Gtk::SelectionData&amp; selection_data)
{
  Glib::ustring clipboard_data = selection_data.get_data_as_string();
  // Faire quelque choses avec les données collées.
}void ExampleWindow::on_clipboard_received_targets(
  const Glib::StringArrayHandle&amp; targets_array)
{
  // Obtenir la liste des cibles disponibles dans le presse-papier :
  std::list&lt;std::string&gt; targets = targets_array;

  const bool bPasteIsPossible =
    std::find(targets.begin(), targets.end(),
      example_target_custom) != targets.end();

  // Activer/désactiver le bouton Coller de manière appropriée :
  m_Button_Paste.set_sensitive(bPasteIsPossible);
}void Gtk::Table::attach(Gtk::Widget&amp; child,
                        guint left_attach, guint right_attach,
                        guint top_attach, guint bottom_attach,
                        guint xoptions = Gtk::FILL | Gtk::EXPAND,
                        guint yoptions = Gtk::FILL | Gtk::EXPAND,
                        guint xpadding = 0, guint ypadding = 0);void cb_rotate_picture (Gtk::Widget *picture)
{
  picture-&gt;set_rotation (adj-&gt;value);
...void doSomething(Cairo::RefPtr&lt;Cairo::Context&gt; context, int x)
{
    context-&gt;save();
    // modifier l'état graphique
    // réaliser les opérations de tracé
    context-&gt;restore();
}void drag_dest_set(const ArrayHandle_TargetEntry&amp; targets,
    GtkDestDefaults flags, GdkDragAction actions);void drag_source_set(const ArrayHandle_TargetEntry&amp; targets,
      GdkModifierType start_button_mask, GdkDragAction actions);void pack_start(Gtk::Widget&amp; child,
                PackOptions options = PACK_EXPAND_WIDGET,
                guint padding = 0);Le paramètre <literal>percentage</literal> est un nombre, entre 0 et 1, indiquant la proportion de remplissage de la barre.où le paramètre <parameter>condition</parameter> est tel que précisé ci-dessus. Comme d'habitude, le connecteur est créé avec <function>sigc::mem_fun()</function> (pour une fonction membre d'un objet) ou <function>sigc::ptr_fun()</function> (pour une fonction).wrap_init_flagsxgettext -a -o my-strings --omit-header *.cc *.h