ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/Deliantra-Client/DC/UI.pm

Comparing deliantra/Deliantra-Client/DC/UI.pm (file contents):
Revision 1.35 by root, Sun Apr 9 17:34:15 2006 UTC vs.
Revision 1.63 by root, Tue Apr 11 13:29:24 2006 UTC

1	package Crossfire::Client::Widget;	1	package CFClient::Widget;
2		2
3	use strict;	3	use strict;
4		4
5	use Scalar::Util;	5	use Scalar::Util;
6		6
7	use SDL::OpenGL;	7	use SDL::OpenGL;
8	use SDL::OpenGL::Constants;	8	use SDL::OpenGL::Constants;
9		9
10	our $FOCUS; # the widget with current focus	10	use CFClient;
11	#our @ACTIVE_WIDGETS;	11
		12	our ($FOCUS, $HOVER, $GRAB); # various widgets
		13
		14	our $TOPLEVEL;
		15	our $BUTTON_STATE;
12		16
13	# class methods for events	17	# class methods for events
14	sub feed_sdl_key_down_event { $FOCUS->key_down ($_[0]) if $FOCUS }	18	sub feed_sdl_key_down_event {
15	sub feed_sdl_key_up_event { $FOCUS->key_up ($_[0]) if $FOCUS }	19	$FOCUS->key_down ($_[0]) if $FOCUS;
		20	}
		21
		22	sub feed_sdl_key_up_event {
		23	$FOCUS->key_up ($_[0]) if $FOCUS;
		24	}
		25
16	sub feed_sdl_button_down_event { }	26	sub feed_sdl_button_down_event {
		27	my ($ev) = @_;
		28	my ($x, $y) = ($ev->motion_x, $ev->motion_y);
		29
		30	if (!$BUTTON_STATE) {
		31	my $widget = $TOPLEVEL->find_widget ($x, $y);
		32
		33	$GRAB = $widget;
		34	$GRAB->update if $GRAB;
		35	}
		36
		37	$BUTTON_STATE |= 1 << ($ev->button - 1);
		38
		39	$GRAB->button_down ($ev, $GRAB->translate ($x, $y)) if $GRAB;
		40	}
		41
17	sub feed_sdl_button_up_event { }	42	sub feed_sdl_button_up_event {
		43	my ($ev) = @_;
		44	my ($x, $y) = ($ev->motion_x, $ev->motion_y);
		45
		46	my $widget = $GRAB || $TOPLEVEL->find_widget ($x, $y);
		47
		48	$BUTTON_STATE &= ~(1 << ($ev->button - 1));
		49
		50	$GRAB->button_down ($ev, $GRAB->translate ($x, $y)) if $GRAB;
		51
		52	if (!$BUTTON_STATE) {
		53	my $grab = $GRAB; undef $GRAB;
		54	$grab->update if $grab;
		55	$GRAB->update if $GRAB;
		56	}
		57	}
		58
		59	sub feed_sdl_motion_event {
		60	my ($ev) = @_;
		61	my ($x, $y) = ($ev->motion_x, $ev->motion_y);
		62
		63	my $widget = $GRAB || $TOPLEVEL->find_widget ($x, $y);
		64
		65	if ($widget != $HOVER) {
		66	my $hover = $HOVER; $HOVER = $widget;
		67
		68	$hover->update if $hover;
		69	$HOVER->update if $HOVER;
		70	}
		71
		72	$HOVER->mouse_motion ($ev, $HOVER->translate ($x, $y)) if $HOVER;
		73	}
18		74
19	sub new {	75	sub new {
20	my $class = shift;	76	my $class = shift;
21		77
22	bless { @_ }, $class	78	bless { @_ }, $class
23	}	79	}
24
25	#sub activate {
26	# push @ACTIVE_WIDGETS, $_[0];
27	# Scalar::Util::weaken $ACTIVE_WIDGETS[-1];
28	#}
29
30	#sub deactivate {
31	# @ACTIVE_WIDGETS =
32	# sort { $a->{z} <=> $b->{z} }
33	# grep { $_ && $_ != $_[0] }
34	# @ACTIVE_WIDGETS;
35	#}
36		80
37	sub move {	81	sub move {
38	my ($self, $x, $y, $z) = @_;	82	my ($self, $x, $y, $z) = @_;
39	$self->{x} = $x;	83	$self->{x} = $x;
40	$self->{y} = $y;	84	$self->{y} = $y;
…		…
44	sub needs_redraw {	88	sub needs_redraw {
45	0	89	0
46	}	90	}
47		91
48	sub size_request {	92	sub size_request {
		93	require Carp;
49	die "size_request is abtract";	94	Carp::confess "size_request is abtract";
		95	}
		96
		97	sub size_allocate {
		98	my ($self, $w, $h) = @_;
		99
		100	$self->{w} = $w;
		101	$self->{h} = $h;
		102	}
		103
		104	# translate global koordinates to local coordinate system
		105	sub translate {
		106	my ($self, $x, $y) = @_;
		107
		108	$self->{parent}->translate ($x - $self->{x}, $y - $self->{y});
50	}	109	}
51		110
52	sub focus_in {	111	sub focus_in {
53	my ($widget) = @_;	112	my ($self) = @_;
54	$FOCUS = $widget;	113
		114	my $focus = $FOCUS; $FOCUS = $self;
		115	$focus->update if $focus;
		116	$FOCUS->update;
55	}	117	}
56		118
57	sub focus_out {	119	sub focus_out {
58	my ($widget) = @_;	120	my ($self) = @_;
59	}
60		121
61	sub key_down {	122	return unless $FOCUS == $self;
62	my ($widget, $sdlev) = @_;
63	}
64		123
65	sub key_up {	124	my $focus = $FOCUS; undef $FOCUS;
66	my ($widget, $sdlev) = @_;	125	$focus->update if $focus; #?
67	}	126	}
68		127
		128	sub mouse_motion { }
		129	sub button_up { }
69	sub button_down {	130	sub button_down { }
70	my ($widget, $sdlev) = @_;	131	sub key_down { }
71	}	132	sub key_up { }
72		133
73	sub button_up {	134	sub w { $_[0]{w} = $_[1] if @_ > 1; $_[0]{w} }
74	my ($widget, $sdlev) = @_;	135	sub h { $_[0]{h} = $_[1] if @_ > 1; $_[0]{h} }
75	}
76
77	sub w { $_[0]->{w} }
78	sub h { $_[0]->{h} }
79	sub x { $_[0]->{x} = $_[1] if $_[1]; $_[0]->{x} }	136	sub x { $_[0]{x} = $_[1] if @_ > 1; $_[0]{x} }
80	sub y { $_[0]->{y} = $_[1] if $_[1]; $_[0]->{y} }	137	sub y { $_[0]{y} = $_[1] if @_ > 1; $_[0]{y} }
81	sub z { $_[0]->{z} = $_[1] if $_[1]; $_[0]->{z} }	138	sub z { $_[0]{z} = $_[1] if @_ > 1; $_[0]{z} }
82		139
83	sub draw {	140	sub draw {
84	my ($self) = @_;	141	my ($self) = @_;
85		142
86	glPushMatrix;	143	glPushMatrix;
87	glTranslate $self->{x}, $self->{y}, 0;	144	glTranslate $self->{x}, $self->{y}, 0;
88	$self->_draw;	145	$self->_draw;
		146	if ($self == $HOVER) {
		147	glColor 1, 1, 1, 0.4;
		148	glEnable GL_BLEND;
		149	glBegin GL_QUADS;
		150	glVertex 0 , 0;
		151	glVertex $self->{w}, 0;
		152	glVertex $self->{w}, $self->{h};
		153	glVertex 0 , $self->{h};
		154	glEnd;
		155	glDisable GL_BLEND;
		156	}
89	glPopMatrix;	157	glPopMatrix;
90	}	158	}
91		159
92	sub _draw {	160	sub _draw {
93	my ($widget) = @_;	161	my ($self) = @_;
		162
		163	warn "no draw defined for $self\n";
94	}	164	}
95		165
96	sub bbox {	166	sub bbox {
97	my ($self) = @_;	167	my ($self) = @_;
98	my ($w, $h) = $self->size_request;	168	my ($w, $h) = $self->size_request;
…		…
102	$self->{x} = $w,	172	$self->{x} = $w,
103	$self->{y} = $h	173	$self->{y} = $h
104	)	174	)
105	}	175	}
106		176
		177	sub find_widget {
		178	my ($self, $x, $y) = @_;
		179
		180	return $self
		181	if $x >= $self->{x} && $x < $self->{x} + $self->{w}
		182	&& $y >= $self->{y} && $y < $self->{y} + $self->{h};
		183
		184	()
		185	}
		186
107	sub del_parent { $_[0]->{parent} = undef }	187	sub del_parent { $_[0]->{parent} = undef }
108		188
109	sub set_parent {	189	sub set_parent {
110	my ($self, $par) = @_;	190	my ($self, $par) = @_;
111		191
…		…
128	my ($self) = @_;	208	my ($self) = @_;
129		209
130	#$self->deactivate;	210	#$self->deactivate;
131	}	211	}
132		212
133	package Crossfire::Client::Widget::Bin;	213	#############################################################################
134		214
		215	package CFClient::Widget::Container;
		216
135	our @ISA = Crossfire::Client::Widget::;	217	our @ISA = CFClient::Widget::;
136		218
137	sub add { $_[0]->{child} = $_[1]; $_[1]->set_parent ($_[0]); $_[1]->update }	219	sub new {
		220	my ($class, @widgets) = @_;
138		221
139	sub get { $_[0]->{child} }	222	my $self = $class->SUPER::new (children => []);
		223	$self->add ($_) for @widgets;
		224
		225	$self
		226	}
		227
		228	sub add {
		229	my ($self, $chld, $expand) = @_;
		230
		231	$chld->{expand} = $expand;
		232	$chld->set_parent ($self);
		233
		234	@{$self->{children}} =
		235	sort { $a->{z} <=> $b->{z} }
		236	@{$self->{children}}, $chld;
		237
		238	$self->size_allocate ($self->{w}, $self->{h})
		239	if $self->{w}; #TODO: check for "realised state"
		240	}
140		241
141	sub remove {	242	sub remove {
142	my ($self, $chld) = @_;	243	my ($self, $widget) = @_;
143	delete $self->{child}	244
144	if $self->{child} == $chld;	245	$self->{children} = [ grep $_ != $widget, @{ $self->{children} } ];
		246
		247	$self->size_allocate ($self->{w}, $self->{h});
145	}	248	}
		249
		250	sub find_widget {
		251	my ($self, $x, $y) = @_;
		252
		253	$x -= $self->{x};
		254	$y -= $self->{y};
		255
		256	my $res;
		257
		258	for (reverse @{ $self->{children} }) {
		259	$res = $_->find_widget ($x, $y)
		260	and return $res;
		261	}
		262
		263	$self->SUPER::find_widget ($x + $self->{x}, $y + $self->{y})
		264	}
		265
		266	sub _draw {
		267	my ($self) = @_;
		268
		269	$_->draw for @{$self->{children}};
		270	}
		271
		272	#############################################################################
		273
		274	package CFClient::Widget::Bin;
		275
		276	our @ISA = CFClient::Widget::Container::;
		277
		278	sub child { $_[0]->{children}[0] }
146		279
147	sub size_request {	280	sub size_request {
148	$_[0]->{child}->size_request if $_[0]->{child}	281	$_[0]{children}[0]->size_request if $_[0]{children}[0];
		282	}
		283
		284	sub size_allocate {
		285	my ($self, $w, $h) = @_;
		286
		287	$self->SUPER::size_allocate ($w, $h);
		288	$self->{children}[0]->size_allocate ($w, $h)
		289	if $self->{children}[0]
		290	}
		291
		292	#############################################################################
		293
		294	package CFClient::Widget::Window;
		295
		296	our @ISA = CFClient::Widget::Bin::;
		297
		298	use SDL::OpenGL;
		299
		300	sub new {
		301	my ($class, $x, $y, $z, $w, $h) = @_;
		302
		303	my $self = $class->SUPER::new;
		304
		305	@$self{qw(x y z w h)} = ($x, $y, $z, $w, $h);
		306	}
		307
		308	sub update {
		309	my ($self) = @_;
		310
		311	# we want to do this delayed...
		312	$self->render_chld;
		313	$self->SUPER::update;
		314	}
		315
		316	sub render_chld {
		317	my ($self) = @_;
		318
		319	$self->{texture} =
		320	CFClient::Texture->new_from_opengl (
		321	$self->{w}, $self->{h}, sub { $self->child->draw }
		322	);
		323	}
		324
		325	sub size_allocate {
		326	my ($self, $w, $h) = @_;
		327
		328	$self->{w} = $w;
		329	$self->{h} = $h;
		330
		331	$self->child->size_allocate ($w, $h);
		332
		333	$self->render_chld;
149	}	334	}
150		335
151	sub _draw {	336	sub _draw {
152	my ($self) = @_;	337	my ($self) = @_;
153		338
154	$self->{child}->draw;	339	my ($w, $h) = ($self->w, $self->h);
155	}
156
157	package Crossfire::Client::Widget::Toplevel;
158
159	our @ISA = Crossfire::Client::Widget::;
160
161	use SDL::OpenGL;
162
163	sub add {
164	my ($self, $chld) = @_;
165
166	push @{$self->{childs}}, $chld;
167	@{$self->{childs}} =
168	sort { $a->{z} <=> $b->{z} }
169	@{$self->{childs}};
170
171	$chld->set_parent ($self);
172	}
173
174	sub remove {
175	my ($self, $chld) = @_;
176	@{$self->{childs}} =
177	sort { $a->{z} <=> $b->{z} }
178	grep { $_ && $_ != $_[0] }
179	@{$self->{childs}}
180	}
181
182	sub update {
183	my ($self) = @_;
184	::refresh ();
185	}
186
187	sub _draw {
188	my ($self) = @_;
189
190	$_->draw for @{$self->{childs}};
191	}
192
193	package Crossfire::Client::Widget::Window;
194
195	our @ISA = Crossfire::Client::Widget::Bin::;
196
197	use SDL::OpenGL;
198
199	sub add {
200	my ($self, $chld) = @_;
201	$self->SUPER::add ($chld);
202	$chld->set_parent ($self);
203	$self->update; #TODO: Move this to the size_request event propably?
204	}
205
206	sub remove {
207	my ($self) = @_;
208	# TODO FIXME: removing a child from a window will crash, see render_chld
209	$self->update;
210	}
211
212	sub update {
213	my ($self) = @_;
214	$self->render_chld;
215	}
216
217	sub render_chld {
218	my ($self) = @_;
219	my $chld = $self->get;
220	my ($w, $h) = $self->size_request;
221
222	$self->{texture} =
223	Crossfire::Client::Texture->new_from_opengl (
224	$w, $h, sub { $chld->draw }
225	);
226	$self->{texture}->upload;
227	}
228
229	sub size_request {
230	my ($self) = @_;
231	my $chld = $self->get
232	or return (0, 0);
233	$chld->size_request
234	}
235
236	sub _draw {
237	my ($self) = @_;
238
239	my ($w, $h) = $self->size_request;#TODO# use width/height of texture
240		340
241	my $tex = $self->{texture}	341	my $tex = $self->{texture}
242	or return;	342	or return;
243		343
244	glEnable GL_BLEND;	344	glEnable GL_BLEND;
245	glEnable GL_TEXTURE_2D;	345	glEnable GL_TEXTURE_2D;
246	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;	346	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
247	glBindTexture GL_TEXTURE_2D, $tex->{name};
248		347
249	glBegin GL_QUADS;	348	$tex->draw_quad (0, 0, $w, $h);
250	glTexCoord 0, 0; glVertex 0, 0;
251	glTexCoord 0, 1; glVertex 0, $h;
252	glTexCoord 1, 1; glVertex $w, $h;
253	glTexCoord 1, 0; glVertex $w, 0;
254	glEnd;
255		349
256	glDisable GL_BLEND;	350	glDisable GL_BLEND;
257	glDisable GL_TEXTURE_2D;	351	glDisable GL_TEXTURE_2D;
258	}	352	}
259		353
		354	#############################################################################
		355
260	package Crossfire::Client::Widget::Frame;	356	package CFClient::Widget::Frame;
261		357
262	our @ISA = Crossfire::Client::Widget::Bin::;	358	our @ISA = CFClient::Widget::Bin::;
263		359
264	use SDL::OpenGL;	360	use SDL::OpenGL;
265		361
266	sub size_request {	362	sub size_request {
267	my ($self) = @_;	363	my ($self) = @_;
268	my $chld = $self->get	364	my $chld = $self->child
269	or return (0, 0);	365	or return (0, 0);
270		366
271	$chld->move (2, 2);	367	$chld->move (2, 2);
272		368
273	map { $_ + 4 } $chld->size_request;	369	map { $_ + 4 } $chld->size_request;
274	}	370	}
275		371
		372	sub size_allocate {
		373	my ($self, $w, $h) = @_;
		374
		375	$self->{w} = $w;
		376	$self->{h} = $h;
		377
		378	$self->child->size_allocate ($w - 4, $h - 4);
		379	$self->child->move (2, 2);
		380	}
		381
276	sub _draw {	382	sub _draw {
277	my ($self) = @_;	383	my ($self) = @_;
278		384
279	my $chld = $self->get;	385	my $chld = $self->child;
280		386
281	my ($w, $h) = $chld->size_request;	387	my ($w, $h) = $chld->size_request;
282		388
283	glBegin GL_QUADS;	389	glBegin GL_QUADS;
284	glColor 0, 0, 0;	390	glColor 0, 0, 0;
285	glTexCoord 0, 0; glVertex 0 , 0;	391	glVertex 0 , 0;
286	glTexCoord 0, 1; glVertex 0 , $h + 4;	392	glVertex 0 , $h + 4;
287	glTexCoord 1, 1; glVertex $w + 4 , $h + 4;	393	glVertex $w + 4 , $h + 4;
288	glTexCoord 1, 0; glVertex $w + 4 , 0;	394	glVertex $w + 4 , 0;
289	glEnd;	395	glEnd;
290		396
291	$chld->draw;	397	$chld->draw;
292	}	398	}
293		399
		400	#############################################################################
		401
294	package Crossfire::Client::Widget::FancyFrame;	402	package CFClient::Widget::FancyFrame;
295		403
296	our @ISA = Crossfire::Client::Widget::Frame::;	404	our @ISA = CFClient::Widget::Bin::;
297		405
298	use SDL::OpenGL;	406	use SDL::OpenGL;
299		407
		408	my @tex =
		409	map { new_from_file CFClient::Texture CFClient::find_rcfile $_ }
		410	qw(d1_bg.png d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png);
		411
		412	sub size_request {
		413	my ($self) = @_;
		414
		415	my ($w, $h) = $self->SUPER::size_request;
		416
		417	$h += $tex[1]->{height};
		418	$h += $tex[4]->{height};
		419	$w += $tex[2]->{width};
		420	$w += $tex[3]->{width};
		421
		422	($w, $h)
		423	}
		424
		425	sub size_allocate {
		426	my ($self, $w, $h) = @_;
		427
		428	$self->SUPER::size_allocate ($w, $h);
		429
		430	$h -= $tex[1]->{height};
		431	$h -= $tex[4]->{height};
		432	$w -= $tex[2]->{width};
		433	$w -= $tex[3]->{width};
		434
		435	$h = $h < 0 ? 0 : $h;
		436	$w = $w < 0 ? 0 : $w;
		437
		438	$self->child->size_allocate ($w, $h);
		439	$self->child->move ($tex[3]->{width}, $tex[1]->{height});
		440	}
		441
		442	sub _draw {
		443	my ($self) = @_;
		444
		445	my ($w, $h) = ($self->{w}, $self->{h});
		446	my ($cw, $ch) = ($self->child->{w}, $self->child->{h});
		447
		448	glEnable GL_BLEND;
		449	glEnable GL_TEXTURE_2D;
		450	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
		451	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
		452
		453	my $top = $tex[1];
		454	$top->draw_quad (0, 0, $w, $top->{height});
		455
		456	my $left = $tex[3];
		457	$left->draw_quad (0, $top->{height}, $left->{width}, $ch);
		458
		459	my $right = $tex[2];
		460	$right->draw_quad ($w - $right->{width}, $top->{height}, $right->{width}, $ch);
		461
		462	my $bottom = $tex[4];
		463	$bottom->draw_quad (0, $h - $bottom->{height}, $w, $bottom->{height});
		464
		465	my $bg = $tex[0];
		466	glBindTexture GL_TEXTURE_2D, $bg->{name};
		467	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
		468	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT;
		469	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT;
		470
		471	my $rep_x = $cw / $bg->{width};
		472	my $rep_y = $ch / $bg->{height};
		473
		474	$bg->draw_quad ($left->{width}, $top->{height}, $cw, $ch);
		475
		476	glDisable GL_BLEND;
		477	glDisable GL_TEXTURE_2D;
		478
		479	$self->child->draw;
		480
		481	}
		482
		483	#############################################################################
		484
		485	package CFClient::Widget::Table;
		486
		487	our @ISA = CFClient::Widget::Bin::;
		488
		489	use SDL::OpenGL;
		490
		491	sub add {
		492	my ($self, $x, $y, $chld) = @_;
		493	my $old_chld = $self->{children}[$y][$x];
		494
		495	$self->{children}[$y][$x] = $chld;
		496	$chld->set_parent ($self);
		497	$self->update;
		498	}
		499
		500	sub max_row_height {
		501	my ($self, $row) = @_;
		502
		503	my $hs = 0;
		504	for (my $xi = 0; $xi <= $#{$self->{children}->[$row] || []}; $xi++) {
		505	my $c = $self->{children}->[$row]->[$xi];
		506	if ($c) {
		507	my ($w, $h) = $c->size_request;
		508	if ($hs < $h) { $hs = $h }
		509	}
		510	}
		511	return $hs;
		512	}
		513
		514	sub max_col_width {
		515	my ($self, $col) = @_;
		516
		517	my $ws = 0;
		518	for (my $yi = 0; $yi <= $#{$self->{children} || []}; $yi++) {
		519	my $c = ($self->{children}->[$yi] || [])->[$col];
		520	if ($c) {
		521	my ($w, $h) = $c->size_request;
		522	if ($ws < $w) { $ws = $w }
		523	}
		524	}
		525	return $ws;
		526	}
		527
		528	sub size_request {
		529	my ($self) = @_;
		530
		531	my ($hs, $ws) = (0, 0);
		532
		533	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
		534	$hs += $self->max_row_height ($yi);
		535	}
		536
		537	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
		538	my $wm = 0;
		539	for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {
		540	$wm += $self->max_col_width ($xi)
		541	}
		542	if ($ws < $wm) { $ws = $wm }
		543	}
		544
		545	return ($ws, $hs);
		546	}
		547
		548	sub _draw {
		549	my ($self) = @_;
		550
		551	my $y = 0;
		552	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
		553	my $x = 0;
		554
		555	for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {
		556
		557	my $c = $self->{children}->[$yi]->[$xi];
		558	if ($c) {
		559	$c->move ($x, $y, 0); #TODO: Move to size_request
		560	$c->draw if $c;
		561	}
		562
		563	$x += $self->max_col_width ($xi);
		564	}
		565
		566	$y += $self->max_row_height ($yi);
		567	}
		568	}
		569
		570	#############################################################################
		571
		572	package CFClient::Widget::VBox;
		573
		574	our @ISA = CFClient::Widget::Container::;
		575
		576	use SDL::OpenGL;
		577
		578	sub size_request {
		579	my ($self) = @_;
		580
		581	my @alloc = map [$_->size_request], @{$self->{children}};
		582
		583	(
		584	(List::Util::max map $_->[0], @alloc),
		585	(List::Util::sum map $_->[1], @alloc),
		586	)
		587	}
		588
		589	sub size_allocate {
		590	my ($self, $w, $h) = @_;
		591
		592	$self->w ($w);
		593	$self->h ($h);
		594
		595	my $exp;
		596	my @oth;
		597	# find expand widget
		598	for (@{$self->{children}}) {
		599	if ($_->{expand}) {
		600	$exp = $_;
		601	last;
		602	}
		603	push @oth, $_;
		604	}
		605
		606	my ($ow, $oh);
		607
		608	# get sizes of other widgets
		609	for (@oth) {
		610	my ($w, $h) = $_->size_request;
		611	$oh += $h;
		612	if ($ow < $w) { $ow = $w }
		613	}
		614
		615	my $y = 0;
		616	for (@{$self->{children}}) {
		617	$_->move (0, $y);
		618
		619	if ($_ == $exp) {
		620	$_->size_allocate ($w, $h - $oh);
		621	$y += $h - $oh;
		622	} else {
		623	my ($cw, $h) = $_->size_request;
		624	$_->size_allocate ($w, $h);
		625	$y += $h;
		626	}
		627	}
		628	}
		629
		630	#############################################################################
		631
		632	package CFClient::Widget::Label;
		633
		634	our @ISA = CFClient::Widget::;
		635
		636	use SDL::OpenGL;
		637
300	sub new {	638	sub new {
301	my ($self, $theme) = @_;	639	my ($class, $x, $y, $z, $height, $text) = @_;
		640
		641	$height ||= $::FONTSIZE;
		642
		643	# TODO: color, and make height, xyz etc. optional
302	$self = $self->SUPER::new;	644	my $self = $class->SUPER::new (
303		645	color => [1, 1, 1],
304	$self->{txts} = [	646	x => $x,
305	map { new_from_file Crossfire::Client::Texture Crossfire::Client::find_rcfile $_ }	647	y => $y,
306	qw/d1_bg.png d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png/	648	z => $z,
		649	height => $height,
		650	layout => new CFClient::Layout $height,
307	];	651	);
		652
		653	$self->set_text ($text);
		654
308	$self	655	$self
		656	}
309		657
		658	sub set_text {
		659	my ($self, $text) = @_;
		660
		661	$self->{text} = $text;
		662	$self->{layout}->set_markup ($text);
		663
		664	delete $self->{texture};
		665	}
		666
		667	sub get_text {
		668	my ($self, $text) = @_;
		669
		670	$self->{text}
310	}	671	}
311		672
312	sub size_request {	673	sub size_request {
313	my ($self) = @_;	674	my ($self) = @_;
314	my ($w, $h) = $self->get->size_request;
315		675
316	$h += $self->{txts}->[1]->{height};	676	$self->{layout}->set_width;
317	$h += $self->{txts}->[4]->{height};	677	$self->{layout}->size
318	$w += $self->{txts}->[2]->{width};	678	# if ($self->{texture}{width} > 1 && $self->{texture}{height} > 1) { #TODO: hack
319	$w += $self->{txts}->[3]->{width};	679	# (
320		680	# $self->{texture}{width},
321	$self->get->move ($self->{txts}->[3]->{width}, $self->{txts}->[1]->{height});	681	# $self->{texture}{height},
322		682	# )
		683	# } else {
		684	# my ($w, $h, $data) = CFClient::font_render "Yy", $self->{height};
		685	#
323	($w, $h)	686	# ($w, $h)
		687	# }
		688	}
		689
		690	sub size_allocate {
		691	my ($self, $w, $h) = @_;
		692
		693	$self->SUPER::size_allocate ($w, $h);
		694	delete $self->{texture};
324	}	695	}
325		696
326	sub _draw {	697	sub _draw {
327	my ($self) = @_;	698	my ($self) = @_;
328		699
329	my ($w, $h) = $self->size_request;	700	my $tex = $self->{texture} ||= do {
330	my ($cw, $ch) = $self->get->size_request;	701	$self->{layout}->set_width ($self->{w});
		702	new_from_layout CFClient::Texture $self->{layout};
		703	};
331		704
332	glEnable GL_BLEND;	705	glEnable GL_BLEND;
333	glEnable GL_TEXTURE_2D;	706	glEnable GL_TEXTURE_2D;
334	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;	707	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
335	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;	708	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
336		709
		710	glColor @{$self->{color}};
337		711
338	my $top = $self->{txts}->[1];	712	$tex->draw_quad (0, 0);
339	glBindTexture GL_TEXTURE_2D, $top->{name};
340
341	glColor 1, 1, 1, 0.8;
342
343	glBegin GL_QUADS;
344	glTexCoord 0, 0; glVertex 0 , 0;
345	glTexCoord 0, 1; glVertex 0 , $top->{height};
346	glTexCoord 1, 1; glVertex $w , $top->{height};
347	glTexCoord 1, 0; glVertex $w , 0;
348	glEnd;
349
350	my $left = $self->{txts}->[3];
351	glBindTexture GL_TEXTURE_2D, $left->{name};
352
353	glColor 1, 1, 1, 0.8;
354
355	glBegin GL_QUADS;
356	glTexCoord 0, 0; glVertex 0 , $top->{height};
357	glTexCoord 0, 1; glVertex 0 , $top->{height} + $ch;
358	glTexCoord 1, 1; glVertex $left->{width}, $top->{height} + $ch;
359	glTexCoord 1, 0; glVertex $left->{width}, $top->{height};
360	glEnd;
361
362	my $right = $self->{txts}->[2];
363	glBindTexture GL_TEXTURE_2D, $right->{name};
364
365	glColor 1, 1, 1, 0.8;
366
367	glBegin GL_QUADS;
368	glTexCoord 0, 0; glVertex $w - $right->{width}, $top->{height};
369	glTexCoord 0, 1; glVertex $w - $right->{width}, $top->{height} + $ch;
370	glTexCoord 1, 1; glVertex $w , $top->{height} + $ch;
371	glTexCoord 1, 0; glVertex $w , $top->{height};
372	glEnd;
373
374	my $bottom = $self->{txts}->[4];
375	glBindTexture GL_TEXTURE_2D, $bottom->{name};
376
377	glColor 1, 1, 1, 0.8;
378
379	glBegin GL_QUADS;
380	glTexCoord 0, 0; glVertex 0 , $h - $bottom->{height};
381	glTexCoord 0, 1; glVertex 0 , $h;
382	glTexCoord 1, 1; glVertex $w , $h;
383	glTexCoord 1, 0; glVertex $w , $h - $bottom->{height};
384	glEnd;
385
386	my $bg = $self->{txts}->[0];
387	glBindTexture GL_TEXTURE_2D, $bg->{name};
388	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT;
389	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT;
390
391	glColor 1, 1, 1, 0.8;
392
393	my $rep_x = $cw / $bg->{width};
394	my $rep_y = $ch / $bg->{height};
395
396	glBegin GL_QUADS;
397	glTexCoord 0, 0; glVertex $left->{width}, $top->{height};
398	glTexCoord 0, $rep_y; glVertex $left->{width}, $top->{height} + $ch;
399	glTexCoord $rep_x, $rep_y; glVertex $left->{width} + $cw , $top->{height} + $ch;
400	glTexCoord $rep_x, 0; glVertex $left->{width} + $cw , $top->{height};
401	glEnd;
402
403	$self->get->draw;
404		713
405	glDisable GL_BLEND;	714	glDisable GL_BLEND;
406	glDisable GL_TEXTURE_2D;	715	glDisable GL_TEXTURE_2D;
407	}	716	}
408		717
409	package Crossfire::Client::Widget::Table;	718	#############################################################################
410		719
411	our @ISA = Crossfire::Client::Widget::Bin::;
412
413	use SDL::OpenGL;
414
415	sub add {
416	my ($self, $x, $y, $chld) = @_;
417	my $old_chld = $self->{childs}[$y][$x];
418
419	$self->{childs}[$y][$x] = $chld;
420	$chld->set_parent ($self);
421	$self->update;
422	}
423
424	sub max_row_height {
425	my ($self, $row) = @_;
426
427	my $hs = 0;
428	for (my $xi = 0; $xi <= $#{$self->{childs}->[$row] || []}; $xi++) {
429	my $c = $self->{childs}->[$row]->[$xi];
430	if ($c) {
431	my ($w, $h) = $c->size_request;
432	if ($hs < $h) { $hs = $h }
433	}
434	}
435	return $hs;
436	}
437
438	sub max_col_width {
439	my ($self, $col) = @_;
440
441	my $ws = 0;
442	for (my $yi = 0; $yi <= $#{$self->{childs} || []}; $yi++) {
443	my $c = ($self->{childs}->[$yi] || [])->[$col];
444	if ($c) {
445	my ($w, $h) = $c->size_request;
446	if ($ws < $w) { $ws = $w }
447	}
448	}
449	return $ws;
450	}
451
452	sub size_request {
453	my ($self) = @_;
454
455	my ($hs, $ws) = (0, 0);
456
457	for (my $yi = 0; $yi <= $#{$self->{childs}}; $yi++) {
458	$hs += $self->max_row_height ($yi);
459	}
460
461	for (my $yi = 0; $yi <= $#{$self->{childs}}; $yi++) {
462	my $wm = 0;
463	for (my $xi = 0; $xi <= $#{$self->{childs}->[$yi]}; $xi++) {
464	$wm += $self->max_col_width ($xi)
465	}
466	if ($ws < $wm) { $ws = $wm }
467	}
468
469	return ($ws, $hs);
470	}
471
472	sub _draw {
473	my ($self) = @_;
474
475	my $y = 0;
476	for (my $yi = 0; $yi <= $#{$self->{childs}}; $yi++) {
477	my $x = 0;
478
479	for (my $xi = 0; $xi <= $#{$self->{childs}->[$yi]}; $xi++) {
480
481	my $c = $self->{childs}->[$yi]->[$xi];
482	if ($c) {
483	$c->move ($x, $y, 0); #TODO: Move to size_request
484	$c->draw if $c;
485	}
486
487	$x += $self->max_col_width ($xi);
488	}
489
490	$y += $self->max_row_height ($yi);
491	}
492	}
493
494	package Crossfire::Client::Widget::VBox;
495
496	our @ISA = Crossfire::Client::Widget::Bin::;
497
498	use SDL::OpenGL;
499
500	sub add {
501	my ($self, $chld) = @_;
502	push @{$self->{childs}}, $chld;
503	$chld->set_parent ($self);
504	$self->update;
505	}
506
507	sub size_request {
508	my ($self) = @_;
509
510	my ($hs, $ws) = (0, 0);
511	for (@{$self->{childs} || []}) {
512	my ($w, $h) = $_->size_request;
513	$hs += $h;
514	if ($ws < $w) { $ws = $w }
515	}
516
517	return ($ws, $hs);
518	}
519
520	sub _draw {
521	my ($self) = @_;
522
523	my ($x, $y);
524	for (@{$self->{childs} || []}) {
525	$_->move (0, $y, 0); #TODO: move to size_request
526	$_->draw;
527	my ($w, $h) = $_->size_request;
528	$y += $h;
529	}
530	}
531
532	package Crossfire::Client::Widget::Label;
533
534	our @ISA = Crossfire::Client::Widget::;
535
536	use SDL::OpenGL;
537
538	sub new {
539	my ($class, $x, $y, $z, $height, $text) = @_;
540
541	# TODO: color, and make height, xyz etc. optional
542	my $self = $class->SUPER::new (x => $x, y => $y, z => $z, height => $height);
543
544	$self->set_text ($text);
545
546	$self
547	}
548
549	sub set_text {
550	my ($self, $text) = @_;
551
552	$self->{text} = $text;
553	$self->{texture} = new_from_text Crossfire::Client::Texture $text, $self->{height};
554
555	$self->update;
556	}
557
558	sub get_text {
559	my ($self, $text) = @_;
560
561	$self->{text}
562	}
563
564	sub size_request {
565	my ($self) = @_;
566
567	(
568	$self->{texture}{width},
569	$self->{texture}{height},
570	)
571	}
572
573	sub _draw {
574	my ($self) = @_;
575
576	my $tex = $self->{texture};
577
578	glEnable GL_BLEND;
579	glEnable GL_TEXTURE_2D;
580	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
581	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
582	glBindTexture GL_TEXTURE_2D, $tex->{name};
583
584	glColor 1, 1, 1, 0.6; # TODO color
585
586	glBegin GL_QUADS;
587	glTexCoord 0, 0; glVertex 0 , 0;
588	glTexCoord 0, 1; glVertex 0 , $tex->{height};
589	glTexCoord 1, 1; glVertex $tex->{width}, $tex->{height};
590	glTexCoord 1, 0; glVertex $tex->{width}, 0;
591	glEnd;
592
593	glDisable GL_BLEND;
594	glDisable GL_TEXTURE_2D;
595	}
596
597	package Crossfire::Client::Widget::TextEntry;	720	package CFClient::Widget::Entry;
598		721
599	our @ISA = Crossfire::Client::Widget::Label::;	722	our @ISA = CFClient::Widget::Label::;
600		723
601	use SDL;	724	use SDL;
602	use SDL::OpenGL;	725	use SDL::OpenGL;
603		726
604	sub key_down {	727	sub key_down {
605	my ($self, $ev) = @_;	728	my ($self, $ev) = @_;
606		729
607	my $mod = $ev->key_mod;	730	my $mod = $ev->key_mod;
608	my $sym = $ev->key_sym;	731	my $sym = $ev->key_sym;
609		732
610	$ev->set_unicode (1);
611	my $uni = $ev->key_unicode;	733	my $uni = $ev->key_unicode;
612		734
613	my $text = $self->get_text;	735	my $text = $self->get_text;
614		736
615	if ($sym == SDLK_BACKSPACE) {	737	if ($sym == SDLK_BACKSPACE) {
616	substr $text, -1, 1, '';	738	substr $text, -1, 1, '';
617
618	} elsif ($uni) {	739	} elsif ($uni) {
619	$text .= chr $uni;	740	$text .= chr $uni;
620	}	741	}
		742
621	$self->set_text ($text);	743	$self->set_text ($text);
622	}	744	}
623		745
		746	sub button_down {
		747	my ($self, $ev) = @_;
624		748
625	# XXX: TextView isn't neccessary with pango multiline text rendering	749	$self->focus_in;
626	package Crossfire::Client::Widget::TextView;	750	}
627		751
628	use strict;	752	sub mouse_motion {
629
630	our @ISA = qw/Crossfire::Client::Widget/;
631
632	use SDL::OpenGL;
633	use SDL::OpenGL::Constants;
634
635	sub new {
636	my ($class, $text, $h) = @_;	753	my ($self, $ev, $x, $y) = @_;
637	my $self = $class->SUPER::new ();	754	printf "M %d,%d %d,%d\n", $ev->motion_x, $ev->motion_y, $x, $y;#d#
638
639	$self->{txt_height} = $h;
640	@{$self->{lines}} = split /\r?\n/, $text;
641
642	for (split /\r?\n/, $text) {
643	$self->add_line ($_);
644	}
645	$self
646	}	755	}
647		756
648	#sub render_lines {	757	sub _draw {
649	# my ($self) = @_;	758	my ($self) = @_;
650	#	759
651	# $self->{txt_lines} = [];	760	if ($FOCUS == $self) {
652	#	761	glColor 1, 1, 1;
653	# for (@{$self->{lines}}) {	762	} else {
654	# push @{$self->{txt_lines}},	763	glColor 0.7, 0.7, 0.7;
655	# new_from_ttf Crossfire::Client::Texture $self->{ttf}, $_;
656	# }	764	}
657	#}
658
659	sub add_line {
660	my ($self, $line) = @_;
661	push @{$self->{lines}}, $line;
662
663	push @{$self->{txt_lines}},
664	new_from_text Crossfire::Client::Texture $line, $self->{txt_height};
665	}
666
667	sub size_request {
668	my ($self) = @_;
669
670	my $w = 0;
671	my $h = 0;
672
673	for (@{$self->{txt_lines}}) {
674	if ($w < $_->{width}) { $w = $_->{width} }
675	$h += $_->{height};
676	}
677
678	return ($w, $h);
679	}
680
681	sub draw_line {
682	my ($self, $tex, $y) = @_;
683
684	glBindTexture GL_TEXTURE_2D, $tex->{name};
685
686	glColor 1, 0, 1;
687		765
688	glBegin GL_QUADS;	766	glBegin GL_QUADS;
689	glTexCoord 0, 0; glVertex 0 , $y;	767	glVertex 0 , 0;
690	glTexCoord 0, 1; glVertex 0 , $y + $tex->{height};	768	glVertex 0 , $self->{h} - 1;
691	glTexCoord 1, 1; glVertex $tex->{width}, $y + $tex->{height};	769	glVertex $self->{w} - 1, $self->{h} - 1;
692	glTexCoord 1, 0; glVertex $tex->{width}, $y;	770	glVertex $self->{w} - 1, 0;
693	glEnd;	771	glEnd;
694	}
695		772
696	sub _draw {	773	$self->SUPER::_draw;
697	my ($self) = @_;
698
699	glEnable GL_BLEND;
700	glEnable GL_TEXTURE_2D;
701	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;#DECAL;
702
703	my $l = 0;
704	for (@{$self->{txt_lines}}) {
705	$self->draw_line ($_, $l);
706	$l += $_->{height};
707	}
708
709	glDisable GL_BLEND;
710	glDisable GL_TEXTURE_2D;
711	}	774	}
712		775
		776	#############################################################################
		777
713	package Crossfire::Client::Widget::MapWidget;	778	package CFClient::Widget::MapWidget;
714		779
715	use strict;	780	use strict;
716		781
717	use List::Util qw(min max);	782	use List::Util qw(min max);
718		783
719	use SDL;	784	use SDL;
720	use SDL::OpenGL;	785	use SDL::OpenGL;
721	use SDL::OpenGL::Constants;	786	use SDL::OpenGL::Constants;
722		787
723	our @ISA = Crossfire::Client::Widget::;	788	our @ISA = CFClient::Widget::;
724		789
725	sub key_down {	790	sub key_down {
726	print "MAPKEYDOWN\n";	791	print "MAPKEYDOWN\n";
727	}	792	}
728		793
729	sub key_up {	794	sub key_up {
		795	}
		796
		797	sub size_request {
		798	(
		799	1 + int $::WIDTH / 32,
		800	1 + int $::HEIGHT / 32,
		801	)
730	}	802	}
731		803
732	sub _draw {	804	sub _draw {
733	my ($self) = @_;	805	my ($self) = @_;
734		806
…		…
757	glEnable GL_TEXTURE_2D;	829	glEnable GL_TEXTURE_2D;
758	glEnable GL_BLEND;	830	glEnable GL_BLEND;
759	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;	831	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
760		832
761	my $sw4 = ($sw + 3) & ~3;	833	my $sw4 = ($sw + 3) & ~3;
762	my $lighting = "\x00" x ($sw4 * $sh);	834	my $darkness = "\x00" x ($sw4 * $sh);
763		835
764	for my $x (0 .. $sw - 1) {	836	for my $x (0 .. $sw - 1) {
		837	my $row = $map->[$x + $xofs];
765	for my $y (0 .. $sh - 1) {	838	for my $y (0 .. $sh - 1) {
766		839
767	my $cell = $map->[$x + $xofs][$y + $yofs]	840	my $cell = $row->[$y + $yofs]
768	or next;	841	or next;
769		842
770	my $darkness = $cell->[0] * (1 / 255);	843	my $dark = $cell->[0];
771	if ($darkness < 0) {	844	if ($dark < 0) {
772	$darkness = 0.15;	845	substr $darkness, $y * $sw4 + $x, 1, chr 224;
		846	} else {
		847	substr $darkness, $y * $sw4 + $x, 1, chr 255 - $dark;
773	}	848	}
774	substr $lighting, $y * $sw4 + $x, 1, chr 255 - $darkness * 255;
775		849
776	for my $num (grep $_, @$cell[1,2,3]) {	850	for my $num (grep $_, @$cell[1,2,3]) {
777	my $tex = $::CONN->{face}[$num]{texture} || next;	851	my $tex = $::CONN->{face}[$num]{texture} || next;
778		852
779	glBindTexture GL_TEXTURE_2D, $tex->{name};
780
781	my $w = $tex->{width};	853	my $w = $tex->{width};
782	my $h = $tex->{height};	854	my $h = $tex->{height};
783		855
784	my $px = ($x + 1) * 32 - $w;	856	$tex->draw_quad (($x + 1) * 32 - $w, ($y + 1) * 32 - $h, $w, $h);
785	my $py = ($y + 1) * 32 - $h;
786
787	glBegin GL_QUADS;
788	glTexCoord 0, 0; glVertex $px , $py;
789	glTexCoord 0, 1; glVertex $px , $py + $h;
790	glTexCoord 1, 1; glVertex $px + $w, $py + $h;
791	glTexCoord 1, 0; glVertex $px + $w, $py;
792	glEnd;
793	}	857	}
794	}	858	}
795	}	859	}
796		860
797	# if (1) { # higher quality darkness	861	# if (1) { # higher quality darkness
…		…
802	#	866	#
803	# $lighting = $pb->get_pixels;	867	# $lighting = $pb->get_pixels;
804	# $lighting =~ s/(.)../$1/gs;	868	# $lighting =~ s/(.)../$1/gs;
805	# }	869	# }
806		870
807	$lighting = new Crossfire::Client::Texture	871	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
		872	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
		873
		874	$darkness = new CFClient::Texture
808	width => $sw4,	875	width => $sw4,
809	height => $sh,	876	height => $sh,
810	data => $lighting,	877	data => $darkness,
811	internalformat => GL_ALPHA4,	878	internalformat => GL_ALPHA,
812	format => GL_ALPHA;	879	format => GL_ALPHA;
813		880
814	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;	881	glColor 0.45, 0.45, 0.45, 1;
815	glColor 0, 0, 0, 0.75;	882	$darkness->draw_quad (0, 0, $sw4 * 32, $sh * 32);
816	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
817	glBindTexture GL_TEXTURE_2D, $lighting->{name};
818	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR;
819	glBegin GL_QUADS;
820	glTexCoord 0, 0; glVertex 0 , 0;
821	glTexCoord 0, 1; glVertex 0 , $sh * 32;
822	glTexCoord 1, 1; glVertex $sw4 * 32, $sh * 32;
823	glTexCoord 1, 0; glVertex $sw4 * 32, 0;
824	glEnd;
825		883
826	glDisable GL_TEXTURE_2D;	884	glDisable GL_TEXTURE_2D;
827	glDisable GL_BLEND;	885	glDisable GL_BLEND;
828	}	886	}
829		887
…		…
876	if (!($mod & KMOD_CTRL ) && delete $self->{ctrl}) {	934	if (!($mod & KMOD_CTRL ) && delete $self->{ctrl}) {
877	$::CONN->send ("command run_stop");	935	$::CONN->send ("command run_stop");
878	}	936	}
879	}	937	}
880		938
		939	#############################################################################
		940
881	package Crossfire::Client::Widget::Animator;	941	package CFClient::Widget::Animator;
882		942
883	use SDL::OpenGL;	943	use SDL::OpenGL;
884		944
885	our @ISA = Crossfire::Client::Widget::Bin::;	945	our @ISA = CFClient::Widget::Bin::;
886		946
887	sub moveto {	947	sub moveto {
888	my ($self, $x, $y) = @_;	948	my ($self, $x, $y) = @_;
889		949
890	$self->{moveto} = [$self->{x}, $self->{y}, $x, $y];	950	$self->{moveto} = [$self->{x}, $self->{y}, $x, $y];
891	$self->{speed} = 0.01;	951	$self->{speed} = 0.001;
892	$self->{time} = 1;	952	$self->{time} = 1;
893		953
894	::animation_start $self;	954	::animation_start $self;
895	}	955	}
896		956
…		…
911		971
912	sub _draw {	972	sub _draw {
913	my ($self) = @_;	973	my ($self) = @_;
914		974
915	glPushMatrix;	975	glPushMatrix;
916	glRotate $self->{time} * 10000, 0, 1, 0;	976	glRotate $self->{time} * 1000, 0, 1, 0;
917	$self->{child}->draw;	977	$self->{children}[0]->draw;
918	glPopMatrix;	978	glPopMatrix;
919	}	979	}
920		980
921	1;	981	#############################################################################
922		982
		983	package CFClient::Widget::Toplevel;
		984
		985	our @ISA = CFClient::Widget::Container::;
		986
		987	sub size_request {
		988	($::WIDTH, $::HEIGHT)
		989	}
		990
		991	sub size_allocate {
		992	my ($self, $w, $h) = @_;
		993
		994	$self->SUPER::size_allocate ($w, $h);
		995
		996	$_->size_allocate ($_->size_request)
		997	for @{$self->{children}};
		998	}
		999
		1000	sub translate {
		1001	my ($self, $x, $y) = @_;
		1002
		1003	($x, $y)
		1004	}
		1005
		1006	sub update {
		1007	my ($self) = @_;
		1008
		1009	$self->size_allocate ($self->size_request);
		1010	::refresh ();
		1011	}
		1012
		1013	sub add {
		1014	my ($self, $widget) = @_;
		1015
		1016	$self->SUPER::add ($widget);
		1017
		1018	$widget->size_allocate ($widget->size_request);
		1019	}
		1020
		1021	sub draw {
		1022	my ($self) = @_;
		1023
		1024	$self->_draw;
		1025	}
		1026
		1027	#############################################################################
		1028
		1029	package CFClient::Widget;
		1030
		1031	$TOPLEVEL = new CFClient::Widget::Toplevel;
		1032
		1033	1
		1034

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines