ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/Deliantra-Client/DC/UI.pm
(Generate patch)

Comparing deliantra/Deliantra-Client/DC/UI.pm (file contents):
Revision 1.78 by root, Tue Apr 11 22:49:13 2006 UTC vs.
Revision 1.310 by root, Fri Jun 23 20:28:20 2006 UTC

1package CFClient::UI; 1package CFClient::UI;
2 2
3use utf8;
3use strict; 4use strict;
4 5
5use Scalar::Util (); 6use Scalar::Util ();
6use List::Util (); 7use List::Util ();
8use Event;
7 9
8use CFClient; 10use CFClient;
11use CFClient::Texture;
9 12
10our ($FOCUS, $HOVER, $GRAB); # various widgets 13our ($FOCUS, $HOVER, $GRAB); # various widgets
11 14
12our $TOPLEVEL; 15our $LAYOUT;
16our $ROOT;
17our $TOOLTIP;
13our $BUTTON_STATE; 18our $BUTTON_STATE;
19
20our %WIDGET; # all widgets, weak-referenced
21
22our $TOOLTIP_WATCHER = Event->idle (min => 1/60, cb => sub {
23 if (!$GRAB) {
24 for (my $widget = $HOVER; $widget; $widget = $widget->{parent}) {
25 if (length $widget->{tooltip}) {
26 if ($TOOLTIP->{owner} != $widget) {
27 $TOOLTIP->hide;
28
29 $TOOLTIP->{owner} = $widget;
30
31 return if $ENV{CFPLUS_DEBUG} & 8;
32
33 my $tip = $widget->{tooltip};
34
35 $tip = $tip->($widget) if CODE:: eq ref $tip;
36
37 $TOOLTIP->set_tooltip_from ($widget);
38 $TOOLTIP->show;
39 }
40
41 return;
42 }
43 }
44 }
45
46 $TOOLTIP->hide;
47 delete $TOOLTIP->{owner};
48});
49
50sub get_layout {
51 my $layout;
52
53 for (grep { $_->{name} } values %WIDGET) {
54 my $win = $layout->{$_->{name}} = { };
55
56 $win->{x} = ($_->{x} + $_->{w} * 0.5) / $::WIDTH if $_->{x} =~ /^[0-9.]+$/;
57 $win->{y} = ($_->{y} + $_->{h} * 0.5) / $::HEIGHT if $_->{y} =~ /^[0-9.]+$/;
58 $win->{w} = $_->{w} / $::WIDTH if defined $_->{w};
59 $win->{h} = $_->{h} / $::HEIGHT if defined $_->{h};
60
61 $win->{show} = $_->{visible} && $_->{is_toplevel};
62 }
63
64 $layout
65}
66
67sub set_layout {
68 my ($layout) = @_;
69
70 $LAYOUT = $layout;
71}
14 72
15# class methods for events 73# class methods for events
16sub feed_sdl_key_down_event { 74sub feed_sdl_key_down_event {
17 $FOCUS->key_down ($_[0]) if $FOCUS; 75 $FOCUS->emit (key_down => $_[0])
76 if $FOCUS;
18} 77}
19 78
20sub feed_sdl_key_up_event { 79sub feed_sdl_key_up_event {
21 $FOCUS->key_up ($_[0]) if $FOCUS; 80 $FOCUS->emit (key_up => $_[0])
81 if $FOCUS;
22} 82}
23 83
24sub feed_sdl_button_down_event { 84sub feed_sdl_button_down_event {
25 my ($ev) = @_; 85 my ($ev) = @_;
26 my ($x, $y) = ($ev->motion_x, $ev->motion_y); 86 my ($x, $y) = ($ev->{x}, $ev->{y});
27 87
28 if (!$BUTTON_STATE) { 88 if (!$BUTTON_STATE) {
29 my $widget = $TOPLEVEL->find_widget ($x, $y); 89 my $widget = $ROOT->find_widget ($x, $y);
30 90
31 $GRAB = $widget; 91 $GRAB = $widget;
32 $GRAB->update if $GRAB; 92 $GRAB->update if $GRAB;
33 }
34 93
94 $TOOLTIP_WATCHER->cb->();
95 }
96
35 $BUTTON_STATE |= 1 << ($ev->button - 1); 97 $BUTTON_STATE |= 1 << ($ev->{button} - 1);
36 98
37 $GRAB->button_down ($ev, $GRAB->translate ($x, $y)) if $GRAB; 99 $GRAB->emit (button_down => $ev, $GRAB->coord2local ($x, $y))
100 if $GRAB;
38} 101}
39 102
40sub feed_sdl_button_up_event { 103sub feed_sdl_button_up_event {
41 my ($ev) = @_; 104 my ($ev) = @_;
42 my ($x, $y) = ($ev->motion_x, $ev->motion_y); 105 my ($x, $y) = ($ev->{x}, $ev->{y});
43 106
44 my $widget = $GRAB || $TOPLEVEL->find_widget ($x, $y); 107 my $widget = $GRAB || $ROOT->find_widget ($x, $y);
45 108
46 $BUTTON_STATE &= ~(1 << ($ev->button - 1)); 109 $BUTTON_STATE &= ~(1 << ($ev->{button} - 1));
47 110
48 $GRAB->button_up ($ev, $GRAB->translate ($x, $y)) if $GRAB; 111 $GRAB->emit (button_up => $ev, $GRAB->coord2local ($x, $y))
112 if $GRAB;
49 113
50 if (!$BUTTON_STATE) { 114 if (!$BUTTON_STATE) {
51 my $grab = $GRAB; undef $GRAB; 115 my $grab = $GRAB; undef $GRAB;
52 $grab->update if $grab; 116 $grab->update if $grab;
53 $GRAB->update if $GRAB; 117 $GRAB->update if $GRAB;
118
119 $TOOLTIP_WATCHER->cb->();
54 } 120 }
55} 121}
56 122
57sub feed_sdl_motion_event { 123sub feed_sdl_motion_event {
58 my ($ev) = @_; 124 my ($ev) = @_;
59 my ($x, $y) = ($ev->motion_x, $ev->motion_y); 125 my ($x, $y) = ($ev->{x}, $ev->{y});
60 126
61 my $widget = $GRAB || $TOPLEVEL->find_widget ($x, $y); 127 my $widget = $GRAB || $ROOT->find_widget ($x, $y);
62 128
63 if ($widget != $HOVER) { 129 if ($widget != $HOVER) {
64 my $hover = $HOVER; $HOVER = $widget; 130 my $hover = $HOVER; $HOVER = $widget;
65 131
66 $hover->update if $hover; 132 $hover->update if $hover && $hover->{can_hover};
67 $HOVER->update if $HOVER; 133 $HOVER->update if $HOVER && $HOVER->{can_hover};
68 }
69 134
70 $HOVER->mouse_motion ($ev, $HOVER->translate ($x, $y)) if $HOVER; 135 $TOOLTIP_WATCHER->start;
136 }
137
138 $HOVER->emit (mouse_motion => $ev, $HOVER->coord2local ($x, $y))
139 if $HOVER;
140}
141
142# convert position array to integers
143sub harmonize {
144 my ($vals) = @_;
145
146 my $rem = 0;
147
148 for (@$vals) {
149 my $i = int $_ + $rem;
150 $rem += $_ - $i;
151 $_ = $i;
152 }
153}
154
155sub full_refresh {
156 # make a copy, otherwise for complains about freed values.
157 my @widgets = values %WIDGET;
158
159 $_->update
160 for @widgets;
161}
162
163sub reconfigure_widgets {
164 # make a copy, otherwise C<for> complains about freed values.
165 my @widgets = values %WIDGET;
166
167 $_->reconfigure
168 for @widgets;
169}
170
171# call when resolution changes etc.
172sub rescale_widgets {
173 my ($sx, $sy) = @_;
174
175 for my $widget (values %WIDGET) {
176 if ($widget->{is_toplevel}) {
177 $widget->{x} += int $widget->{w} * 0.5 if $widget->{x} =~ /^[0-9.]+$/;
178 $widget->{y} += int $widget->{h} * 0.5 if $widget->{y} =~ /^[0-9.]+$/;
179
180 $widget->{x} = int 0.5 + $widget->{x} * $sx if $widget->{x} =~ /^[0-9.]+$/;
181 $widget->{w} = int 0.5 + $widget->{w} * $sx if exists $widget->{w};
182 $widget->{force_w} = int 0.5 + $widget->{force_w} * $sx if exists $widget->{force_w};
183 $widget->{y} = int 0.5 + $widget->{y} * $sy if $widget->{y} =~ /^[0-9.]+$/;
184 $widget->{h} = int 0.5 + $widget->{h} * $sy if exists $widget->{h};
185 $widget->{force_h} = int 0.5 + $widget->{force_h} * $sy if exists $widget->{force_h};
186
187 $widget->{x} -= int $widget->{w} * 0.5 if $widget->{x} =~ /^[0-9.]+$/;
188 $widget->{y} -= int $widget->{h} * 0.5 if $widget->{y} =~ /^[0-9.]+$/;
189
190 }
191 }
192
193 reconfigure_widgets;
71} 194}
72 195
73############################################################################# 196#############################################################################
74 197
75package CFClient::UI::Base; 198package CFClient::UI::Base;
76 199
77use strict; 200use strict;
78 201
79use SDL::OpenGL; 202use CFClient::OpenGL;
80 203
81sub new { 204sub new {
82 my $class = shift; 205 my $class = shift;
83 206
84 bless { 207 my $self = bless {
85 x => 0, 208 x => "center",
86 y => 0, 209 y => "center",
87 z => 0, 210 z => 0,
88 w => -1, 211 w => undef,
89 h => -1, 212 h => undef,
213 can_events => 1,
90 @_ 214 @_
91 }, $class 215 }, $class;
92}
93 216
217 Scalar::Util::weaken ($CFClient::UI::WIDGET{$self+0} = $self);
218
219 for (keys %$self) {
220 if (/^on_(.*)$/) {
221 $self->connect ($1 => delete $self->{$_});
222 }
223 }
224
225 if (my $layout = $CFClient::UI::LAYOUT->{$self->{name}}) {
226 $self->{x} = $layout->{x} * $CFClient::UI::ROOT->{alloc_w} if exists $layout->{x};
227 $self->{y} = $layout->{y} * $CFClient::UI::ROOT->{alloc_h} if exists $layout->{y};
228 $self->{force_w} = $layout->{w} * $CFClient::UI::ROOT->{alloc_w} if exists $layout->{w};
229 $self->{force_h} = $layout->{h} * $CFClient::UI::ROOT->{alloc_h} if exists $layout->{h};
230
231 $self->{x} -= $self->{force_w} * 0.5 if exists $layout->{x};
232 $self->{y} -= $self->{force_h} * 0.5 if exists $layout->{y};
233
234 $self->show if $layout->{show};
235 }
236
237 $self
238}
239
240sub destroy {
241 my ($self) = @_;
242
243 $self->hide;
244 %$self = ();
245}
246
247sub show {
248 my ($self) = @_;
249
250 return if $self->{parent};
251
252 $CFClient::UI::ROOT->add ($self);
253}
254
255sub set_visible {
256 my ($self) = @_;
257
258 return if $self->{visible};
259
260 $self->{root} = $self->{parent}{root};
261 $self->{visible} = $self->{parent}{visible} + 1;
262
263 $self->emit (visibility_change => 1);
264
265 $self->realloc if !exists $self->{req_w};
266
267 $_->set_visible for $self->children;
268}
269
270sub set_invisible {
271 my ($self) = @_;
272
273 return unless $self->{visible};
274
275 $_->set_invisible for $self->children;
276
277 delete $self->{visible};
278 delete $self->{root};
279
280 undef $GRAB if $GRAB == $self;
281 undef $HOVER if $HOVER == $self;
282
283 $CFClient::UI::TOOLTIP_WATCHER->cb->()
284 if $TOOLTIP->{owner} == $self;
285
286 $self->emit ("focus_out");
287 $self->emit (visibility_change => 0);
288}
289
290sub set_visibility {
291 my ($self, $visible) = @_;
292
293 return if $self->{visible} == $visible;
294
295 $visible ? $self->hide
296 : $self->show;
297}
298
299sub toggle_visibility {
300 my ($self) = @_;
301
302 $self->{visible}
303 ? $self->hide
304 : $self->show;
305}
306
307sub hide {
308 my ($self) = @_;
309
310 $self->set_invisible;
311
312 $self->{parent}->remove ($self)
313 if $self->{parent};
314}
315
94sub move { 316sub move_abs {
95 my ($self, $x, $y, $z) = @_; 317 my ($self, $x, $y, $z) = @_;
96 $self->{x} = $x; 318
97 $self->{y} = $y; 319 $self->{x} = List::Util::max 0, List::Util::min $self->{root}{w} - $self->{w}, int $x;
320 $self->{y} = List::Util::max 0, List::Util::min $self->{root}{h} - $self->{h}, int $y;
98 $self->{z} = $z if defined $z; 321 $self->{z} = $z if defined $z;
99}
100 322
101sub needs_redraw { 323 $self->update;
102 0 324}
325
326sub set_size {
327 my ($self, $w, $h) = @_;
328
329 $self->{force_w} = $w;
330 $self->{force_h} = $h;
331
332 $self->realloc;
103} 333}
104 334
105sub size_request { 335sub size_request {
106 require Carp; 336 require Carp;
107 Carp::confess "size_request is abtract"; 337 Carp::confess "size_request is abstract";
108} 338}
109 339
110sub _size_allocate { 340sub configure {
111 my ($self, $x, $y, $w, $h) = @_; 341 my ($self, $x, $y, $w, $h) = @_;
112 342
343 if ($self->{aspect}) {
344 my ($ow, $oh) = ($w, $h);
345
346 $w = List::Util::min $w, int $h * $self->{aspect};
347 $h = List::Util::min $h, int $w / $self->{aspect};
348
349 # use alignment to adjust x, y
350
351 $x += int 0.5 * ($ow - $w);
352 $y += int 0.5 * ($oh - $h);
353 }
354
355 if ($self->{x} ne $x || $self->{y} ne $y) {
113 $self->{x} = $x; 356 $self->{x} = $x;
114 $self->{y} = $y; 357 $self->{y} = $y;
358 $self->update;
359 }
115 360
116 return unless $self->{w} != $w || $self->{h} != $h; 361 if ($self->{alloc_w} != $w || $self->{alloc_h} != $h) {
362 return unless $self->{visible};
117 363
118 $self->{w} = $w; 364 $self->{alloc_w} = $w;
119 $self->{h} = $h; 365 $self->{alloc_h} = $h;
120 366
367 $self->{root}{size_alloc}{$self+0} = $self;
121 1 368 }
122} 369}
123 370
124sub size_allocate { 371sub children {
372 # nop
373}
374
375sub visible_children {
376 $_[0]->children
377}
378
379sub set_max_size {
125 my ($self, $x, $y, $w, $h) = @_; 380 my ($self, $w, $h) = @_;
126 381
127 $self->_size_allocate ($x, $y, $w, $h); 382 $self->{max_w} = int $w if defined $w;
128} 383 $self->{max_h} = int $h if defined $h;
129 384
385 $self->realloc;
386}
387
388sub set_tooltip {
389 my ($self, $tooltip) = @_;
390
391 $tooltip =~ s/^\s+//;
392 $tooltip =~ s/\s+$//;
393
394 return if $self->{tooltip} eq $tooltip;
395
396 $self->{tooltip} = $tooltip;
397
398 if ($CFClient::UI::TOOLTIP->{owner} == $self) {
399 delete $CFClient::UI::TOOLTIP->{owner};
400 $CFClient::UI::TOOLTIP_WATCHER->cb->();
401 }
402}
403
130# translate global koordinates to local coordinate system 404# translate global coordinates to local coordinate system
131sub translate { 405sub coord2local {
132 my ($self, $x, $y) = @_; 406 my ($self, $x, $y) = @_;
133 407
134 $self->{parent}->translate ($x - $self->{x}, $y - $self->{y}); 408 $self->{parent}->coord2local ($x - $self->{x}, $y - $self->{y})
135} 409}
136 410
411# translate local coordinates to global coordinate system
412sub coord2global {
413 my ($self, $x, $y) = @_;
414
415 $self->{parent}->coord2global ($x + $self->{x}, $y + $self->{y})
416}
417
137sub focus_in { 418sub invoke_focus_in {
138 my ($self) = @_; 419 my ($self) = @_;
139 420
140 return if $FOCUS == $self; 421 return if $FOCUS == $self;
422 return unless $self->{can_focus};
141 423
142 my $focus = $FOCUS; $FOCUS = $self; 424 my $focus = $FOCUS; $FOCUS = $self;
425
143 $focus->update if $focus; 426 $focus->update if $focus;
144 $FOCUS->update; 427 $FOCUS->update;
145}
146 428
429 0
430}
431
147sub focus_out { 432sub invoke_focus_out {
148 my ($self) = @_; 433 my ($self) = @_;
149 434
150 return unless $FOCUS == $self; 435 return unless $FOCUS == $self;
151 436
152 my $focus = $FOCUS; undef $FOCUS; 437 my $focus = $FOCUS; undef $FOCUS;
438
153 $focus->update if $focus; #? 439 $focus->update if $focus; #?
154}
155 440
441 $::MAPWIDGET->grab_focus #d# focus mapwidget if no other widget has focus
442 unless $FOCUS;
443
444 0
445}
446
447sub grab_focus {
448 my ($self) = @_;
449
450 $self->emit ("focus_in");
451}
452
156sub mouse_motion { } 453sub invoke_mouse_motion { 1 }
157sub button_up { } 454sub invoke_button_up { 1 }
158sub key_down { } 455sub invoke_key_down { 1 }
159sub key_up { } 456sub invoke_key_up { 1 }
160 457
161sub button_down { 458sub invoke_button_down {
162 my ($self, $ev, $x, $y) = @_; 459 my ($self, $ev, $x, $y) = @_;
163 460
164 $self->focus_in; 461 $self->grab_focus;
165}
166 462
167sub w { $_[0]{w} = $_[1] if @_ > 1; $_[0]{w} }
168sub h { $_[0]{h} = $_[1] if @_ > 1; $_[0]{h} }
169sub x { $_[0]{x} = $_[1] if @_ > 1; $_[0]{x} }
170sub y { $_[0]{y} = $_[1] if @_ > 1; $_[0]{y} }
171sub z { $_[0]{z} = $_[1] if @_ > 1; $_[0]{z} }
172
173sub draw {
174 my ($self) = @_;
175
176 return unless $self->{h} && $self->{w};
177
178 glPushMatrix;
179 glTranslate $self->{x}, $self->{y}, 0;
180 $self->_draw;
181 glPopMatrix;
182
183 if ($self == $HOVER) {
184 my ($x, $y) = @$self{qw(x y)};
185
186 glColor 0, 0, 1, 0.2;
187 glEnable GL_BLEND;
188 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
189 glBegin GL_QUADS;
190 glVertex $x , $y;
191 glVertex $x + $self->{w}, $y;
192 glVertex $x + $self->{w}, $y + $self->{h};
193 glVertex $x , $y + $self->{h};
194 glEnd;
195 glDisable GL_BLEND;
196 } 463 1
197} 464}
198 465
199sub _draw { 466sub connect {
200 my ($self) = @_; 467 my ($self, $signal, $cb) = @_;
201 468
202 warn "no draw defined for $self\n"; 469 push @{ $self->{signal_cb}{$signal} }, $cb;
470}
471
472sub emit {
473 my ($self, $signal, @args) = @_;
474
475 #d##TODO# stop propagating at first true, do not use sum
476 (List::Util::sum map $_->($self, @args), @{$self->{signal_cb}{$signal} || []}) # before
477 || ($self->can ("invoke_$signal") || sub { 1 })->($self, @args) # closure
478 || ($self->{parent} && $self->{parent}->emit ($signal, @args)) # parent
203} 479}
204 480
205sub find_widget { 481sub find_widget {
206 my ($self, $x, $y) = @_; 482 my ($self, $x, $y) = @_;
483
484 return () unless $self->{can_events};
207 485
208 return $self 486 return $self
209 if $x >= $self->{x} && $x < $self->{x} + $self->{w} 487 if $x >= $self->{x} && $x < $self->{x} + $self->{w}
210 && $y >= $self->{y} && $y < $self->{y} + $self->{h}; 488 && $y >= $self->{y} && $y < $self->{y} + $self->{h};
211 489
212 () 490 ()
213} 491}
214 492
215sub set_parent { 493sub set_parent {
216 my ($self, $par) = @_; 494 my ($self, $parent) = @_;
217 495
218 $self->{parent} = $par;
219 Scalar::Util::weaken $self->{parent}; 496 Scalar::Util::weaken ($self->{parent} = $parent);
497 $self->set_visible if $parent->{visible};
220} 498}
221 499
222sub get_parent { 500sub realloc {
223 $_[0]->{parent} 501 my ($self) = @_;
502
503 if ($self->{visible}) {
504 return if $self->{root}{realloc}{$self+0};
505
506 $self->{root}{realloc}{$self+0} = $self;
507 $self->{root}->update;
508 } else {
509 delete $self->{req_w};
510 delete $self->{req_h};
511 }
224} 512}
225 513
226sub update { 514sub update {
227 my ($self) = @_; 515 my ($self) = @_;
228 516
229 $self->{parent}->update 517 $self->{parent}->update
230 if $self->{parent}; 518 if $self->{parent};
231} 519}
232 520
233sub connect { 521sub reconfigure {
234 my ($self, $signal, $cb) = @_; 522 my ($self) = @_;
235 523
236 push @{ $self->{cb}{$signal} }, $cb; 524 $self->realloc;
525 $self->update;
237} 526}
238 527
239sub emit { 528# using global variables seems a bit hacky, but passing through all drawing
240 my ($self, $signal, @args) = @_; 529# functions seems pointless.
530our ($draw_x, $draw_y, $draw_w, $draw_h); # screen rectangle being drawn
241 531
242 $_->($self, @args) 532sub draw {
243 for @{$self->{cb}{$signal} || []}; 533 my ($self) = @_;
534
535 return unless $self->{h} && $self->{w};
536
537 # update screen rectangle
538 local $draw_x = $draw_x + $self->{x};
539 local $draw_y = $draw_y + $self->{y};
540 local $draw_w = $draw_x + $self->{w};
541 local $draw_h = $draw_y + $self->{h};
542
543 # skip widgets that are entirely outside the drawing area
544 return if ($draw_x + $self->{w} < 0) || ($draw_x >= $draw_w)
545 || ($draw_y + $self->{h} < 0) || ($draw_y >= $draw_h);
546
547 glPushMatrix;
548 glTranslate $self->{x}, $self->{y}, 0;
549
550 if ($self == $HOVER && $self->{can_hover}) {
551 glColor 1*0.2, 0.8*0.2, 0.5*0.2, 0.2;
552 glEnable GL_BLEND;
553 glBlendFunc GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
554 glBegin GL_QUADS;
555 glVertex 0 , 0;
556 glVertex $self->{w}, 0;
557 glVertex $self->{w}, $self->{h};
558 glVertex 0 , $self->{h};
559 glEnd;
560 glDisable GL_BLEND;
561 }
562
563 if ($ENV{CFPLUS_DEBUG} & 1) {
564 glPushMatrix;
565 glColor 1, 1, 0, 1;
566 glTranslate 0.375, 0.375;
567 glBegin GL_LINE_LOOP;
568 glVertex 0 , 0;
569 glVertex $self->{w} - 1, 0;
570 glVertex $self->{w} - 1, $self->{h} - 1;
571 glVertex 0 , $self->{h} - 1;
572 glEnd;
573 glPopMatrix;
574 #CFClient::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
575 }
576
577 $self->_draw;
578 glPopMatrix;
579}
580
581sub _draw {
582 my ($self) = @_;
583
584 warn "no draw defined for $self\n";
244} 585}
245 586
246sub DESTROY { 587sub DESTROY {
247 my ($self) = @_; 588 my ($self) = @_;
248 589
249 #$self->deactivate; 590 delete $WIDGET{$self+0};
591
592 eval { $self->destroy };
593 warn "exception during widget destruction: $@" if $@ & $@ != /during global destruction/;
250} 594}
251 595
252############################################################################# 596#############################################################################
253 597
254package CFClient::UI::DrawBG; 598package CFClient::UI::DrawBG;
255 599
256our @ISA = CFClient::UI::Base::; 600our @ISA = CFClient::UI::Base::;
257 601
258use strict; 602use strict;
259use SDL::OpenGL; 603use CFClient::OpenGL;
260 604
261sub new { 605sub new {
262 my $class = shift; 606 my $class = shift;
263 607
264 # range [value, low, high, page] 608 # range [value, low, high, page]
265 609
266 $class->SUPER::new ( 610 $class->SUPER::new (
267 bg => [0, 0, 0, 0.2], 611 #bg => [0, 0, 0, 0.2],
268 active_bg => [1, 1, 1], 612 #active_bg => [1, 1, 1, 0.5],
269 @_ 613 @_
270 ) 614 )
271} 615}
272 616
273sub _draw { 617sub _draw {
274 my ($self) = @_; 618 my ($self) = @_;
275 619
620 my $color = $FOCUS == $self && $self->{active_bg}
621 ? $self->{active_bg}
622 : $self->{bg};
623
624 if ($color && (@$color < 4 || $color->[3])) {
276 my ($w, $h) = @$self{qw(w h)}; 625 my ($w, $h) = @$self{qw(w h)};
277 626
278 glEnable GL_BLEND; 627 glEnable GL_BLEND;
279 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA; 628 glBlendFunc GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
280 glColor @{ $FOCUS == $self ? $self->{active_bg} : $self->{bg} }; 629 glColor_premultiply @$color;
281 630
282 glBegin GL_QUADS; 631 glBegin GL_QUADS;
283 glVertex 0 , 0; 632 glVertex 0 , 0;
284 glVertex 0 , $h; 633 glVertex 0 , $h;
285 glVertex $w, $h; 634 glVertex $w, $h;
286 glVertex $w, 0; 635 glVertex $w, 0;
287 glEnd; 636 glEnd;
288 637
289 glDisable GL_BLEND; 638 glDisable GL_BLEND;
639 }
290} 640}
291 641
292############################################################################# 642#############################################################################
293 643
294package CFClient::UI::Empty; 644package CFClient::UI::Empty;
295
296our @ISA = CFClient::UI::Base::;
297
298sub size_request {
299 (0, 0)
300}
301
302sub draw { }
303
304#############################################################################
305
306package CFClient::UI::Container;
307 645
308our @ISA = CFClient::UI::Base::; 646our @ISA = CFClient::UI::Base::;
309 647
310sub new { 648sub new {
311 my ($class, %arg) = @_; 649 my ($class, %arg) = @_;
650 $class->SUPER::new (can_events => 0, %arg);
651}
312 652
653sub size_request {
654 my ($self) = @_;
655
656 ($self->{w} + 0, $self->{h} + 0)
657}
658
659sub draw { }
660
661#############################################################################
662
663package CFClient::UI::Container;
664
665our @ISA = CFClient::UI::Base::;
666
667sub new {
668 my ($class, %arg) = @_;
669
313 my $children = delete $arg{children} || []; 670 my $children = delete $arg{children};
314 671
315 my $self = $class->SUPER::new (children => [], %arg); 672 my $self = $class->SUPER::new (
673 children => [],
674 can_events => 0,
675 %arg,
676 );
677
316 $self->add ($_) for @$children; 678 $self->add (@$children)
679 if $children;
317 680
318 $self 681 $self
319} 682}
320 683
321sub add { 684sub add {
322 my ($self, $chld) = @_; 685 my ($self, @widgets) = @_;
323 686
324 $chld->set_parent ($self); 687 $_->set_parent ($self)
688 for @widgets;
689
690 use sort 'stable';
325 691
326 $self->{children} = [ 692 $self->{children} = [
327 sort { $a->{z} <=> $b->{z} } 693 sort { $a->{z} <=> $b->{z} }
328 @{$self->{children}}, $chld 694 @{$self->{children}}, @widgets
329 ]; 695 ];
330 696
331 $self->{w} = $self->{h} = -1; 697 $self->realloc;
332 $self->update; 698}
699
700sub children {
701 @{ $_[0]{children} }
702}
703
704sub remove {
705 my ($self, $child) = @_;
706
707 delete $child->{parent};
708 $child->hide;
709
710 $self->{children} = [ grep $_ != $child, @{ $self->{children} } ];
711
712 $self->realloc;
713}
714
715sub clear {
716 my ($self) = @_;
717
718 my $children = delete $self->{children};
719 $self->{children} = [];
720
721 for (@$children) {
722 delete $_->{parent};
723 $_->hide;
724 }
725
726 $self->realloc;
727}
728
729sub find_widget {
730 my ($self, $x, $y) = @_;
731
732 $x -= $self->{x};
733 $y -= $self->{y};
734
735 my $res;
736
737 for (reverse $self->visible_children) {
738 $res = $_->find_widget ($x, $y)
739 and return $res;
740 }
741
742 $self->SUPER::find_widget ($x + $self->{x}, $y + $self->{y})
743}
744
745sub _draw {
746 my ($self) = @_;
747
748 $_->draw for @{$self->{children}};
749}
750
751#############################################################################
752
753package CFClient::UI::Bin;
754
755our @ISA = CFClient::UI::Container::;
756
757sub new {
758 my ($class, %arg) = @_;
759
760 my $child = (delete $arg{child}) || new CFClient::UI::Empty::;
761
762 $class->SUPER::new (children => [$child], %arg)
763}
764
765sub add {
766 my ($self, $child) = @_;
767
768 $self->SUPER::remove ($_) for @{ $self->{children} };
769 $self->SUPER::add ($child);
333} 770}
334 771
335sub remove { 772sub remove {
336 my ($self, $widget) = @_; 773 my ($self, $widget) = @_;
337 774
338 $self->{children} = [ grep $_ != $widget, @{ $self->{children} } ]; 775 $self->SUPER::remove ($widget);
339 776
340 $self->size_allocate (0, 0, $self->{w}, $self->{h}); 777 $self->{children} = [new CFClient::UI::Empty]
778 unless @{$self->{children}};
779}
780
781sub child { $_[0]->{children}[0] }
782
783sub size_request {
784 $_[0]{children}[0]->size_request
785}
786
787sub invoke_size_allocate {
788 my ($self, $w, $h) = @_;
789
790 $self->{children}[0]->configure (0, 0, $w, $h);
791
792 1
793}
794
795#############################################################################
796
797# back-buffered drawing area
798
799package CFClient::UI::Window;
800
801our @ISA = CFClient::UI::Bin::;
802
803use CFClient::OpenGL;
804
805sub new {
806 my ($class, %arg) = @_;
807
808 my $self = $class->SUPER::new (%arg);
809}
810
811sub update {
812 my ($self) = @_;
813
814 $ROOT->on_post_alloc ($self => sub { $self->render_child });
815 $self->SUPER::update;
816}
817
818sub invoke_size_allocate {
819 my ($self, $w, $h) = @_;
820
821 $self->update;
822
823 $self->SUPER::invoke_size_allocate ($w, $h)
824}
825
826sub _render {
827 my ($self) = @_;
828
829 $self->{children}[0]->draw;
830}
831
832sub render_child {
833 my ($self) = @_;
834
835 $self->{texture} = new_from_opengl CFClient::Texture $self->{w}, $self->{h}, sub {
836 glClearColor 0, 0, 0, 0;
837 glClear GL_COLOR_BUFFER_BIT;
838
839 {
840 package CFClient::UI::Base;
841
842 ($draw_x, $draw_y, $draw_w, $draw_h) =
843 (0, 0, $self->{w}, $self->{h});
844 }
845
846 $self->_render;
847 };
848}
849
850sub _draw {
851 my ($self) = @_;
852
853 my ($w, $h) = @$self{qw(w h)};
854
855 my $tex = $self->{texture}
856 or return;
857
858 glEnable GL_TEXTURE_2D;
859 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
860 glColor 0, 0, 0, 1;
861
862 $tex->draw_quad_alpha_premultiplied (0, 0, $w, $h);
863
864 glDisable GL_TEXTURE_2D;
865}
866
867#############################################################################
868
869package CFClient::UI::ViewPort;
870
871our @ISA = CFClient::UI::Window::;
872
873sub new {
874 my $class = shift;
875
876 $class->SUPER::new (
877 scroll_x => 0,
878 scroll_y => 1,
879 @_,
880 )
881}
882
883sub size_request {
884 my ($self) = @_;
885
886 my ($w, $h) = @{$self->child}{qw(req_w req_h)};
887
888 $w = 10 if $self->{scroll_x};
889 $h = 10 if $self->{scroll_y};
890
891 ($w, $h)
892}
893
894sub invoke_size_allocate {
895 my ($self, $w, $h) = @_;
896
897 my $child = $self->child;
898
899 $w = $child->{req_w} if $self->{scroll_x} && $child->{req_w};
900 $h = $child->{req_h} if $self->{scroll_y} && $child->{req_h};
901
902 $self->child->configure (0, 0, $w, $h);
903 $self->update;
904
905 1
906}
907
908sub set_offset {
909 my ($self, $x, $y) = @_;
910
911 $self->{view_x} = int $x;
912 $self->{view_y} = int $y;
913
914 $self->update;
915}
916
917# hmm, this does not work for topleft of $self... but we should not ask for that
918sub coord2local {
919 my ($self, $x, $y) = @_;
920
921 $self->SUPER::coord2local ($x + $self->{view_x}, $y + $self->{view_y})
922}
923
924sub coord2global {
925 my ($self, $x, $y) = @_;
926
927 $x = List::Util::min $self->{w}, $x - $self->{view_x};
928 $y = List::Util::min $self->{h}, $y - $self->{view_y};
929
930 $self->SUPER::coord2global ($x, $y)
341} 931}
342 932
343sub find_widget { 933sub find_widget {
344 my ($self, $x, $y) = @_; 934 my ($self, $x, $y) = @_;
345 935
346 $x -= $self->{x}; 936 if ( $x >= $self->{x} && $x < $self->{x} + $self->{w}
347 $y -= $self->{y}; 937 && $y >= $self->{y} && $y < $self->{y} + $self->{h}
348 938 ) {
349 my $res;
350
351 for (reverse @{ $self->{children} }) {
352 $res = $_->find_widget ($x, $y)
353 and return $res;
354 }
355
356 $self->SUPER::find_widget ($x + $self->{x}, $y + $self->{y}) 939 $self->child->find_widget ($x + $self->{view_x}, $y + $self->{view_y})
940 } else {
941 $self->CFClient::UI::Base::find_widget ($x, $y)
942 }
357} 943}
358 944
359sub _draw { 945sub _render {
360 my ($self) = @_; 946 my ($self) = @_;
361 947
362 $_->draw for @{$self->{children}}; 948 local $CFClient::UI::Base::draw_x = $CFClient::UI::Base::draw_x - $self->{view_x};
949 local $CFClient::UI::Base::draw_y = $CFClient::UI::Base::draw_y - $self->{view_y};
950
951 CFClient::OpenGL::glTranslate -$self->{view_x}, -$self->{view_y};
952
953 $self->SUPER::_render;
363} 954}
364 955
365############################################################################# 956#############################################################################
366 957
367package CFClient::UI::Bin; 958package CFClient::UI::ScrolledWindow;
368 959
369our @ISA = CFClient::UI::Container::; 960our @ISA = CFClient::UI::HBox::;
370 961
371sub new { 962sub new {
372 my ($class, %arg) = @_; 963 my ($class, %arg) = @_;
373 964
374 my $child = (delete $arg{child}) || new CFClient::UI::Empty::; 965 my $child = delete $arg{child};
375 966
376 $class->SUPER::new (children => [$child], %arg) 967 my $self;
968
969 my $slider = new CFClient::UI::Slider
970 vertical => 1,
971 range => [0, 0, 1, 0.01], # HACK fix
972 on_changed => sub {
973 $self->{vp}->set_offset (0, $_[1]);
974 },
975 ;
976
977 $self = $class->SUPER::new (
978 vp => (new CFClient::UI::ViewPort expand => 1),
979 slider => $slider,
980 %arg,
981 );
982
983 $self->SUPER::add ($self->{vp}, $self->{slider});
984 $self->add ($child) if $child;
985
986 $self
377} 987}
378 988
379sub add { 989sub add {
380 my ($self, $widget) = @_; 990 my ($self, $widget) = @_;
381 991
382 $self->{children} = []; 992 $self->{vp}->add ($self->{child} = $widget);
383
384 $self->SUPER::add ($widget);
385} 993}
386 994
387sub remove { 995sub update {
388 my ($self, $widget) = @_; 996 my ($self) = @_;
389 997
390 $self->SUPER::remove ($widget); 998 $self->SUPER::update;
391 999
392 $self->{children} = [new CFClient::UI::Empty] 1000 # todo: overwrite size_allocate of child
393 unless @{$self->{children}}; 1001 my $child = $self->{vp}->child;
1002 $self->{slider}->set_range ([$self->{slider}{range}[0], 0, $child->{h}, $self->{vp}{h}, 1]);
394} 1003}
395 1004
396sub child { $_[0]->{children}[0] }
397
398sub size_request {
399 $_[0]{children}[0]->size_request
400}
401
402sub size_allocate { 1005sub invoke_size_allocate {
403 my ($self, $x, $y, $w, $h) = @_; 1006 my ($self, $w, $h) = @_;
404 1007
405 $self->_size_allocate ($x, $y, $w, $h) or return; 1008 my $child = $self->{vp}->child;
1009 $self->{slider}->set_range ([$self->{slider}{range}[0], 0, $child->{h}, $self->{vp}{h}, 1]);
406 1010
407 $self->{children}[0]->size_allocate (0, 0, $w, $h); 1011 $self->SUPER::invoke_size_allocate ($w, $h)
408} 1012}
1013
1014#TODO# update range on size_allocate depending on child
1015# update viewport offset on scroll
409 1016
410############################################################################# 1017#############################################################################
411 1018
412package CFClient::UI::Window; 1019package CFClient::UI::Frame;
413 1020
414our @ISA = CFClient::UI::Bin::; 1021our @ISA = CFClient::UI::Bin::;
415 1022
416use SDL::OpenGL; 1023use CFClient::OpenGL;
1024
1025sub new {
1026 my $class = shift;
1027
1028 $class->SUPER::new (
1029 bg => undef,
1030 @_,
1031 )
1032}
1033
1034sub _draw {
1035 my ($self) = @_;
1036
1037 if ($self->{bg}) {
1038 my ($w, $h) = @$self{qw(w h)};
1039
1040 glEnable GL_BLEND;
1041 glBlendFunc GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
1042 glColor_premultiply @{ $self->{bg} };
1043
1044 glBegin GL_QUADS;
1045 glVertex 0 , 0;
1046 glVertex 0 , $h;
1047 glVertex $w, $h;
1048 glVertex $w, 0;
1049 glEnd;
1050
1051 glDisable GL_BLEND;
1052 }
1053
1054 $self->SUPER::_draw;
1055}
1056
1057#############################################################################
1058
1059package CFClient::UI::FancyFrame;
1060
1061our @ISA = CFClient::UI::Bin::;
1062
1063use CFClient::OpenGL;
1064
1065my $bg =
1066 new_from_file CFClient::Texture CFClient::find_rcfile "d1_bg.png",
1067 mipmap => 1, wrap => 1;
1068
1069my @border =
1070 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
1071 qw(d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png);
417 1072
418sub new { 1073sub new {
419 my ($class, %arg) = @_; 1074 my ($class, %arg) = @_;
420 1075
421 my $self = $class->SUPER::new (%arg); 1076 my $self = $class->SUPER::new (
422} 1077 bg => [1, 1, 1, 1],
1078 border_bg => [1, 1, 1, 1],
1079 border => 0.6,
1080 can_events => 1,
1081 min_w => 16,
1082 min_h => 16,
1083 %arg,
1084 );
423 1085
424sub update { 1086 $self->{title_widget} = new CFClient::UI::Label
1087 align => 0,
1088 valign => 1,
1089 text => $self->{title},
1090 fontsize => $self->{border},
1091 if exists $self->{title};
1092
1093 if ($self->{has_close_button}) {
1094 $self->{close_button} =
1095 new CFClient::UI::ImageButton
1096 path => 'x1_close.png',
1097 on_activate => sub { $self->hide };
1098
1099 $self->CFClient::UI::Container::add ($self->{close_button});
1100 }
1101
1102 $self
1103}
1104
1105sub add {
425 my ($self) = @_; 1106 my ($self, @widgets) = @_;
426 1107
427 # we want to do this delayed... 1108 $self->SUPER::add (@widgets);
428 $self->render_chld; 1109 $self->CFClient::UI::Container::add ($self->{close_button}) if $self->{close_button};
429 $self->SUPER::update; 1110 $self->CFClient::UI::Container::add ($self->{title_widget}) if $self->{title_widget};
430} 1111}
431 1112
432sub render_chld { 1113sub border {
433 my ($self) = @_; 1114 int $_[0]{border} * $::FONTSIZE
434
435 $self->{texture} =
436 CFClient::Texture->new_from_opengl (
437 $self->{w}, $self->{h}, sub { $self->child->draw }
438 );
439} 1115}
440
441sub size_allocate {
442 my ($self, $x, $y, $w, $h) = @_;
443
444 $self->_size_allocate ($x, $y, $w, $h) or return;
445
446 $self->child->size_allocate (0, 0, $w, $h);
447
448 $self->render_chld;
449}
450
451sub _draw {
452 my ($self) = @_;
453
454 my ($w, $h) = ($self->w, $self->h);
455
456 my $tex = $self->{texture}
457 or return;
458
459 glEnable GL_BLEND;
460 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
461 glEnable GL_TEXTURE_2D;
462 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
463
464 $tex->draw_quad (0, 0, $w, $h);
465
466 glDisable GL_BLEND;
467 glDisable GL_TEXTURE_2D;
468}
469
470#############################################################################
471
472package CFClient::UI::Frame;
473
474our @ISA = CFClient::UI::Bin::;
475
476use SDL::OpenGL;
477 1116
478sub size_request { 1117sub size_request {
479 my ($self) = @_; 1118 my ($self) = @_;
480 my $chld = $self->child
481 or return (0, 0);
482 1119
483 $chld->move (2, 2); 1120 $self->{title_widget}->size_request
1121 if $self->{title_widget};
484 1122
485 map { $_ + 4 } $chld->size_request; 1123 $self->{close_button}->size_request
486} 1124 if $self->{close_button};
487
488sub size_allocate {
489 my ($self, $x, $y, $w, $h) = @_;
490
491 $self->_size_allocate ($x, $y, $w, $h) or return;
492
493 $self->child->size_allocate (2, 2, $w - 4, $h - 4);
494}
495
496sub _draw {
497 my ($self) = @_;
498
499 my $chld = $self->child;
500
501 my ($w, $h) = $chld->size_request;
502
503 glBegin GL_QUADS;
504 glColor 0, 0, 0;
505 glVertex 0 , 0;
506 glVertex 0 , $h + 4;
507 glVertex $w + 4 , $h + 4;
508 glVertex $w + 4 , 0;
509 glEnd;
510
511 $chld->draw;
512}
513
514#############################################################################
515
516package CFClient::UI::FancyFrame;
517
518our @ISA = CFClient::UI::Bin::;
519
520use SDL::OpenGL;
521
522my @tex =
523 map { new_from_file CFClient::Texture CFClient::find_rcfile $_ }
524 qw(d1_bg.png d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png);
525
526sub size_request {
527 my ($self) = @_;
528
529 return ($self->{user_w}, $self->{user_h}) if $self->{user_w} && $self->{user_h};
530 1125
531 my ($w, $h) = $self->SUPER::size_request; 1126 my ($w, $h) = $self->SUPER::size_request;
532 1127
533 $h += $tex[1]->{h}; 1128 (
534 $h += $tex[4]->{h}; 1129 $w + $self->border * 2,
535 $w += $tex[2]->{w}; 1130 $h + $self->border * 2,
536 $w += $tex[3]->{w}; 1131 )
537
538 ($w, $h)
539} 1132}
540 1133
541sub size_allocate { 1134sub invoke_size_allocate {
542 my ($self, $x, $y, $w, $h) = @_; 1135 my ($self, $w, $h) = @_;
543 1136
544 $self->_size_allocate ($x, $y, $w, $h) or return; 1137 if ($self->{title_widget}) {
1138 $self->{title_widget}{w} = $w;
1139 $self->{title_widget}{h} = $h;
1140 $self->{title_widget}->invoke_size_allocate ($w, $h);
1141 }
545 1142
546 $h -= $tex[1]{h}; 1143 my $border = $self->border;
547 $h -= $tex[4]{h};
548 $w -= $tex[2]{w};
549 $w -= $tex[3]{w};
550 1144
551 $h = $h < 0 ? 0 : $h; 1145 $h -= List::Util::max 0, $border * 2;
552 $w = $w < 0 ? 0 : $w; 1146 $w -= List::Util::max 0, $border * 2;
553 1147
554 my $child = $self->child; 1148 $self->child->configure ($border, $border, $w, $h);
555 1149
556 $child->size_allocate ($tex[3]->{w}, $tex[1]->{h}, $w, $h); 1150 $self->{close_button}->configure ($self->{w} - $border, 0, $border, $border)
557} 1151 if $self->{close_button};
558 1152
1153 1
1154}
1155
559sub button_down { 1156sub invoke_button_down {
560 my ($self, $ev, $x, $y) = @_; 1157 my ($self, $ev, $x, $y) = @_;
561 1158
562 if ($x < $self->{w} && $x >= $self->{w} - $tex[2]{w} 1159 my ($w, $h) = @$self{qw(w h)};
563 && $y < $self->{h} && $y >= $self->{h} - $tex[4]{h}) { 1160 my $border = $self->border;
564 1161
1162 my $lr = ($x >= 0 && $x < $border) || ($x > $w - $border && $x < $w);
1163 my $td = ($y >= 0 && $y < $border) || ($y > $h - $border && $y < $h);
1164
1165 if ($lr & $td) {
1166 my ($wx, $wy) = ($self->{x}, $self->{y});
565 my ($ox, $oy) = ($ev->button_x, $ev->button_y); 1167 my ($ox, $oy) = ($ev->{x}, $ev->{y});
566 my ($bw, $bh) = ($self->{w}, $self->{h}); 1168 my ($bw, $bh) = ($self->{w}, $self->{h});
1169
1170 my $mx = $x < $border;
1171 my $my = $y < $border;
567 1172
568 $self->{motion} = sub { 1173 $self->{motion} = sub {
569 my ($ev, $x, $y) = @_; 1174 my ($ev, $x, $y) = @_;
570 1175
571 ($x, $y) = ($ev->motion_x, $ev->motion_y); 1176 my $dx = $ev->{x} - $ox;
1177 my $dy = $ev->{y} - $oy;
572 1178
573 $self->{user_w} = $bw + $x - $ox; 1179 $self->{force_w} = $bw + $dx * ($mx ? -1 : 1);
574 $self->{user_h} = $bh + $y - $oy; 1180 $self->{force_h} = $bh + $dy * ($my ? -1 : 1);
1181
1182 $self->move_abs ($wx + $dx * $mx, $wy + $dy * $my);
575 $self->update; 1183 $self->realloc;
576 }; 1184 };
577 1185
578 } elsif ($x >= 0 && $x < $self->{w} 1186 } elsif ($lr ^ $td) {
579 && $y >= 0 && $y < $tex[1]{h}) {
580
581 my ($ox, $oy) = ($ev->button_x, $ev->button_y); 1187 my ($ox, $oy) = ($ev->{x}, $ev->{y});
582 my ($bx, $by) = ($self->{x}, $self->{y}); 1188 my ($bx, $by) = ($self->{x}, $self->{y});
583 1189
584 $self->{motion} = sub { 1190 $self->{motion} = sub {
585 my ($ev, $x, $y) = @_; 1191 my ($ev, $x, $y) = @_;
586 1192
587 ($x, $y) = ($ev->motion_x, $ev->motion_y); 1193 ($x, $y) = ($ev->{x}, $ev->{y});
588 1194
589 $self->move ($bx + $x - $ox, $by + $y - $oy); 1195 $self->move_abs ($bx + $x - $ox, $by + $y - $oy);
590 $self->update; 1196 # HACK: the next line is required to enforce placement
1197 $self->{parent}->invoke_size_allocate ($self->{parent}{w}, $self->{parent}{h});
591 }; 1198 };
1199 } else {
1200 return 0;
1201 }
1202
592 } 1203 1
593} 1204}
594 1205
595sub button_up { 1206sub invoke_button_up {
596 my ($self, $ev, $x, $y) = @_; 1207 my ($self, $ev, $x, $y) = @_;
597 1208
598 delete $self->{motion}; 1209 ! ! delete $self->{motion}
599} 1210}
600 1211
601sub mouse_motion { 1212sub invoke_mouse_motion {
602 my ($self, $ev, $x, $y) = @_; 1213 my ($self, $ev, $x, $y) = @_;
603 1214
604 $self->{motion}->($ev, $x, $y) if $self->{motion}; 1215 $self->{motion}->($ev, $x, $y) if $self->{motion};
1216
1217 ! ! $self->{motion}
605} 1218}
606 1219
607sub _draw { 1220sub _draw {
608 my ($self) = @_; 1221 my ($self) = @_;
609 1222
1223 my $child = $self->{children}[0];
1224
610 my ($w, $h) = ($self->{w}, $self->{h}); 1225 my ($w, $h ) = ($self->{w}, $self->{h});
611 my ($cw, $ch) = ($self->child->{w}, $self->child->{h}); 1226 my ($cw, $ch) = ($child->{w}, $child->{h});
612 1227
613 glEnable GL_BLEND;
614 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
615 glEnable GL_TEXTURE_2D; 1228 glEnable GL_TEXTURE_2D;
616 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE; 1229 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
617 1230
618 my $top = $tex[1]; 1231 my $border = $self->border;
619 $top->draw_quad (0, 0, $w, $top->{h});
620 1232
621 my $left = $tex[3]; 1233 glColor @{ $self->{border_bg} };
622 $left->draw_quad (0, $top->{h}, $left->{w}, $ch); 1234 $border[0]->draw_quad_alpha (0, 0, $w, $border);
1235 $border[1]->draw_quad_alpha (0, $border, $border, $ch);
1236 $border[2]->draw_quad_alpha ($w - $border, $border, $border, $ch);
1237 $border[3]->draw_quad_alpha (0, $h - $border, $w, $border);
623 1238
624 my $right = $tex[2]; 1239 if (@{$self->{bg}} < 4 || $self->{bg}[3]) {
625 $right->draw_quad ($w - $right->{w}, $top->{h}, $right->{w}, $ch); 1240 glColor @{ $self->{bg} };
626 1241
627 my $bottom = $tex[4]; 1242 # TODO: repeat texture not scale
628 $bottom->draw_quad (0, $h - $bottom->{h}, $w, $bottom->{h}); 1243 # solve this better(?)
629 1244 $bg->{s} = $cw / $bg->{w};
630 my $bg = $tex[0]; 1245 $bg->{t} = $ch / $bg->{h};
631 1246 $bg->draw_quad_alpha ($border, $border, $cw, $ch);
632 glBindTexture GL_TEXTURE_2D, $bg->{name}; 1247 }
633 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
634 glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT;
635 glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT;
636
637 my $rep_x = $cw / $bg->{w};
638 my $rep_y = $ch / $bg->{h};
639
640 $bg->draw_quad ($left->{w}, $top->{h}, $cw, $ch);
641 1248
642 glDisable GL_TEXTURE_2D; 1249 glDisable GL_TEXTURE_2D;
643 glDisable GL_BLEND;
644 1250
645 $self->child->draw; 1251 $child->draw;
646 1252
1253 if ($self->{title_widget}) {
1254 glTranslate 0, $border - $self->{h};
1255 $self->{title_widget}->_draw;
1256
1257 glTranslate 0, - ($border - $self->{h});
1258 }
1259
1260 $self->{close_button}->draw
1261 if $self->{close_button};
647} 1262}
648 1263
649############################################################################# 1264#############################################################################
650 1265
651package CFClient::UI::Table; 1266package CFClient::UI::Table;
652 1267
653our @ISA = CFClient::UI::Base::; 1268our @ISA = CFClient::UI::Base::;
654 1269
655use List::Util qw(max sum); 1270use List::Util qw(max sum);
656 1271
657use SDL::OpenGL; 1272use CFClient::OpenGL;
658 1273
659sub new { 1274sub new {
660 my $class = shift; 1275 my $class = shift;
661 1276
662 $class->SUPER::new ( 1277 $class->SUPER::new (
663 col_expand => [], 1278 col_expand => [],
664 @_ 1279 @_,
665 ) 1280 )
666} 1281}
667 1282
1283sub children {
1284 grep $_, map @$_, grep $_, @{ $_[0]{children} }
1285}
1286
668sub add { 1287sub add {
669 my ($self, $x, $y, $chld) = @_; 1288 my ($self, $x, $y, $child) = @_;
670 1289
1290 $child->set_parent ($self);
671 $self->{children}[$y][$x] = $chld; 1291 $self->{children}[$y][$x] = $child;
672 $chld->set_parent ($self);
673 1292
674 $self->{w} = $self->{h} = -1; 1293 $self->realloc;
675 $self->update; 1294}
1295
1296sub remove {
1297 my ($self, $child) = @_;
1298
1299 # TODO: not yet implemented
1300}
1301
1302# TODO: move to container class maybe? send children a signal on removal?
1303sub clear {
1304 my ($self) = @_;
1305
1306 my @children = $self->children;
1307 delete $self->{children};
1308
1309 for (@children) {
1310 delete $_->{parent};
1311 $_->hide;
1312 }
1313
1314 $self->realloc;
676} 1315}
677 1316
678sub get_wh { 1317sub get_wh {
679 my ($self) = @_; 1318 my ($self) = @_;
680 1319
… …
685 or next; 1324 or next;
686 1325
687 for my $x (0 .. $#$row) { 1326 for my $x (0 .. $#$row) {
688 my $widget = $row->[$x] 1327 my $widget = $row->[$x]
689 or next; 1328 or next;
690 my ($w, $h) = $widget->size_request; 1329 my ($w, $h) = @$widget{qw(req_w req_h)};
691 1330
692 $w[$x] = max $w[$x], $w; 1331 $w[$x] = max $w[$x], $w;
693 $h[$y] = max $h[$y], $h; 1332 $h[$y] = max $h[$y], $h;
694 } 1333 }
695 } 1334 }
… …
706 (sum @$ws), 1345 (sum @$ws),
707 (sum @$hs), 1346 (sum @$hs),
708 ) 1347 )
709} 1348}
710 1349
711sub size_allocate { 1350sub invoke_size_allocate {
712 my ($self, $x, $y, $w, $h) = @_; 1351 my ($self, $w, $h) = @_;
713
714 $self->_size_allocate ($x, $y, $w, $h) or return;
715 1352
716 my ($ws, $hs) = $self->get_wh; 1353 my ($ws, $hs) = $self->get_wh;
717 1354
718 my $req_w = sum @$ws; 1355 my $req_w = (sum @$ws) || 1;
719 my $req_h = sum @$hs; 1356 my $req_h = (sum @$hs) || 1;
720 1357
721 # TODO: nicer code && do row_expand 1358 # TODO: nicer code && do row_expand
722 my @col_expand = @{$self->{col_expand}}; 1359 my @col_expand = @{$self->{col_expand}};
723 @col_expand = (1) x @$ws unless @col_expand; 1360 @col_expand = (1) x @$ws unless @col_expand;
724 my $col_expand = (sum @col_expand) || 1; 1361 my $col_expand = (sum @col_expand) || 1;
725 1362
726 # linearly scale sizes 1363 # linearly scale sizes
727 $ws->[$_] += $col_expand[$_] / $col_expand * ($w - $req_w) for 0 .. $#$ws; 1364 $ws->[$_] += $col_expand[$_] / $col_expand * ($w - $req_w) for 0 .. $#$ws;
728 $hs->[$_] *= 1 * $h / $req_h for 0 .. $#$hs; 1365 $hs->[$_] *= 1 * $h / $req_h for 0 .. $#$hs;
729 1366
1367 CFClient::UI::harmonize $ws;
1368 CFClient::UI::harmonize $hs;
1369
730 my $y; 1370 my $y;
731 1371
732 for my $r (0 .. $#{$self->{children}}) { 1372 for my $r (0 .. $#{$self->{children}}) {
733 my $row = $self->{children}[$r] 1373 my $row = $self->{children}[$r]
734 or next; 1374 or next;
735 1375
736 my $x = 0; 1376 my $x = 0;
737 my $row_h = $hs->[$r]; 1377 my $row_h = $hs->[$r];
738 1378
739 for my $c (0 .. $#$row) { 1379 for my $c (0 .. $#$row) {
740 my $widget = $row->[$c]
741 or next;
742
743 my $col_w = $ws->[$c]; 1380 my $col_w = $ws->[$c];
744 1381
1382 if (my $widget = $row->[$c]) {
745 $widget->size_allocate ($x, $y, $col_w, $row_h); 1383 $widget->configure ($x, $y, $col_w, $row_h);
1384 }
746 1385
747 $x += $col_w; 1386 $x += $col_w;
748 } 1387 }
749 1388
750 $y += $row_h; 1389 $y += $row_h;
751 } 1390 }
752 1391
1392 1
753} 1393}
754 1394
755sub find_widget { 1395sub find_widget {
756 my ($self, $x, $y) = @_; 1396 my ($self, $x, $y) = @_;
757 1397
… …
776 } 1416 }
777} 1417}
778 1418
779############################################################################# 1419#############################################################################
780 1420
1421package CFClient::UI::Box;
1422
1423our @ISA = CFClient::UI::Container::;
1424
1425sub size_request {
1426 my ($self) = @_;
1427
1428 $self->{vertical}
1429 ? (
1430 (List::Util::max map $_->{req_w}, @{$self->{children}}),
1431 (List::Util::sum map $_->{req_h}, @{$self->{children}}),
1432 )
1433 : (
1434 (List::Util::sum map $_->{req_w}, @{$self->{children}}),
1435 (List::Util::max map $_->{req_h}, @{$self->{children}}),
1436 )
1437}
1438
1439sub invoke_size_allocate {
1440 my ($self, $w, $h) = @_;
1441
1442 my $space = $self->{vertical} ? $h : $w;
1443 my @children = $self->visible_children;
1444
1445 my @req;
1446
1447 if ($self->{homogeneous}) {
1448 @req = ($space / (@children || 1)) x @children;
1449 } else {
1450 @req = map $_->{$self->{vertical} ? "req_h" : "req_w"}, @children;
1451 my $req = List::Util::sum @req;
1452
1453 if ($req > $space) {
1454 # ah well, not enough space
1455 $_ *= $space / $req for @req;
1456 } else {
1457 my $expand = (List::Util::sum map $_->{expand}, @children) || 1;
1458
1459 $space = ($space - $req) / $expand; # remaining space to give away
1460
1461 $req[$_] += $space * $children[$_]{expand}
1462 for 0 .. $#children;
1463 }
1464 }
1465
1466 CFClient::UI::harmonize \@req;
1467
1468 my $pos = 0;
1469 for (0 .. $#children) {
1470 my $alloc = $req[$_];
1471 $children[$_]->configure ($self->{vertical} ? (0, $pos, $w, $alloc) : ($pos, 0, $alloc, $h));
1472
1473 $pos += $alloc;
1474 }
1475
1476 1
1477}
1478
1479#############################################################################
1480
781package CFClient::UI::HBox; 1481package CFClient::UI::HBox;
782 1482
783# TODO: wrap into common Box base class
784
785our @ISA = CFClient::UI::Container::; 1483our @ISA = CFClient::UI::Box::;
786 1484
787sub size_request { 1485sub new {
788 my ($self) = @_; 1486 my $class = shift;
789 1487
790 my @alloc = map [$_->size_request], @{$self->{children}}; 1488 $class->SUPER::new (
791 1489 vertical => 0,
792 ( 1490 @_,
793 (List::Util::sum map $_->[0], @alloc),
794 (List::Util::max map $_->[1], @alloc),
795 ) 1491 )
796} 1492}
797 1493
798sub size_allocate {
799 my ($self, $x, $y, $w, $h) = @_;
800
801 $self->_size_allocate ($x, $y, $w, $h) or return;
802
803 return unless $self->{w};
804
805 ($h, $w) = ($w, $h);
806
807 my $children = $self->{children};
808
809 my @h = map +($_->size_request)[0], @$children;
810
811 my $req_h = List::Util::sum @h;
812
813 if ($req_h > $h) {
814 # ah well, not enough space
815 $_ *= $h / $req_h for @h;
816 } else {
817 my $exp = List::Util::sum map $_->{expand}, @$children;
818 $exp ||= 1;
819
820 for (0 .. $#$children) {
821 my $child = $children->[$_];
822
823 my $alloc_h = $h[$_];
824 $alloc_h += ($h - $req_h) * $child->{expand} / $exp;
825 $h[$_] = $alloc_h;
826 }
827 }
828
829 my $y = 0;
830 for (0 .. $#$children) {
831 my $child = $children->[$_];
832 my $h = $h[$_];
833 $child->size_allocate ($y, 0, $h, $w);
834
835 $y += $h;
836 }
837}
838
839############################################################################# 1494#############################################################################
840 1495
841package CFClient::UI::VBox; 1496package CFClient::UI::VBox;
842 1497
843# TODO: wrap into common Box base class
844
845our @ISA = CFClient::UI::Container::; 1498our @ISA = CFClient::UI::Box::;
846 1499
847sub size_request { 1500sub new {
848 my ($self) = @_; 1501 my $class = shift;
849 1502
850 my @alloc = map [$_->size_request], @{$self->{children}}; 1503 $class->SUPER::new (
851 1504 vertical => 1,
852 ( 1505 @_,
853 (List::Util::max map $_->[0], @alloc),
854 (List::Util::sum map $_->[1], @alloc),
855 ) 1506 )
856} 1507}
857 1508
858sub size_allocate {
859 my ($self, $x, $y, $w, $h) = @_;
860
861 $self->_size_allocate ($x, $y, $w, $h) or return;
862
863 return unless $self->{h};
864
865 my $children = $self->{children};
866
867 my @h = map +($_->size_request)[1], @$children;
868
869 my $req_h = List::Util::sum @h;
870
871 if ($req_h > $h) {
872 # ah well, not enough space
873 $_ *= $h / $req_h for @h;
874 } else {
875 my $exp = List::Util::sum map $_->{expand}, @$children;
876 $exp ||= 1;
877
878 for (0 .. $#$children) {
879 my $child = $children->[$_];
880
881 $h[$_] += ($h - $req_h) * $child->{expand} / $exp;
882 }
883 }
884
885 my $y = 0;
886 for (0 .. $#$children) {
887 my $child = $children->[$_];
888 my $h = $h[$_];
889 $child->size_allocate (0, $y, $w, $h);
890
891 $y += $h;
892 }
893}
894
895############################################################################# 1509#############################################################################
896 1510
897package CFClient::UI::Label; 1511package CFClient::UI::Label;
898 1512
899our @ISA = CFClient::UI::Base::; 1513our @ISA = CFClient::UI::DrawBG::;
900 1514
901use SDL::OpenGL; 1515use CFClient::OpenGL;
902 1516
903sub new { 1517sub new {
904 my ($class, %arg) = @_; 1518 my ($class, %arg) = @_;
905 1519
906 my $self = $class->SUPER::new ( 1520 my $self = $class->SUPER::new (
907 fg => [1, 1, 1], 1521 fg => [1, 1, 1],
908 height => $::FONTSIZE, 1522 #bg => none
909 text => "", 1523 #active_bg => none
910 align => -1, 1524 #font => default_font
911 padding => 2, 1525 #text => initial text
1526 #markup => initial narkup
1527 #max_w => maximum pixel width
1528 ellipsise => 3, # end
912 layout => new CFClient::Layout, 1529 layout => (new CFClient::Layout),
1530 fontsize => 1,
1531 align => -1,
1532 valign => -1,
1533 padding_x => 2,
1534 padding_y => 2,
1535 can_events => 0,
913 %arg 1536 %arg
914 ); 1537 );
915 1538
1539 if (exists $self->{template}) {
1540 my $layout = new CFClient::Layout;
1541 $layout->set_text (delete $self->{template});
1542 $self->{template} = $layout;
1543 }
1544
1545 if (exists $self->{markup}) {
1546 $self->set_markup (delete $self->{markup});
1547 } else {
916 $self->set_text ($self->{text}); 1548 $self->set_text (delete $self->{text});
1549 }
917 1550
918 $self 1551 $self
919} 1552}
920 1553
921sub escape_text { 1554sub escape($) {
922 local $_ = $_[1]; 1555 local $_ = $_[0];
923 1556
924 s/&/&amp;/g; 1557 s/&/&amp;/g;
925 s/>/&gt;/g; 1558 s/>/&gt;/g;
926 s/</&lt;/g; 1559 s/</&lt;/g;
927 1560
928 $_[1] 1561 $_
1562}
1563
1564sub update {
1565 my ($self) = @_;
1566
1567 delete $self->{texture};
1568 $self->SUPER::update;
1569}
1570
1571sub realloc {
1572 my ($self) = @_;
1573
1574 delete $self->{ox};
1575 $self->SUPER::realloc;
929} 1576}
930 1577
931sub set_text { 1578sub set_text {
932 my ($self, $text) = @_; 1579 my ($self, $text) = @_;
933 1580
1581 return if $self->{text} eq "T$text";
934 $self->{text} = $text; 1582 $self->{text} = "T$text";
1583
1584 $self->{layout} = new CFClient::Layout if $self->{layout}->is_rgba;
1585 $self->{layout}->set_text ($text);
1586
1587 delete $self->{size_req};
1588 $self->realloc;
1589 $self->update;
1590}
1591
1592sub set_markup {
1593 my ($self, $markup) = @_;
1594
1595 return if $self->{text} eq "M$markup";
1596 $self->{text} = "M$markup";
1597
1598 my $rgba = $markup =~ /span.*(?:foreground|background)/;
1599
1600 $self->{layout} = new CFClient::Layout $rgba if $self->{layout}->is_rgba != $rgba;
935 $self->{layout}->set_markup ($text); 1601 $self->{layout}->set_markup ($markup);
936 1602
1603 delete $self->{size_req};
1604 $self->realloc;
1605 $self->update;
1606}
1607
1608sub size_request {
1609 my ($self) = @_;
1610
1611 $self->{size_req} ||= do {
1612 $self->{layout}->set_font ($self->{font}) if $self->{font};
1613 $self->{layout}->set_width ($self->{max_w} || -1);
1614 $self->{layout}->set_ellipsise ($self->{ellipsise});
1615 $self->{layout}->set_single_paragraph_mode ($self->{ellipsise});
1616 $self->{layout}->set_height ($self->{fontsize} * $::FONTSIZE);
1617
1618 my ($w, $h) = $self->{layout}->size;
1619
1620 if (exists $self->{template}) {
1621 $self->{template}->set_font ($self->{font}) if $self->{font};
1622 $self->{template}->set_height ($self->{fontsize} * $::FONTSIZE);
1623
1624 my ($w2, $h2) = $self->{template}->size;
1625
1626 $w = List::Util::max $w, $w2;
1627 $h = List::Util::max $h, $h2;
1628 }
1629
1630 [$w, $h]
1631 };
1632
1633 @{ $self->{size_req} }
1634}
1635
1636sub invoke_size_allocate {
1637 my ($self, $w, $h) = @_;
1638
1639 delete $self->{ox};
1640
1641 delete $self->{texture}
1642 unless $w >= $self->{req_w} && $self->{old_w} >= $self->{req_w};
1643
1644 1
1645}
1646
1647sub set_fontsize {
1648 my ($self, $fontsize) = @_;
1649
1650 $self->{fontsize} = $fontsize;
937 delete $self->{texture}; 1651 delete $self->{texture};
938 $self->update;
939}
940 1652
941sub get_text { 1653 $self->realloc;
1654}
1655
1656sub reconfigure {
942 my ($self, $text) = @_; 1657 my ($self) = @_;
943 1658
944 $self->{text}
945}
946
947sub size_request {
948 my ($self) = @_;
949
950 $self->{layout}->set_width;
951 $self->{layout}->set_height ($self->{height});
952 my ($w, $h) = $self->{layout}->size;
953
954 (
955 $w + $self->{padding} * 2,
956 $h + $self->{padding} * 2,
957 )
958}
959
960sub size_allocate {
961 my ($self, $x, $y, $w, $h) = @_;
962
963 $self->_size_allocate ($x, $y, $w, $h) or return;
964
965 delete $self->{texture}; 1659 delete $self->{size_req};
966}
967 1660
968sub update {
969 my ($self) = @_;
970
971 delete $self->{texture};
972 $self->SUPER::update; 1661 $self->SUPER::reconfigure;
973} 1662}
974 1663
975sub _draw { 1664sub _draw {
976 my ($self) = @_; 1665 my ($self) = @_;
977 1666
1667 $self->SUPER::_draw; # draw background, if applicable
1668
978 my $tex = $self->{texture} ||= do { 1669 my $tex = $self->{texture} ||= do {
1670 $self->{layout}->set_foreground (@{$self->{fg}});
1671 $self->{layout}->set_font ($self->{font}) if $self->{font};
979 $self->{layout}->set_width ($self->{w}); 1672 $self->{layout}->set_width ($self->{w});
980 $self->{layout}->set_height (List::Util::min $self->{h}, $self->{height}); 1673 $self->{layout}->set_ellipsise ($self->{ellipsise});
1674 $self->{layout}->set_single_paragraph_mode ($self->{ellipsise});
1675 $self->{layout}->set_height ($self->{fontsize} * $::FONTSIZE);
1676
981 new_from_layout CFClient::Texture $self->{layout} 1677 new_from_layout CFClient::Texture $self->{layout}
982 }; 1678 };
983 1679
984 glEnable GL_BLEND; 1680 unless (exists $self->{ox}) {
985 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA; 1681 $self->{ox} = int ($self->{align} < 0 ? $self->{padding_x}
1682 : $self->{align} > 0 ? $self->{w} - $tex->{w} - $self->{padding_x}
1683 : ($self->{w} - $tex->{w}) * 0.5);
1684
1685 $self->{oy} = int ($self->{valign} < 0 ? $self->{padding_y}
1686 : $self->{valign} > 0 ? $self->{h} - $tex->{h} - $self->{padding_y}
1687 : ($self->{h} - $tex->{h}) * 0.5);
1688 };
1689
986 glEnable GL_TEXTURE_2D; 1690 glEnable GL_TEXTURE_2D;
1691
1692 my $w = List::Util::min $self->{w} + 4, $tex->{w};
1693 my $h = List::Util::min $self->{h} + 2, $tex->{h};
1694
1695 if ($tex->{format} == GL_ALPHA) {
987 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE; 1696 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
988
989 glColor @{$self->{fg}}; 1697 glColor @{$self->{fg}};
990 1698 $tex->draw_quad_alpha ($self->{ox}, $self->{oy}, $w, $h);
991 my $x = 1699 } else {
992 $self->{align} < 0 ? $self->{padding} 1700 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
993 : $self->{align} > 0 ? $self->{w} - $tex->{w} - $self->{padding} 1701 $tex->draw_quad_alpha_premultiplied ($self->{ox}, $self->{oy}, $w, $h);
994 : ($self->{w} - $tex->{w}) * 0.5; 1702 }
995
996 $tex->draw_quad ($x, $self->{padding});
997 1703
998 glDisable GL_TEXTURE_2D; 1704 glDisable GL_TEXTURE_2D;
999 glDisable GL_BLEND;
1000} 1705}
1001 1706
1002############################################################################# 1707#############################################################################
1003 1708
1004package CFClient::UI::Entry; 1709package CFClient::UI::EntryBase;
1005 1710
1006our @ISA = CFClient::UI::Label::; 1711our @ISA = CFClient::UI::Label::;
1007 1712
1008use SDL; 1713use CFClient::OpenGL;
1009use SDL::OpenGL;
1010 1714
1011sub new { 1715sub new {
1012 my $class = shift; 1716 my $class = shift;
1013 1717
1014 $class->SUPER::new ( 1718 $class->SUPER::new (
1015 fg => [1, 1, 1], 1719 fg => [1, 1, 1],
1016 bg => [0, 0, 0, 0.2], 1720 bg => [0, 0, 0, 0.2],
1017 active_bg => [1, 1, 1], 1721 active_bg => [1, 1, 1, 0.5],
1018 active_fg => [0, 0, 0], 1722 active_fg => [0, 0, 0],
1723 can_hover => 1,
1724 can_focus => 1,
1725 valign => 0,
1726 can_events => 1,
1727 #text => ...
1728 #hidden => "*",
1019 @_ 1729 @_
1020 ) 1730 )
1021} 1731}
1022 1732
1023sub _set_text { 1733sub _set_text {
1024 my ($self, $text) = @_; 1734 my ($self, $text) = @_;
1025 1735
1736 delete $self->{cur_h};
1737
1738 return if $self->{text} eq $text;
1739
1026 $self->{last_activity} = $::NOW; 1740 $self->{last_activity} = $::NOW;
1027
1028 $self->{text} = $text; 1741 $self->{text} = $text;
1029 $self->{layout}->set_width ($self->{w});
1030 1742
1031 $text =~ s/./*/g if $self->{hidden}; 1743 $text =~ s/./*/g if $self->{hidden};
1744 $self->{layout}->set_text ("$text ");
1745 delete $self->{size_req};
1032 1746
1033 $self->{layout}->set_markup ($self->escape_text ($text) . " "); 1747 $self->emit (changed => $self->{text});
1034 1748
1035 $text = substr $text, 0, $self->{cursor}; 1749 $self->realloc;
1036 utf8::encode $text; 1750 $self->update;
1037
1038 @$self{qw(cur_x cur_y cur_h)} = $self->{layout}->cursor_pos (length $text);
1039}
1040
1041sub size_request {
1042 my ($self) = @_;
1043
1044 my ($w, $h) = $self->SUPER::size_request;
1045
1046 ($w + 1, $h) # add 1 for cursor
1047}
1048
1049sub size_allocate {
1050 my ($self, $x, $y, $w, $h) = @_;
1051
1052 $self->SUPER::size_allocate ($x, $y, $w, $h);
1053
1054 $self->_set_text ($self->{text});
1055} 1751}
1056 1752
1057sub set_text { 1753sub set_text {
1058 my ($self, $text) = @_; 1754 my ($self, $text) = @_;
1059 1755
1060 $self->{cursor} = length $text; 1756 $self->{cursor} = length $text;
1061 $self->_set_text ($text); 1757 $self->_set_text ($text);
1062 $self->update;
1063} 1758}
1064 1759
1760sub get_text {
1761 $_[0]{text}
1762}
1763
1764sub size_request {
1765 my ($self) = @_;
1766
1767 my ($w, $h) = $self->SUPER::size_request;
1768
1769 ($w + 1, $h) # add 1 for cursor
1770}
1771
1065sub key_down { 1772sub invoke_key_down {
1066 my ($self, $ev) = @_; 1773 my ($self, $ev) = @_;
1067 1774
1068 my $mod = $ev->key_mod; 1775 my $mod = $ev->{mod};
1069 my $sym = $ev->key_sym; 1776 my $sym = $ev->{sym};
1070
1071 my $uni = $ev->key_unicode; 1777 my $uni = $ev->{unicode};
1072 1778
1073 my $text = $self->get_text; 1779 my $text = $self->get_text;
1074 1780
1075 if ($sym == SDLK_BACKSPACE) { 1781 if ($uni == 8) {
1076 substr $text, --$self->{cursor}, 1, "" if $self->{cursor}; 1782 substr $text, --$self->{cursor}, 1, "" if $self->{cursor};
1077 } elsif ($sym == SDLK_DELETE) { 1783 } elsif ($uni == 127) {
1078 substr $text, $self->{cursor}, 1, ""; 1784 substr $text, $self->{cursor}, 1, "";
1079 } elsif ($sym == SDLK_LEFT) { 1785 } elsif ($sym == CFClient::SDLK_LEFT) {
1080 --$self->{cursor} if $self->{cursor}; 1786 --$self->{cursor} if $self->{cursor};
1081 } elsif ($sym == SDLK_RIGHT) { 1787 } elsif ($sym == CFClient::SDLK_RIGHT) {
1082 ++$self->{cursor} if $self->{cursor} < length $self->{text}; 1788 ++$self->{cursor} if $self->{cursor} < length $self->{text};
1083 } elsif ($sym == SDLK_HOME) { 1789 } elsif ($sym == CFClient::SDLK_HOME) {
1084 $self->{cursor} = 0; 1790 $self->{cursor} = 0;
1085 } elsif ($sym == SDLK_END) { 1791 } elsif ($sym == CFClient::SDLK_END) {
1086 $self->{cursor} = length $text; 1792 $self->{cursor} = length $text;
1793 } elsif ($uni == 27) {
1794 $self->emit ('escape');
1087 } elsif ($uni) { 1795 } elsif ($uni) {
1088 substr $text, $self->{cursor}++, 0, chr $uni; 1796 substr $text, $self->{cursor}++, 0, chr $uni;
1797 } else {
1798 return 0;
1089 } 1799 }
1090 1800
1091 $self->_set_text ($text); 1801 $self->_set_text ($text);
1092 $self->update;
1093}
1094 1802
1803 $self->realloc;
1804
1805 1
1806}
1807
1095sub focus_in { 1808sub invoke_focus_in {
1096 my ($self) = @_; 1809 my ($self) = @_;
1097 1810
1098 $self->{last_activity} = $::NOW; 1811 $self->{last_activity} = $::NOW;
1099 1812
1100 $self->SUPER::focus_in; 1813 $self->SUPER::invoke_focus_in
1101} 1814}
1102 1815
1103sub button_down { 1816sub invoke_button_down {
1104 my ($self, $ev, $x, $y) = @_; 1817 my ($self, $ev, $x, $y) = @_;
1105 1818
1106 $self->SUPER::button_down ($ev, $x, $y); 1819 $self->SUPER::invoke_button_down ($ev, $x, $y);
1107 1820
1108 my $idx = $self->{layout}->xy_to_index ($x, $y); 1821 my $idx = $self->{layout}->xy_to_index ($x, $y);
1109 1822
1110 # byte-index to char-index 1823 # byte-index to char-index
1111 my $text = $self->{text}; 1824 my $text = $self->{text};
1112 utf8::encode $text; 1825 utf8::encode $text;
1113 $self->{cursor} = length substr $text, 0, $idx; 1826 $self->{cursor} = length substr $text, 0, $idx;
1114 1827
1115 $self->_set_text ($self->{text}); 1828 $self->_set_text ($self->{text});
1116 $self->update; 1829 $self->update;
1830
1831 1
1117} 1832}
1118 1833
1119sub mouse_motion { 1834sub invoke_mouse_motion {
1120 my ($self, $ev, $x, $y) = @_; 1835 my ($self, $ev, $x, $y) = @_;
1121# printf "M %d,%d %d,%d\n", $ev->motion_x, $ev->motion_y, $x, $y;#d# 1836# printf "M %d,%d %d,%d\n", $ev->motion_x, $ev->motion_y, $x, $y;#d#
1837
1838 1
1122} 1839}
1123 1840
1124sub _draw { 1841sub _draw {
1125 my ($self) = @_; 1842 my ($self) = @_;
1126 1843
1127 local $self->{fg} = $self->{fg}; 1844 local $self->{fg} = $self->{fg};
1128 1845
1129 if ($FOCUS == $self) { 1846 if ($FOCUS == $self) {
1130 glColor @{$self->{active_bg}}; 1847 glColor_premultiply @{$self->{active_bg}};
1131 $self->{fg} = $self->{active_fg}; 1848 $self->{fg} = $self->{active_fg};
1132 } else { 1849 } else {
1133 glColor @{$self->{bg}}; 1850 glColor_premultiply @{$self->{bg}};
1134 } 1851 }
1135 1852
1136 glEnable GL_BLEND; 1853 glEnable GL_BLEND;
1137 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA; 1854 glBlendFunc GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
1138 glBegin GL_QUADS; 1855 glBegin GL_QUADS;
1139 glVertex 0 , 0; 1856 glVertex 0 , 0;
1140 glVertex 0 , $self->{h}; 1857 glVertex 0 , $self->{h};
1141 glVertex $self->{w}, $self->{h}; 1858 glVertex $self->{w}, $self->{h};
1142 glVertex $self->{w}, 0; 1859 glVertex $self->{w}, 0;
… …
1145 1862
1146 $self->SUPER::_draw; 1863 $self->SUPER::_draw;
1147 1864
1148 #TODO: force update every cursor change :( 1865 #TODO: force update every cursor change :(
1149 if ($FOCUS == $self && (($::NOW - $self->{last_activity}) & 1023) < 600) { 1866 if ($FOCUS == $self && (($::NOW - $self->{last_activity}) & 1023) < 600) {
1867
1868 unless (exists $self->{cur_h}) {
1869 my $text = substr $self->{text}, 0, $self->{cursor};
1870 utf8::encode $text;
1871
1872 @$self{qw(cur_x cur_y cur_h)} = $self->{layout}->cursor_pos (length $text)
1873 }
1874
1150 glColor @{$self->{fg}}; 1875 glColor @{$self->{fg}};
1151 glBegin GL_LINES; 1876 glBegin GL_LINES;
1152 glVertex $self->{cur_x}, $self->{cur_y};
1153 glVertex $self->{cur_x}, $self->{cur_y} + $self->{cur_h}; 1877 glVertex $self->{cur_x} + $self->{ox}, $self->{cur_y} + $self->{oy};
1878 glVertex $self->{cur_x} + $self->{ox}, $self->{cur_y} + $self->{oy} + $self->{cur_h};
1154 glEnd; 1879 glEnd;
1155 } 1880 }
1156} 1881}
1157 1882
1883package CFClient::UI::Entry;
1884
1885our @ISA = CFClient::UI::EntryBase::;
1886
1887use CFClient::OpenGL;
1888
1889sub invoke_key_down {
1890 my ($self, $ev) = @_;
1891
1892 my $sym = $ev->{sym};
1893
1894 if ($sym == 13) {
1895 unshift @{$self->{history}},
1896 my $txt = $self->get_text;
1897
1898 $self->{history_pointer} = -1;
1899 $self->{history_saveback} = '';
1900 $self->emit (activate => $txt);
1901 $self->update;
1902
1903 } elsif ($sym == CFClient::SDLK_UP) {
1904 if ($self->{history_pointer} < 0) {
1905 $self->{history_saveback} = $self->get_text;
1906 }
1907 if (@{$self->{history} || []} > 0) {
1908 $self->{history_pointer}++;
1909 if ($self->{history_pointer} >= @{$self->{history} || []}) {
1910 $self->{history_pointer} = @{$self->{history} || []} - 1;
1911 }
1912 $self->set_text ($self->{history}->[$self->{history_pointer}]);
1913 }
1914
1915 } elsif ($sym == CFClient::SDLK_DOWN) {
1916 $self->{history_pointer}--;
1917 $self->{history_pointer} = -1 if $self->{history_pointer} < 0;
1918
1919 if ($self->{history_pointer} >= 0) {
1920 $self->set_text ($self->{history}->[$self->{history_pointer}]);
1921 } else {
1922 $self->set_text ($self->{history_saveback});
1923 }
1924
1925 } else {
1926 return $self->SUPER::invoke_key_down ($ev)
1927 }
1928
1929 1
1930}
1931
1158############################################################################# 1932#############################################################################
1159 1933
1160package CFClient::UI::Slider; 1934package CFClient::UI::Button;
1161 1935
1162use strict;
1163
1164use SDL::OpenGL;
1165
1166our @ISA = CFClient::UI::DrawBG::; 1936our @ISA = CFClient::UI::Label::;
1937
1938use CFClient::OpenGL;
1939
1940my @tex =
1941 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
1942 qw(b1_button_active.png);
1167 1943
1168sub new { 1944sub new {
1169 my $class = shift; 1945 my $class = shift;
1170 1946
1947 $class->SUPER::new (
1948 padding_x => 4,
1949 padding_y => 4,
1950 fg => [1, 1, 1],
1951 active_fg => [0, 0, 1],
1952 can_hover => 1,
1953 align => 0,
1954 valign => 0,
1955 can_events => 1,
1956 @_
1957 )
1958}
1959
1960sub invoke_button_up {
1961 my ($self, $ev, $x, $y) = @_;
1962
1963 $self->emit ("activate")
1964 if $x >= 0 && $x < $self->{w}
1965 && $y >= 0 && $y < $self->{h};
1966
1967 1
1968}
1969
1970sub _draw {
1971 my ($self) = @_;
1972
1973 local $self->{fg} = $GRAB == $self ? $self->{active_fg} : $self->{fg};
1974
1975 glEnable GL_TEXTURE_2D;
1976 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
1977 glColor 0, 0, 0, 1;
1978
1979 $tex[0]->draw_quad_alpha (0, 0, $self->{w}, $self->{h});
1980
1981 glDisable GL_TEXTURE_2D;
1982
1983 $self->SUPER::_draw;
1984}
1985
1986#############################################################################
1987
1988package CFClient::UI::ImageButton;
1989
1990our @ISA = CFClient::UI::Image::;
1991
1992use CFClient::OpenGL;
1993
1994my %textures;
1995
1996sub new {
1997 my $class = shift;
1998
1999 my $self = $class->SUPER::new (
2000 padding_x => 4,
2001 padding_y => 4,
2002 fg => [1, 1, 1],
2003 active_fg => [0, 0, 1],
2004 can_hover => 1,
2005 align => 0,
2006 valign => 0,
2007 can_events => 1,
2008 @_
2009 );
2010}
2011
2012sub invoke_button_up {
2013 my ($self, $ev, $x, $y) = @_;
2014
2015 $self->emit ("activate")
2016 if $x >= 0 && $x < $self->{w}
2017 && $y >= 0 && $y < $self->{h};
2018
2019 1
2020}
2021
2022#############################################################################
2023
2024package CFClient::UI::CheckBox;
2025
2026our @ISA = CFClient::UI::DrawBG::;
2027
2028my @tex =
2029 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
2030 qw(c1_checkbox_bg.png c1_checkbox_active.png);
2031
2032use CFClient::OpenGL;
2033
2034sub new {
2035 my $class = shift;
2036
2037 $class->SUPER::new (
2038 padding_x => 2,
2039 padding_y => 2,
2040 fg => [1, 1, 1],
2041 active_fg => [1, 1, 0],
2042 bg => [0, 0, 0, 0.2],
2043 active_bg => [1, 1, 1, 0.5],
2044 state => 0,
2045 can_hover => 1,
2046 @_
2047 )
2048}
2049
2050sub size_request {
2051 my ($self) = @_;
2052
2053 (6) x 2
2054}
2055
2056sub invoke_button_down {
2057 my ($self, $ev, $x, $y) = @_;
2058
2059 if ($x >= $self->{padding_x} && $x < $self->{w} - $self->{padding_x}
2060 && $y >= $self->{padding_y} && $y < $self->{h} - $self->{padding_y}) {
2061 $self->{state} = !$self->{state};
2062 $self->emit (changed => $self->{state});
2063 } else {
2064 return 0
2065 }
2066
2067 1
2068}
2069
2070sub _draw {
2071 my ($self) = @_;
2072
2073 $self->SUPER::_draw;
2074
2075 glTranslate $self->{padding_x} + 0.375, $self->{padding_y} + 0.375, 0;
2076
2077 my ($w, $h) = @$self{qw(w h)};
2078
2079 my $s = List::Util::min $w - $self->{padding_x} * 2, $h - $self->{padding_y} * 2;
2080
2081 glColor @{ $FOCUS == $self ? $self->{active_fg} : $self->{fg} };
2082
2083 my $tex = $self->{state} ? $tex[1] : $tex[0];
2084
2085 glEnable GL_TEXTURE_2D;
2086 $tex->draw_quad_alpha (0, 0, $s, $s);
2087 glDisable GL_TEXTURE_2D;
2088}
2089
2090#############################################################################
2091
2092package CFClient::UI::Image;
2093
2094our @ISA = CFClient::UI::Base::;
2095
2096use CFClient::OpenGL;
2097
2098our %texture_cache;
2099
2100sub new {
2101 my $class = shift;
2102
2103 my $self = $class->SUPER::new (
2104 can_events => 0,
2105 @_,
2106 );
2107
2108 $self->{path}
2109 or Carp::croak "required attribute 'path' not set";
2110
2111 $self->{tex} = $texture_cache{$self->{path}} ||=
2112 new_from_file CFClient::Texture CFClient::find_rcfile $self->{path}, mipmap => 1;
2113
2114 Scalar::Util::weaken $texture_cache{$self->{path}};
2115
2116 $self->{aspect} ||= $self->{tex}{w} / $self->{tex}{h};
2117
2118 $self
2119}
2120
2121sub size_request {
2122 my ($self) = @_;
2123
2124 ($self->{tex}{w}, $self->{tex}{h})
2125}
2126
2127sub _draw {
2128 my ($self) = @_;
2129
2130 my $tex = $self->{tex};
2131
2132 my ($w, $h) = ($self->{w}, $self->{h});
2133
2134 if ($self->{rot90}) {
2135 glRotate 90, 0, 0, 1;
2136 glTranslate 0, -$self->{w}, 0;
2137
2138 ($w, $h) = ($h, $w);
2139 }
2140
2141 glEnable GL_TEXTURE_2D;
2142 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
2143
2144 $tex->draw_quad_alpha (0, 0, $w, $h);
2145
2146 glDisable GL_TEXTURE_2D;
2147}
2148
2149#############################################################################
2150
2151package CFClient::UI::VGauge;
2152
2153our @ISA = CFClient::UI::Base::;
2154
2155use List::Util qw(min max);
2156
2157use CFClient::OpenGL;
2158
2159my %tex = (
2160 food => [
2161 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
2162 qw/g1_food_gauge_empty.png g1_food_gauge_full.png/
2163 ],
2164 grace => [
2165 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
2166 qw/g1_grace_gauge_empty.png g1_grace_gauge_full.png g1_grace_gauge_overflow.png/
2167 ],
2168 hp => [
2169 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
2170 qw/g1_hp_gauge_empty.png g1_hp_gauge_full.png/
2171 ],
2172 mana => [
2173 map { new_from_file CFClient::Texture CFClient::find_rcfile $_, mipmap => 1 }
2174 qw/g1_mana_gauge_empty.png g1_mana_gauge_full.png g1_mana_gauge_overflow.png/
2175 ],
2176);
2177
2178# eg. VGauge->new (gauge => 'food'), default gauge: food
2179sub new {
2180 my $class = shift;
2181
2182 my $self = $class->SUPER::new (
2183 type => 'food',
2184 @_
2185 );
2186
2187 $self->{aspect} = $tex{$self->{type}}[0]{w} / $tex{$self->{type}}[0]{h};
2188
2189 $self
2190}
2191
2192sub size_request {
2193 my ($self) = @_;
2194
2195 #my $tex = $tex{$self->{type}}[0];
2196 #@$tex{qw(w h)}
2197 (0, 0)
2198}
2199
2200sub set_max {
2201 my ($self, $max) = @_;
2202
2203 return if $self->{max_val} == $max;
2204
2205 $self->{max_val} = $max;
2206 $self->update;
2207}
2208
2209sub set_value {
2210 my ($self, $val, $max) = @_;
2211
2212 $self->set_max ($max)
2213 if defined $max;
2214
2215 return if $self->{val} == $val;
2216
2217 $self->{val} = $val;
2218 $self->update;
2219}
2220
2221sub _draw {
2222 my ($self) = @_;
2223
2224 my $tex = $tex{$self->{type}};
2225 my ($t1, $t2, $t3) = @$tex;
2226
2227 my ($w, $h) = ($self->{w}, $self->{h});
2228
2229 if ($self->{vertical}) {
2230 glRotate 90, 0, 0, 1;
2231 glTranslate 0, -$self->{w}, 0;
2232
2233 ($w, $h) = ($h, $w);
2234 }
2235
2236 my $ycut = $self->{val} / ($self->{max_val} || 1);
2237
2238 my $ycut1 = max 0, min 1, $ycut;
2239 my $ycut2 = max 0, min 1, $ycut - 1;
2240
2241 my $h1 = $self->{h} * (1 - $ycut1);
2242 my $h2 = $self->{h} * (1 - $ycut2);
2243
2244 glEnable GL_BLEND;
2245 glBlendFuncSeparate GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
2246 GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
2247 glEnable GL_TEXTURE_2D;
2248 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
2249
2250 glBindTexture GL_TEXTURE_2D, $t1->{name};
2251 glBegin GL_QUADS;
2252 glTexCoord 0 , 0; glVertex 0 , 0;
2253 glTexCoord 0 , $t1->{t} * (1 - $ycut1); glVertex 0 , $h1;
2254 glTexCoord $t1->{s}, $t1->{t} * (1 - $ycut1); glVertex $w, $h1;
2255 glTexCoord $t1->{s}, 0; glVertex $w, 0;
2256 glEnd;
2257
2258 my $ycut1 = List::Util::min 1, $ycut;
2259 glBindTexture GL_TEXTURE_2D, $t2->{name};
2260 glBegin GL_QUADS;
2261 glTexCoord 0 , $t2->{t} * (1 - $ycut1); glVertex 0 , $h1;
2262 glTexCoord 0 , $t2->{t} * (1 - $ycut2); glVertex 0 , $h2;
2263 glTexCoord $t2->{s}, $t2->{t} * (1 - $ycut2); glVertex $w, $h2;
2264 glTexCoord $t2->{s}, $t2->{t} * (1 - $ycut1); glVertex $w, $h1;
2265 glEnd;
2266
2267 if ($t3) {
2268 glBindTexture GL_TEXTURE_2D, $t3->{name};
2269 glBegin GL_QUADS;
2270 glTexCoord 0 , $t3->{t} * (1 - $ycut2); glVertex 0 , $h2;
2271 glTexCoord 0 , $t3->{t}; glVertex 0 , $self->{h};
2272 glTexCoord $t3->{s}, $t3->{t}; glVertex $w, $self->{h};
2273 glTexCoord $t3->{s}, $t3->{t} * (1 - $ycut2); glVertex $w, $h2;
2274 glEnd;
2275 }
2276
2277 glDisable GL_BLEND;
2278 glDisable GL_TEXTURE_2D;
2279}
2280
2281#############################################################################
2282
2283package CFClient::UI::Gauge;
2284
2285our @ISA = CFClient::UI::VBox::;
2286
2287sub new {
2288 my ($class, %arg) = @_;
2289
2290 my $self = $class->SUPER::new (
2291 tooltip => $arg{type},
2292 can_hover => 1,
2293 can_events => 1,
2294 %arg,
2295 );
2296
2297 $self->add ($self->{value} = new CFClient::UI::Label valign => +1, align => 0, template => "999");
2298 $self->add ($self->{gauge} = new CFClient::UI::VGauge type => $self->{type}, expand => 1, can_hover => 1);
2299 $self->add ($self->{max} = new CFClient::UI::Label valign => -1, align => 0, template => "999");
2300
2301 $self
2302}
2303
2304sub set_fontsize {
2305 my ($self, $fsize) = @_;
2306
2307 $self->{value}->set_fontsize ($fsize);
2308 $self->{max} ->set_fontsize ($fsize);
2309}
2310
2311sub set_max {
2312 my ($self, $max) = @_;
2313
2314 $self->{gauge}->set_max ($max);
2315 $self->{max}->set_text ($max);
2316}
2317
2318sub set_value {
2319 my ($self, $val, $max) = @_;
2320
2321 $self->set_max ($max)
2322 if defined $max;
2323
2324 $self->{gauge}->set_value ($val, $max);
2325 $self->{value}->set_text ($val);
2326}
2327
2328#############################################################################
2329
2330package CFClient::UI::Slider;
2331
2332use strict;
2333
2334use CFClient::OpenGL;
2335
2336our @ISA = CFClient::UI::DrawBG::;
2337
2338my @tex =
2339 map { new_from_file CFClient::Texture CFClient::find_rcfile $_ }
2340 qw(s1_slider.png s1_slider_bg.png);
2341
2342sub new {
2343 my $class = shift;
2344
1171 # range [value, low, high, page] 2345 # range [value, low, high, page, unit]
1172 2346
2347 # TODO: 0-width page
2348 # TODO: req_w/h are wrong with vertical
2349 # TODO: calculations are off
1173 my $self = $class->SUPER::new ( 2350 my $self = $class->SUPER::new (
1174 fg => [1, 1, 1], 2351 fg => [1, 1, 1],
1175 active_fg => [0, 0, 0], 2352 active_fg => [0, 0, 0],
2353 bg => [0, 0, 0, 0.2],
2354 active_bg => [1, 1, 1, 0.5],
1176 range => [0, 0, 100, 10], 2355 range => [0, 0, 100, 10, 0],
1177 req_w => 40, 2356 min_w => $::WIDTH / 80,
1178 req_h => 10, 2357 min_h => $::WIDTH / 80,
1179 vertical => 0, 2358 vertical => 0,
2359 can_hover => 1,
2360 inner_pad => 0.02,
1180 @_ 2361 @_
1181 ); 2362 );
1182 2363
2364 $self->set_value ($self->{range}[0]);
2365 $self->update;
2366
1183 $self 2367 $self
1184} 2368}
1185 2369
2370sub set_range {
2371 my ($self, $range) = @_;
2372
2373 ($range, $self->{range}) = ($self->{range}, $range);
2374
2375 if ("@$range" ne "@{$self->{range}}") {
2376 $self->update;
2377 $self->set_value ($self->{range}[0]);
2378 }
2379}
2380
2381sub set_value {
2382 my ($self, $value) = @_;
2383
2384 my ($old_value, $lo, $hi, $page, $unit) = @{$self->{range}};
2385
2386 $hi = $lo + 1 if $hi <= $lo;
2387
2388 $page = $hi - $lo if $page > $hi - $lo;
2389
2390 $value = $lo if $value < $lo;
2391 $value = $hi - $page if $value > $hi - $page;
2392
2393 $value = $lo + $unit * int +($value - $lo + $unit * 0.5) / $unit
2394 if $unit;
2395
2396 @{$self->{range}} = ($value, $lo, $hi, $page, $unit);
2397
2398 if ($value != $old_value) {
2399 $self->emit (changed => $value);
2400 $self->update;
2401 }
2402}
2403
1186sub size_request { 2404sub size_request {
1187 my ($self) = @_; 2405 my ($self) = @_;
1188 2406
1189 my $w = $self->{req_w}; 2407 ($self->{req_w}, $self->{req_h})
1190 my $h = $self->{req_h};
1191
1192 $self->{vertical} ? ($h, $w) : ($w, $h)
1193} 2408}
1194 2409
1195sub button_down { 2410sub invoke_button_down {
1196 my ($self, $ev, $x, $y) = @_; 2411 my ($self, $ev, $x, $y) = @_;
1197 2412
1198 $self->SUPER::button_down ($ev, $x, $y); 2413 $self->SUPER::invoke_button_down ($ev, $x, $y);
2414
2415 $self->{click} = [$self->{range}[0], $self->{vertical} ? $y : $x];
2416
1199 $self->mouse_motion ($ev, $x, $y); 2417 $self->invoke_mouse_motion ($ev, $x, $y)
1200} 2418}
1201 2419
1202sub mouse_motion { 2420sub invoke_mouse_motion {
1203 my ($self, $ev, $x, $y) = @_; 2421 my ($self, $ev, $x, $y) = @_;
1204 2422
1205 if ($GRAB == $self) { 2423 if ($GRAB == $self) {
2424 my ($x, $w) = $self->{vertical} ? ($y, $self->{h}) : ($x, $self->{w});
2425
2426 my (undef, $lo, $hi, $page) = @{$self->{range}};
2427
2428 $x = ($x - $self->{click}[1]) / ($w * $self->{scale});
2429
2430 $self->set_value ($self->{click}[0] + $x * ($hi - $page - $lo));
2431 } else {
2432 return 0;
2433 }
2434
2435 1
2436}
2437
2438sub update {
2439 my ($self) = @_;
2440
2441 delete $self->{knob_w};
2442 $self->SUPER::update;
2443}
2444
2445sub _draw {
2446 my ($self) = @_;
2447
2448 unless ($self->{knob_w}) {
2449 $self->set_value ($self->{range}[0]);
2450
1206 my ($value, $lo, $hi, $page) = @{$self->{range}}; 2451 my ($value, $lo, $hi, $page) = @{$self->{range}};
2452 my $range = ($hi - $page - $lo) || 1e-100;
1207 2453
1208 my ($x, $w) = $self->{vertical} ? ($y, $self->{h}) : ($x, $self->{w}); 2454 my $knob_w = List::Util::min 1, $page / ($hi - $lo) || 0.1;
1209 2455
1210 $x = $x * ($hi - $lo) / $w + $lo; 2456 $self->{offset} = List::Util::max $self->{inner_pad}, $knob_w * 0.5;
1211 $x = $lo if $x < $lo; 2457 $self->{scale} = 1 - 2 * $self->{offset} || 1e-100;
1212 $x = $hi - $page if $x > $hi - $page;
1213 $self->{range}[0] = $x;
1214 2458
1215 $self->emit (changed => $x); 2459 $value = ($value - $lo) / $range;
1216 $self->update; 2460 $value = $value * $self->{scale} + $self->{offset};
1217 }
1218}
1219 2461
1220sub _draw { 2462 $self->{knob_x} = $value - $knob_w * 0.5;
1221 my ($self) = @_; 2463 $self->{knob_w} = $knob_w;
2464 }
1222 2465
1223 $self->SUPER::_draw (); 2466 $self->SUPER::_draw ();
1224 2467
1225 my ($w, $h) = @$self{qw(w h)}; 2468 glScale $self->{w}, $self->{h};
1226 2469
1227 if ($self->{vertical}) { 2470 if ($self->{vertical}) {
1228 # draw a vertical slider like a rotated horizontal slider 2471 # draw a vertical slider like a rotated horizontal slider
1229 2472
2473 glTranslate 1, 0, 0;
1230 glRotate 90, 0, 0, 1; 2474 glRotate 90, 0, 0, 1;
1231 glTranslate 0, -$self->{w}, 0;
1232
1233 ($w, $h) = ($h, $w);
1234 } 2475 }
1235 2476
1236 my $fg = $FOCUS == $self ? $self->{active_fg} : $self->{fg}; 2477 my $fg = $FOCUS == $self ? $self->{active_fg} : $self->{fg};
1237 my $bg = $FOCUS == $self ? $self->{active_bg} : $self->{bg}; 2478 my $bg = $FOCUS == $self ? $self->{active_bg} : $self->{bg};
1238 2479
1239 my ($value, $lo, $hi, $page) = @{$self->{range}}; 2480 glEnable GL_TEXTURE_2D;
2481 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
1240 2482
1241 $page = int $page * $w / ($hi - $lo); 2483 # draw background
1242 $value = int +($value - $lo) * $w / ($hi - $lo); 2484 $tex[1]->draw_quad_alpha (0, 0, 1, 1);
1243 2485
1244 $w -= $page; 2486 # draw handle
1245 $page &= ~1; 2487 $tex[0]->draw_quad_alpha ($self->{knob_x}, 0, $self->{knob_w}, 1);
1246 glTranslate $page * 0.5, 0, 0;
1247 2488
1248 glColor @$fg; 2489 glDisable GL_TEXTURE_2D;
1249 glBegin GL_LINES;
1250 glVertex 0, 0; glVertex 0, $h;
1251 glVertex $w - 1, 0; glVertex $w - 1, $h;
1252 glVertex 0, $h * 0.5; glVertex $w, $h * 0.5;
1253 glEnd;
1254
1255 my $knob_a = $value - $page * 0.5;
1256 my $knob_b = $value + $page * 0.5;
1257
1258 glBegin GL_QUADS;
1259 glColor @$fg;
1260 glVertex $knob_a, 0;
1261 glVertex $knob_a, $h;
1262 glVertex $knob_b, $h;
1263 glVertex $knob_b, 0;
1264
1265 if ($knob_a < $knob_b - 2) {
1266 glColor @$bg;
1267 glVertex $knob_a + 1, 1;
1268 glVertex $knob_a + 1, $h - 1;
1269 glVertex $knob_b - 1, $h - 1;
1270 glVertex $knob_b - 1, 1;
1271 }
1272 glEnd;
1273} 2490}
1274 2491
1275############################################################################# 2492#############################################################################
1276 2493
1277package CFClient::UI::MapWidget; 2494package CFClient::UI::ValSlider;
1278 2495
1279use strict;
1280
1281use List::Util qw(min max);
1282
1283use SDL;
1284use SDL::OpenGL;
1285
1286our @ISA = CFClient::UI::Base::; 2496our @ISA = CFClient::UI::HBox::;
2497
2498sub new {
2499 my ($class, %arg) = @_;
2500
2501 my $range = delete $arg{range};
2502
2503 my $self = $class->SUPER::new (
2504 slider => (new CFClient::UI::Slider expand => 1, range => $range),
2505 entry => (new CFClient::UI::Label text => "", template => delete $arg{template}),
2506 to_value => sub { shift },
2507 from_value => sub { shift },
2508 %arg,
2509 );
2510
2511 $self->{slider}->connect (changed => sub {
2512 my ($self, $value) = @_;
2513 $self->{parent}{entry}->set_text ($self->{parent}{to_value}->($value));
2514 $self->{parent}->emit (changed => $value);
2515 });
2516
2517# $self->{entry}->connect (changed => sub {
2518# my ($self, $value) = @_;
2519# $self->{parent}{slider}->set_value ($self->{parent}{from_value}->($value));
2520# $self->{parent}->emit (changed => $value);
2521# });
2522
2523 $self->add ($self->{slider}, $self->{entry});
2524
2525 $self->{slider}->emit (changed => $self->{slider}{range}[0]);
2526
2527 $self
2528}
2529
2530sub set_range { shift->{slider}->set_range (@_) }
2531sub set_value { shift->{slider}->set_value (@_) }
2532
2533#############################################################################
2534
2535package CFClient::UI::TextScroller;
2536
2537our @ISA = CFClient::UI::HBox::;
2538
2539use CFClient::OpenGL;
1287 2540
1288sub new { 2541sub new {
1289 my $class = shift; 2542 my $class = shift;
1290 2543
1291 $class->SUPER::new ( 2544 my $self = $class->SUPER::new (
1292 z => -1, 2545 fontsize => 1,
1293 list => (glGenLists 1), 2546 can_events => 0,
2547 indent => 0,
2548 #font => default_font
1294 @_ 2549 @_,
2550
2551 layout => (new CFClient::Layout 1),
2552 par => [],
2553 height => 0,
2554 children => [
2555 (new CFClient::UI::Empty expand => 1),
2556 (new CFClient::UI::Slider vertical => 1),
2557 ],
1295 ) 2558 );
1296}
1297 2559
1298sub key_down { 2560 $self->{children}[1]->connect (changed => sub { $self->update });
1299 print "MAPKEYDOWN\n";
1300}
1301 2561
1302sub key_up { 2562 $self
1303} 2563}
1304 2564
1305sub size_request { 2565sub set_fontsize {
1306 ( 2566 my ($self, $fontsize) = @_;
1307 1 + 32 * int $::WIDTH / 32, 2567
1308 1 + 32 * int $::HEIGHT / 32, 2568 $self->{fontsize} = $fontsize;
1309 ) 2569 $self->reflow;
2570}
2571
2572sub visible_children {
2573 my ($self) = @_;
2574
2575 @{$self->{children}}[0,1]
2576}
2577
2578sub invoke_size_allocate {
2579 my ($self, $w, $h) = @_;
2580
2581 my (undef, undef, @other) = @{ $self->{children} };
2582 $_->configure (@$_{qw(x y req_w req_h)}) for @other;
2583
2584 $self->{layout}->set_font ($self->{font}) if $self->{font};
2585 $self->{layout}->set_height ($self->{fontsize} * $::FONTSIZE);
2586 $self->{layout}->set_width ($self->{children}[0]{w});
2587 $self->{layout}->set_indent ($self->{fontsize} * $::FONTSIZE * $self->{indent});
2588
2589 $self->reflow;
2590
2591 $self->SUPER::invoke_size_allocate ($w, $h)
2592}
2593
2594sub get_layout {
2595 my ($self, $para) = @_;
2596
2597 my $layout = $self->{layout};
2598
2599 $layout->set_font ($self->{font}) if $self->{font};
2600 $layout->set_height ($self->{fontsize} * $::FONTSIZE);
2601 $layout->set_width ($self->{children}[0]{w} - $para->{indent});
2602 $layout->set_indent ($self->{fontsize} * $::FONTSIZE * $self->{indent});
2603 $layout->set_markup ($para->{markup});
2604 $layout->set_shapes (map +($_->{req_w}, $_->{req_h}), @{$para->{widget}});
2605
2606 $layout
2607}
2608
2609sub reflow {
2610 my ($self) = @_;
2611
2612 $self->{need_reflow}++;
2613 $self->update;
2614}
2615
2616sub set_offset {
2617 my ($self, $offset) = @_;
2618
2619 # todo: base offset on lines or so, not on pixels
2620 $self->{children}[1]->set_value ($offset);
2621}
2622
2623sub clear {
2624 my ($self) = @_;
2625
2626 my (undef, undef, @other) = @{ $self->{children} };
2627 $self->remove ($_) for @other;
2628
2629 $self->{par} = [];
2630 $self->{height} = 0;
2631 $self->{children}[1]->set_range ([0, 0, 0, 1, 1]);
2632}
2633
2634sub add_paragraph {
2635 my ($self, $color, $para, $indent) = @_;
2636
2637 my ($text, @w) = ref $para ? @$para : $para;
2638
2639 $para = {
2640 w => 1e10,
2641 wrapped => 1,
2642 fg => $color,
2643 indent => $indent,
2644 markup => $text,
2645 widget => \@w,
2646 };
2647
2648 $self->add (@w) if @w;
2649 push @{$self->{par}}, $para;
2650
2651 $self->{need_reflow}++;
2652 $self->update;
2653}
2654
2655sub scroll_to_bottom {
2656 my ($self) = @_;
2657
2658 $self->{scroll_to_bottom} = 1;
2659 $self->update;
1310} 2660}
1311 2661
1312sub update { 2662sub update {
1313 my ($self) = @_; 2663 my ($self) = @_;
1314 2664
1315 $self->{need_update} = 1;
1316 $self->SUPER::update; 2665 $self->SUPER::update;
1317}
1318 2666
1319sub draw { 2667 return unless $self->{h} > 0;
1320 my ($self) = @_;
1321 2668
2669 delete $self->{texture};
2670
2671 $ROOT->on_post_alloc ($self => sub {
2672 my ($W, $H) = @{$self->{children}[0]}{qw(w h)};
2673
1322 if (delete $self->{need_update}) { 2674 if (delete $self->{need_reflow}) {
1323 glNewList $self->{list}, GL_COMPILE; 2675 my $height = 0;
1324 2676
1325 my $mx = $::CONN->{mapx}; 2677 for my $para (@{$self->{par}}) {
1326 my $my = $::CONN->{mapy}; 2678 if ($para->{w} != $W && ($para->{wrapped} || $para->{w} > $W)) {
2679 my $layout = $self->get_layout ($para);
2680 my ($w, $h) = $layout->size;
1327 2681
1328 my $map = $::CONN->{map}; 2682 $para->{w} = $w + $para->{indent};
2683 $para->{h} = $h;
2684 $para->{wrapped} = $layout->has_wrapped;
2685 }
1329 2686
1330 my ($xofs, $yofs); 2687 $height += $para->{h};
2688 }
1331 2689
1332 my $sw = 1 + int $::WIDTH / 32; 2690 $self->{height} = $height;
1333 my $sh = 1 + int $::HEIGHT / 32;
1334 2691
1335 if ($::CONN->{mapw} > $sw) { 2692 $self->{children}[1]->set_range ([$self->{children}[1]{range}[0], 0, $height, $H, 1]);
1336 $xofs = $mx + ($::CONN->{mapw} - $sw) * 0.5; 2693
1337 } else { 2694 delete $self->{texture};
1338 $xofs = $self->{xofs} = min $mx, max $mx + $::CONN->{mapw} - $sw + 1, $self->{xofs};
1339 } 2695 }
1340 2696
1341 if ($::CONN->{maph} > $sh) { 2697 if (delete $self->{scroll_to_bottom}) {
1342 $yofs = $my + ($::CONN->{maph} - $sh) * 0.5; 2698 $self->{children}[1]->set_value (1e10);
1343 } else {
1344 $yofs = $self->{yofs} = min $my, max $my + $::CONN->{maph} - $sh + 1, $self->{yofs};
1345 } 2699 }
1346 2700
1347 glEnable GL_TEXTURE_2D; 2701 $self->{texture} ||= new_from_opengl CFClient::Texture $W, $H, sub {
2702 glClearColor 0, 0, 0, 0;
2703 glClear GL_COLOR_BUFFER_BIT;
2704
2705 my $top = int $self->{children}[1]{range}[0];
2706
2707 my $y0 = $top;
2708 my $y1 = $top + $H;
2709
2710 my $y = 0;
2711
1348 glEnable GL_BLEND; 2712 glEnable GL_BLEND;
2713 #TODO# not correct in windows where rgba is forced off
1349 glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA; 2714 glBlendFunc GL_ONE, GL_ONE_MINUS_SRC_ALPHA;
1350 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
1351 2715
1352 my $sw4 = ($sw + 3) & ~3; 2716 for my $para (@{$self->{par}}) {
1353 my $darkness = "\x00" x ($sw4 * $sh); 2717 my $h = $para->{h};
1354 2718
1355 for my $x (0 .. $sw - 1) { 2719 if ($y0 < $y + $h && $y < $y1) {
1356 my $row = $map->[$x + $xofs];
1357 for my $y (0 .. $sh - 1) {
1358 2720
1359 my $cell = $row->[$y + $yofs] 2721 my $layout = $self->get_layout ($para);
2722
2723 my ($w, $h, $data, $format, $internalformat) = $layout->render;
2724
2725 glRasterPos $para->{indent}, $y - $y0;
2726 glDrawPixels $w, $h, $format, GL_UNSIGNED_BYTE, $data;
2727
2728 if (my @w = @{ $para->{widget} }) {
2729 my @s = $layout->get_shapes;
2730
2731 for (@w) {
2732 my ($dx, $dy) = splice @s, 0, 2, ();
2733
2734 $_->{x} = $dx + $para->{indent};
2735 $_->{y} = $dy + $y - $y0;
2736
2737 $_->draw;
2738 }
1360 or next; 2739 }
1361
1362 my $dark = $cell->[0];
1363 if ($dark < 0) {
1364 substr $darkness, $y * $sw4 + $x, 1, chr 224;
1365 } else {
1366 substr $darkness, $y * $sw4 + $x, 1, chr 255 - $dark;
1367 } 2740 }
1368 2741
1369 for my $num (grep $_, @$cell[1,2,3]) { 2742 $y += $h;
1370 my $tex = $::CONN->{face}[$num]{texture} || next;
1371
1372 my ($w, $h) = @$tex{qw(w h)};
1373
1374 $tex->draw_quad (($x + 1) * 32 - $w, ($y + 1) * 32 - $h, $w, $h);
1375 }
1376 } 2743 }
2744
2745 glDisable GL_BLEND;
1377 } 2746 };
2747 });
2748}
1378 2749
1379# if (1) { # higher quality darkness 2750sub reconfigure {
1380# $lighting =~ s/(.)/$1$1$1/gs; 2751 my ($self) = @_;
1381# my $pb = new_from_data Gtk2::Gdk::Pixbuf $lighting, "rgb", 0, 8, $sw4, $sh, $sw4 * 3;
1382#
1383# $pb = $pb->scale_simple ($sw4 * 0.5, $sh * 0.5, "bilinear");
1384#
1385# $lighting = $pb->get_pixels;
1386# $lighting =~ s/(.)../$1/gs;
1387# }
1388 2752
2753 $self->SUPER::reconfigure;
2754
2755 $_->{w} = 1e10 for @{ $self->{par} };
2756 $self->reflow;
2757}
2758
2759sub _draw {
2760 my ($self) = @_;
2761
2762 glEnable GL_TEXTURE_2D;
1389 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE; 2763 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
1390
1391 $darkness = new CFClient::Texture
1392 w => $sw4,
1393 h => $sh,
1394 data => $darkness,
1395 internalformat => GL_ALPHA,
1396 format => GL_ALPHA;
1397
1398 glColor 0.45, 0.45, 0.45, 1; 2764 glColor 0, 0, 0, 1;
1399 $darkness->draw_quad (0, 0, $sw4 * 32, $sh * 32); 2765 $self->{texture}->draw_quad_alpha_premultiplied (0, 0, $self->{children}[0]{w}, $self->{children}[0]{h});
1400
1401 glDisable GL_TEXTURE_2D; 2766 glDisable GL_TEXTURE_2D;
1402 glDisable GL_BLEND;
1403 2767
1404 glEndList; 2768 $self->{children}[1]->draw;
1405 }
1406
1407 glCallList $self->{list};
1408}
1409
1410my %DIR = (
1411 SDLK_KP8, [1, "north"],
1412 SDLK_KP9, [2, "northeast"],
1413 SDLK_KP6, [3, "east"],
1414 SDLK_KP3, [4, "southeast"],
1415 SDLK_KP2, [5, "south"],
1416 SDLK_KP1, [6, "southwest"],
1417 SDLK_KP4, [7, "west"],
1418 SDLK_KP7, [8, "northwest"],
1419
1420 SDLK_UP, [1, "north"],
1421 SDLK_RIGHT, [3, "east"],
1422 SDLK_DOWN, [5, "south"],
1423 SDLK_LEFT, [7, "west"],
1424);
1425
1426sub key_down {
1427 my ($self, $ev) = @_;
1428
1429 my $mod = $ev->key_mod;
1430 my $sym = $ev->key_sym;
1431
1432 if ($sym == SDLK_KP5) {
1433 $::CONN->send ("command stay fire");
1434 } elsif (exists $DIR{$sym}) {
1435 if ($mod & KMOD_SHIFT) {
1436 $self->{shft}++;
1437 $::CONN->send ("command fire $DIR{$sym}[0]");
1438 } elsif ($mod & KMOD_CTRL) {
1439 $self->{ctrl}++;
1440 $::CONN->send ("command run $DIR{$sym}[0]");
1441 } else {
1442 $::CONN->send ("command $DIR{$sym}[1]");
1443 }
1444 }
1445}
1446
1447sub key_up {
1448 my ($self, $ev) = @_;
1449
1450 my $mod = $ev->key_mod;
1451 my $sym = $ev->key_sym;
1452
1453 if (!($mod & KMOD_SHIFT) && delete $self->{shft}) {
1454 $::CONN->send ("command fire_stop");
1455 }
1456 if (!($mod & KMOD_CTRL ) && delete $self->{ctrl}) {
1457 $::CONN->send ("command run_stop");
1458 }
1459} 2769}
1460 2770
1461############################################################################# 2771#############################################################################
1462 2772
1463package CFClient::UI::Animator; 2773package CFClient::UI::Animator;
1464 2774
1465use SDL::OpenGL; 2775use CFClient::OpenGL;
1466 2776
1467our @ISA = CFClient::UI::Bin::; 2777our @ISA = CFClient::UI::Bin::;
1468 2778
1469sub moveto { 2779sub moveto {
1470 my ($self, $x, $y) = @_; 2780 my ($self, $x, $y) = @_;
… …
1500 glPopMatrix; 2810 glPopMatrix;
1501} 2811}
1502 2812
1503############################################################################# 2813#############################################################################
1504 2814
1505package CFClient::UI::Toplevel; 2815package CFClient::UI::Flopper;
2816
2817our @ISA = CFClient::UI::Button::;
2818
2819sub new {
2820 my $class = shift;
2821
2822 my $self = $class->SUPER::new (
2823 state => 0,
2824 on_activate => \&toggle_flopper,
2825 @_
2826 );
2827
2828 $self
2829}
2830
2831sub toggle_flopper {
2832 my ($self) = @_;
2833
2834 $self->{other}->toggle_visibility;
2835}
2836
2837#############################################################################
2838
2839package CFClient::UI::Tooltip;
2840
2841our @ISA = CFClient::UI::Bin::;
2842
2843use CFClient::OpenGL;
2844
2845sub new {
2846 my $class = shift;
2847
2848 $class->SUPER::new (
2849 @_,
2850 can_events => 0,
2851 )
2852}
2853
2854sub set_tooltip_from {
2855 my ($self, $widget) = @_;
2856
2857 my $tooltip = $widget->{tooltip};
2858
2859 if ($ENV{CFPLUS_DEBUG} & 2) {
2860 $tooltip .= "\n\n" . (ref $widget) . "\n"
2861 . "$widget->{x} $widget->{y} $widget->{w} $widget->{h}\n"
2862 . "req $widget->{req_w} $widget->{req_h}\n"
2863 . "visible $widget->{visible}";
2864 }
2865
2866 $tooltip =~ s/^\n+//;
2867 $tooltip =~ s/\n+$//;
2868
2869 $self->add (new CFClient::UI::Label
2870 markup => $tooltip,
2871 max_w => ($widget->{tooltip_width} || 0.25) * $::WIDTH,
2872 fontsize => 0.8,
2873 fg => [0, 0, 0, 1],
2874 ellipsise => 0,
2875 font => ($widget->{tooltip_font} || $::FONT_PROP),
2876 );
2877}
2878
2879sub size_request {
2880 my ($self) = @_;
2881
2882 my ($w, $h) = @{$self->child}{qw(req_w req_h)};
2883
2884 ($w + 4, $h + 4)
2885}
2886
2887sub invoke_size_allocate {
2888 my ($self, $w, $h) = @_;
2889
2890 $self->SUPER::invoke_size_allocate ($w - 4, $h - 4)
2891}
2892
2893sub invoke_visibility_change {
2894 my ($self, $visible) = @_;
2895
2896 return unless $visible;
2897
2898 $self->{root}->on_post_alloc ("move_$self" => sub {
2899 my $widget = $self->{owner}
2900 or return;
2901
2902 my ($x, $y) = $widget->coord2global ($widget->{w}, 0);
2903
2904 ($x, $y) = $widget->coord2global (-$self->{w}, 0)
2905 if $x + $self->{w} > $self->{root}{w};
2906
2907 $self->move_abs ($x, $y);
2908 });
2909}
2910
2911sub _draw {
2912 my ($self) = @_;
2913
2914 glTranslate 0.375, 0.375;
2915
2916 my ($w, $h) = @$self{qw(w h)};
2917
2918 glColor 1, 0.8, 0.4;
2919 glBegin GL_QUADS;
2920 glVertex 0 , 0;
2921 glVertex 0 , $h;
2922 glVertex $w, $h;
2923 glVertex $w, 0;
2924 glEnd;
2925
2926 glColor 0, 0, 0;
2927 glBegin GL_LINE_LOOP;
2928 glVertex 0 , 0;
2929 glVertex 0 , $h;
2930 glVertex $w, $h;
2931 glVertex $w, 0;
2932 glEnd;
2933
2934 glTranslate 2 - 0.375, 2 - 0.375;
2935
2936 $self->SUPER::_draw;
2937}
2938
2939#############################################################################
2940
2941package CFClient::UI::Face;
2942
2943our @ISA = CFClient::UI::Base::;
2944
2945use CFClient::OpenGL;
2946
2947sub new {
2948 my $class = shift;
2949
2950 my $self = $class->SUPER::new (
2951 aspect => 1,
2952 can_events => 0,
2953 @_,
2954 );
2955
2956 if ($self->{anim} && $self->{animspeed}) {
2957 Scalar::Util::weaken (my $widget = $self);
2958
2959 $self->{timer} = Event->timer (
2960 at => $self->{animspeed} * int $::NOW / $self->{animspeed},
2961 hard => 1,
2962 interval => $self->{animspeed},
2963 cb => sub {
2964 ++$widget->{frame};
2965 $widget->update;
2966 },
2967 );
2968 }
2969
2970 $self
2971}
2972
2973sub size_request {
2974 (32, 8)
2975}
2976
2977sub update {
2978 my ($self) = @_;
2979
2980 return unless $self->{visible};
2981
2982 $self->SUPER::update;
2983}
2984
2985sub _draw {
2986 my ($self) = @_;
2987
2988 return unless $::CONN;
2989
2990 my $face;
2991
2992 if ($self->{frame}) {
2993 my $anim = $::CONN->{anim}[$self->{anim}];
2994
2995 $face = $anim->[ $self->{frame} % @$anim ]
2996 if $anim && @$anim;
2997 }
2998
2999 my $tex = $::CONN->{texture}[$::CONN->{faceid}[$face || $self->{face}]];
3000
3001 if ($tex) {
3002 glEnable GL_TEXTURE_2D;
3003 glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
3004 glColor 0, 0, 0, 1;
3005 $tex->draw_quad_alpha (0, 0, $self->{w}, $self->{h});
3006 glDisable GL_TEXTURE_2D;
3007 }
3008}
3009
3010sub destroy {
3011 my ($self) = @_;
3012
3013 $self->{timer}->cancel
3014 if $self->{timer};
3015
3016 $self->SUPER::destroy;
3017}
3018
3019#############################################################################
3020
3021package CFClient::UI::Buttonbar;
3022
3023our @ISA = CFClient::UI::HBox::;
3024
3025# TODO: should actualyl wrap buttons and other goodies.
3026
3027#############################################################################
3028
3029package CFClient::UI::Menu;
3030
3031our @ISA = CFClient::UI::FancyFrame::;
3032
3033use CFClient::OpenGL;
3034
3035sub new {
3036 my $class = shift;
3037
3038 my $self = $class->SUPER::new (
3039 items => [],
3040 z => 100,
3041 @_,
3042 );
3043
3044 $self->add ($self->{vbox} = new CFClient::UI::VBox);
3045
3046 for my $item (@{ $self->{items} }) {
3047 my ($widget, $cb, $tooltip) = @$item;
3048
3049 # handle various types of items, only text for now
3050 if (!ref $widget) {
3051 $widget = new CFClient::UI::Label
3052 can_hover => 1,
3053 can_events => 1,
3054 markup => $widget,
3055 tooltip => $tooltip
3056 }
3057
3058 $self->{item}{$widget} = $item;
3059
3060 $self->{vbox}->add ($widget);
3061 }
3062
3063 $self
3064}
3065
3066# popup given the event (must be a mouse button down event currently)
3067sub popup {
3068 my ($self, $ev) = @_;
3069
3070 $self->emit ("popdown");
3071
3072 # maybe save $GRAB? must be careful about events...
3073 $GRAB = $self;
3074 $self->{button} = $ev->{button};
3075
3076 $self->show;
3077 $self->move_abs ($ev->{x} - $self->{w} * 0.5, $ev->{y} - $self->{h} * 0.5);
3078}
3079
3080sub invoke_mouse_motion {
3081 my ($self, $ev, $x, $y) = @_;
3082
3083 # TODO: should use vbox->find_widget or so
3084 $HOVER = $ROOT->find_widget ($ev->{x}, $ev->{y});
3085 $self->{hover} = $self->{item}{$HOVER};
3086
3087 0
3088}
3089
3090sub invoke_button_up {
3091 my ($self, $ev, $x, $y) = @_;
3092
3093 if ($ev->{button} == $self->{button}) {
3094 undef $GRAB;
3095 $self->hide;
3096
3097 $self->emit ("popdown");
3098 $self->{hover}[1]->() if $self->{hover};
3099 } else {
3100 return 0
3101 }
3102
3103 1
3104}
3105
3106#############################################################################
3107
3108package CFClient::UI::Multiplexer;
1506 3109
1507our @ISA = CFClient::UI::Container::; 3110our @ISA = CFClient::UI::Container::;
1508 3111
3112sub new {
3113 my $class = shift;
3114
3115 my $self = $class->SUPER::new (
3116 @_,
3117 );
3118
3119 $self->{current} = $self->{children}[0]
3120 if @{ $self->{children} };
3121
3122 $self
3123}
3124
3125sub add {
3126 my ($self, @widgets) = @_;
3127
3128 $self->SUPER::add (@widgets);
3129
3130 $self->{current} = $self->{children}[0]
3131 if @{ $self->{children} };
3132}
3133
3134sub set_current_page {
3135 my ($self, $page_or_widget) = @_;
3136
3137 my $widget = ref $page_or_widget
3138 ? $page_or_widget
3139 : $self->{children}[$page_or_widget];
3140
3141 $self->{current} = $widget;
3142 $self->{current}->configure (0, 0, $self->{w}, $self->{h});
3143
3144 $self->emit (page_changed => $self->{current});
3145
3146 $self->realloc;
3147}
3148
3149sub visible_children {
3150 $_[0]{current}
3151}
3152
1509sub size_request { 3153sub size_request {
1510 ($::WIDTH, $::HEIGHT) 3154 my ($self) = @_;
1511}
1512 3155
3156 $self->{current}->size_request
3157}
3158
1513sub size_allocate { 3159sub invoke_size_allocate {
1514 my ($self, $x, $y, $w, $h) = @_; 3160 my ($self, $w, $h) = @_;
1515 3161
1516 $self->_size_allocate ($x, $y, $w, $h); 3162 $self->{current}->configure (0, 0, $w, $h);
1517 3163
1518 $_->size_allocate ($_->{x}, $_->{y}, $_->size_request) 3164 1
1519 for @{$self->{children}};
1520} 3165}
1521 3166
1522sub translate { 3167sub _draw {
3168 my ($self) = @_;
3169
3170 $self->{current}->draw;
3171}
3172
3173#############################################################################
3174
3175package CFClient::UI::Notebook;
3176
3177our @ISA = CFClient::UI::VBox::;
3178
3179sub new {
3180 my $class = shift;
3181
3182 my $self = $class->SUPER::new (
3183 buttonbar => (new CFClient::UI::Buttonbar),
3184 multiplexer => (new CFClient::UI::Multiplexer expand => 1),
3185 # filter => # will be put between multiplexer and $self
3186 @_,
3187 );
3188
3189 $self->{filter}->add ($self->{multiplexer}) if $self->{filter};
3190 $self->SUPER::add ($self->{buttonbar}, $self->{filter} || $self->{multiplexer});
3191
3192 $self
3193}
3194
3195sub add {
3196 my ($self, $title, $widget, $tooltip) = @_;
3197
3198 Scalar::Util::weaken $self;
3199
3200 $self->{buttonbar}->add (new CFClient::UI::Button
3201 markup => $title,
3202 tooltip => $tooltip,
3203 on_activate => sub { $self->set_current_page ($widget) },
3204 );
3205
3206 $self->{multiplexer}->add ($widget);
3207}
3208
3209sub set_current_page {
3210 my ($self, $page) = @_;
3211
3212 $self->{multiplexer}->set_current_page ($page);
3213 $self->emit (page_changed => $self->{multiplexer}{current});
3214}
3215
3216#############################################################################
3217
3218package CFClient::UI::Combobox;
3219
3220use utf8;
3221
3222our @ISA = CFClient::UI::Button::;
3223
3224sub new {
3225 my $class = shift;
3226
3227 my $self = $class->SUPER::new (
3228 options => [], # [value, title, longdesc], ...
3229 value => undef,
3230 @_,
3231 );
3232
3233 $self->_set_value ($self->{value});
3234
3235 $self
3236}
3237
3238sub invoke_button_down {
3239 my ($self, $ev) = @_;
3240
3241 my @menu_items;
3242
3243 for (@{ $self->{options} }) {
3244 my ($value, $title, $tooltip) = @$_;
3245
3246 push @menu_items, [$tooltip || $title, sub { $self->set_value ($value) }];
3247 }
3248
3249 CFClient::UI::Menu->new (items => \@menu_items)->popup ($ev);
3250}
3251
3252sub _set_value {
3253 my ($self, $value) = @_;
3254
3255 my ($item) = grep $_->[0] eq $value, @{ $self->{options} }
3256 or return;
3257
3258 $self->{value} = $item->[0];
3259 $self->set_markup ("$item->[1] ⇓");
3260 $self->set_tooltip ($item->[2]);
3261}
3262
3263sub set_value {
3264 my ($self, $value) = @_;
3265
3266 return unless $self->{value} ne $value;
3267
3268 $self->_set_value ($value);
3269 $self->emit (changed => $value);
3270}
3271
3272#############################################################################
3273
3274package CFClient::UI::Statusbox;
3275
3276our @ISA = CFClient::UI::VBox::;
3277
3278sub new {
3279 my $class = shift;
3280
3281 my $self = $class->SUPER::new (
3282 fontsize => 0.8,
3283 @_,
3284 );
3285
3286 Scalar::Util::weaken (my $this = $self);
3287
3288 $self->{timer} = Event->timer (after => 1, interval => 1, cb => sub { $this->reorder });
3289
3290 $self
3291}
3292
3293sub reorder {
3294 my ($self) = @_;
3295 my $NOW = Time::HiRes::time;
3296
3297 # freeze display when hovering over any label
3298 return if $CFClient::UI::TOOLTIP->{owner}
3299 && grep $CFClient::UI::TOOLTIP->{owner} == $_->{label},
3300 values %{ $self->{item} };
3301
3302 while (my ($k, $v) = each %{ $self->{item} }) {
3303 delete $self->{item}{$k} if $v->{timeout} < $NOW;
3304 }
3305
3306 my @widgets;
3307
3308 my @items = sort {
3309 $a->{pri} <=> $b->{pri}
3310 or $b->{id} <=> $a->{id}
3311 } values %{ $self->{item} };
3312
3313 $self->{timer}->interval (1);
3314
3315 my $count = 10 + 1;
3316 for my $item (@items) {
3317 last unless --$count;
3318
3319 my $label = $item->{label} ||= do {
3320 # TODO: doesn't handle markup well (read as: at all)
3321 my $short = $item->{count} > 1
3322 ? "<b>$item->{count} ×</b> $item->{text}"
3323 : $item->{text};
3324
3325 for ($short) {
3326 s/^\s+//;
3327 s/\s+/ /g;
3328 }
3329
3330 new CFClient::UI::Label
3331 markup => $short,
3332 tooltip => $item->{tooltip},
3333 tooltip_font => $::FONT_PROP,
3334 tooltip_width => 0.67,
3335 fontsize => $item->{fontsize} || $self->{fontsize},
3336 max_w => $::WIDTH * 0.44,
3337 fg => [@{ $item->{fg} }],
3338 can_events => 1,
3339 can_hover => 1
3340 };
3341
3342 if ((my $diff = $item->{timeout} - $NOW) < 2) {
3343 $label->{fg}[3] = ($item->{fg}[3] || 1) * $diff / 2;
3344 $label->update;
3345 $label->set_max_size (undef, $label->{req_h} * $diff)
3346 if $diff < 1;
3347 $self->{timer}->interval (1/30);
3348 } else {
3349 $label->{fg}[3] = $item->{fg}[3] || 1;
3350 }
3351
3352 push @widgets, $label;
3353 }
3354
3355 $self->clear;
3356 $self->SUPER::add (reverse @widgets);
3357}
3358
3359sub add {
3360 my ($self, $text, %arg) = @_;
3361
3362 $text =~ s/^\s+//;
3363 $text =~ s/\s+$//;
3364
3365 return unless $text;
3366
3367 my $timeout = (int time) + ((delete $arg{timeout}) || 60);
3368
3369 my $group = exists $arg{group} ? $arg{group} : ++$self->{id};
3370
3371 if (my $item = $self->{item}{$group}) {
3372 if ($item->{text} eq $text) {
3373 $item->{count}++;
3374 } else {
3375 $item->{count} = 1;
3376 $item->{text} = $item->{tooltip} = $text;
3377 }
3378 $item->{id} += 0.2;#d#
3379 $item->{timeout} = $timeout;
3380 delete $item->{label};
3381 } else {
3382 $self->{item}{$group} = {
3383 id => ++$self->{id},
3384 text => $text,
3385 timeout => $timeout,
3386 tooltip => $text,
3387 fg => [0.8, 0.8, 0.8, 0.8],
3388 pri => 0,
3389 count => 1,
3390 %arg,
3391 };
3392 }
3393
3394 $self->reorder;
3395}
3396
3397sub reconfigure {
3398 my ($self) = @_;
3399
3400 delete $_->{label}
3401 for values %{ $self->{item} || {} };
3402
3403 $self->reorder;
3404 $self->SUPER::reconfigure;
3405}
3406
3407sub destroy {
3408 my ($self) = @_;
3409
3410 $self->{timer}->cancel;
3411
3412 $self->SUPER::destroy;
3413}
3414
3415#############################################################################
3416
3417package CFClient::UI::Inventory;
3418
3419our @ISA = CFClient::UI::ScrolledWindow::;
3420
3421sub new {
3422 my $class = shift;
3423
3424 my $self = $class->SUPER::new (
3425 child => (new CFClient::UI::Table col_expand => [0, 1, 0]),
3426 @_,
3427 );
3428
3429 $self
3430}
3431
3432sub set_items {
3433 my ($self, $items) = @_;
3434
3435 $self->{child}->clear;
3436 return unless $items;
3437
3438 my @items = sort {
3439 ($a->{type} <=> $b->{type})
3440 or ($a->{name} cmp $b->{name})
3441 } @$items;
3442
3443 $self->{real_items} = \@items;
3444
3445 my $row = 0;
3446 for my $item (@items) {
3447 CFClient::Item::update_widgets $item;
3448
3449 $self->{child}->add (0, $row, $item->{face_widget});
3450 $self->{child}->add (1, $row, $item->{desc_widget});
3451 $self->{child}->add (2, $row, $item->{weight_widget});
3452
3453 $row++;
3454 }
3455}
3456
3457#############################################################################
3458
3459package CFClient::UI::BindEditor;
3460
3461our @ISA = CFClient::UI::FancyFrame::;
3462
3463sub new {
3464 my $class = shift;
3465
3466 my $self = $class->SUPER::new (binding => [], commands => [], @_);
3467
3468 $self->add (my $vb = new CFClient::UI::VBox);
3469
3470
3471 $vb->add ($self->{rec_btn} = new CFClient::UI::Button
3472 text => "start recording",
3473 tooltip => "Start/Stops recording of actions."
3474 ."All subsequent actions after the recording started will be captured."
3475 ."The actions are displayed after the record was stopped."
3476 ."To bind the action you have to click on the 'Bind' button",
3477 on_activate => sub {
3478 unless ($self->{recording}) {
3479 $self->start;
3480 } else {
3481 $self->stop;
3482 }
3483 });
3484
3485 $vb->add (new CFClient::UI::Label text => "Actions:");
3486 $vb->add ($self->{cmdbox} = new CFClient::UI::VBox);
3487
3488 $vb->add (new CFClient::UI::Label text => "Bound to: ");
3489 $vb->add (my $hb = new CFClient::UI::HBox);
3490 $hb->add ($self->{keylbl} = new CFClient::UI::Label expand => 1);
3491 $hb->add (new CFClient::UI::Button
3492 text => "bind",
3493 tooltip => "This opens a query where you have to press the key combination to bind the recorded actions",
3494 on_activate => sub {
3495 $self->ask_for_bind;
3496 });
3497
3498 $vb->add (my $hb = new CFClient::UI::HBox);
3499 $hb->add (new CFClient::UI::Button
3500 text => "ok",
3501 expand => 1,
3502 tooltip => "This closes the binding editor and saves the binding",
3503 on_activate => sub {
3504 $self->hide;
3505 $self->commit;
3506 });
3507
3508 $hb->add (new CFClient::UI::Button
3509 text => "cancel",
3510 expand => 1,
3511 tooltip => "This closes the binding editor without saving",
3512 on_activate => sub {
3513 $self->hide;
3514 $self->{binding_cancel}->()
3515 if $self->{binding_cancel};
3516 });
3517
3518 $self->update_binding_widgets;
3519
3520 $self
3521}
3522
3523sub cfg_bind {
3524 my ($self, $mod, $sym, $cmds) = @_;
3525 $::CFG->{profile}{default}{bindings}{$mod}{$sym} = $cmds;
3526 ::update_bindings ();
3527}
3528
3529sub cfg_unbind {
3530 my ($self, $mod, $sym, $cmds) = @_;
3531 delete $::CFG->{profile}{default}{bindings}{$mod}{$sym};
3532 ::update_bindings ();
3533}
3534
3535sub commit {
3536 my ($self) = @_;
3537 my ($mod, $sym, $cmds) = $self->get_binding;
3538 if ($sym != 0 && @$cmds > 0) {
3539 $::STATUSBOX->add ("Bound actions to '".CFClient::Binder::keycombo_to_name ($mod, $sym)
3540 ."'. Don't forget 'Save Config'!");
3541 $self->{binding_change}->($mod, $sym, $cmds)
3542 if $self->{binding_change};
3543 } else {
3544 $::STATUSBOX->add ("No action bound, no key or action specified!");
3545 $self->{binding_cancel}->()
3546 if $self->{binding_cancel};
3547 }
3548}
3549
3550sub start {
3551 my ($self) = @_;
3552
3553 $self->{rec_btn}->set_text ("stop recording");
3554 $self->{recording} = 1;
3555 $self->clear_command_list;
3556 $::CONN->start_record if $::CONN;
3557}
3558
3559sub stop {
3560 my ($self) = @_;
3561
3562 $self->{rec_btn}->set_text ("start recording");
3563 $self->{recording} = 0;
3564
3565 my $rec;
3566 $rec = $::CONN->stop_record if $::CONN;
3567 return unless ref $rec eq 'ARRAY';
3568 $self->set_command_list ($rec);
3569}
3570
3571
3572sub ask_for_bind_and_commit {
3573 my ($self) = @_;
3574 $self->ask_for_bind (1);
3575}
3576
3577sub ask_for_bind {
3578 my ($self, $commit, $end_cb) = @_;
3579
3580 CFClient::Binder::open_binding_dialog (sub {
3581 my ($mod, $sym) = @_;
3582 $self->{binding} = [$mod, $sym]; # XXX: how to stop that memleak?
3583 $self->update_binding_widgets;
3584 $self->commit if $commit;
3585 $end_cb->() if $end_cb;
3586 });
3587}
3588
3589# $mod and $sym are the modifiers and key symbol
3590# $cmds is a array ref of strings (the commands)
3591# $cb is the callback that is executed on OK
3592# $ccb is the callback that is executed on CANCEL and
3593# when the binding was unsuccessful on OK
3594sub set_binding {
3595 my ($self, $mod, $sym, $cmds, $cb, $ccb) = @_;
3596
3597 $self->clear_command_list;
3598 $self->{recording} = 0;
3599 $self->{rec_btn}->set_text ("start recording");
3600
3601 $self->{binding} = [$mod, $sym];
3602 $self->{commands} = $cmds;
3603
3604 $self->{binding_change} = $cb;
3605 $self->{binding_cancel} = $ccb;
3606
3607 $self->update_binding_widgets;
3608}
3609
3610# this is a shortcut method that asks for a binding
3611# and then just binds it.
3612sub do_quick_binding {
3613 my ($self, $cmds, $end_cb) = @_;
3614 $self->set_binding (undef, undef, $cmds, sub { $self->cfg_bind (@_) });
3615 $self->ask_for_bind (1, $end_cb);
3616}
3617
3618sub update_binding_widgets {
3619 my ($self) = @_;
3620 my ($mod, $sym, $cmds) = $self->get_binding;
3621 $self->{keylbl}->set_text (CFClient::Binder::keycombo_to_name ($mod, $sym));
3622 $self->set_command_list ($cmds);
3623}
3624
3625sub get_binding {
3626 my ($self) = @_;
3627 return (
3628 $self->{binding}->[0],
3629 $self->{binding}->[1],
3630 [ grep { defined $_ } @{$self->{commands}} ]
3631 );
3632}
3633
3634sub clear_command_list {
3635 my ($self) = @_;
3636 $self->{cmdbox}->clear ();
3637}
3638
3639sub set_command_list {
3640 my ($self, $cmds) = @_;
3641
3642 $self->{cmdbox}->clear ();
3643 $self->{commands} = $cmds;
3644
3645 my $idx = 0;
3646
3647 for (@$cmds) {
3648 $self->{cmdbox}->add (my $hb = new CFClient::UI::HBox);
3649
3650 my $i = $idx;
3651 $hb->add (new CFClient::UI::Label text => $_);
3652 $hb->add (new CFClient::UI::Button
3653 text => "delete",
3654 tooltip => "Deletes the action from the record",
3655 on_activate => sub {
3656 $self->{cmdbox}->remove ($hb);
3657 $cmds->[$i] = undef;
3658 });
3659
3660
3661 $idx++
3662 }
3663}
3664
3665#############################################################################
3666
3667package CFClient::UI::SpellList;
3668
3669our @ISA = CFClient::UI::Table::;
3670
3671sub new {
3672 my $class = shift;
3673
3674 my $self = $class->SUPER::new (
3675 binding => [],
3676 commands => [],
3677 @_,
3678 )
3679}
3680
3681my $TOOLTIP_ALL = "\n\n<small>Left click - ready spell\nMiddle click - invoke spell\nRight click - further options</small>";
3682
3683my @TOOLTIP_NAME = (align => -1, can_events => 1, can_hover => 1, tooltip =>
3684 "<b>Name</b>. The name of the spell.$TOOLTIP_ALL");
3685my @TOOLTIP_SKILL = (align => -1, can_events => 1, can_hover => 1, tooltip =>
3686 "<b>Skill</b>. The skill (or magic school) required to be able to attempt casting this spell.$TOOLTIP_ALL");
3687my @TOOLTIP_LVL = (align => 1, can_events => 1, can_hover => 1, tooltip =>
3688 "<b>Level</b>. Minimum level the caster needs in the associated skill to be able to attempt casting this spell.$TOOLTIP_ALL");
3689my @TOOLTIP_SP = (align => 1, can_events => 1, can_hover => 1, tooltip =>
3690 "<b>Spell points / Grace points</b>. Amount of spell or grace points used by each invocation.$TOOLTIP_ALL");
3691my @TOOLTIP_DMG = (align => 1, can_events => 1, can_hover => 1, tooltip =>
3692 "<b>Damage</b>. The amount of damage the spell deals when it hits.$TOOLTIP_ALL");
3693
3694sub rebuild_spell_list {
3695 my ($self) = @_;
3696
3697 $CFClient::UI::ROOT->on_refresh ($self => sub {
3698 $self->clear;
3699
3700 return unless $::CONN;
3701
3702 $self->add (1, 0, new CFClient::UI::Label text => "Spell Name", @TOOLTIP_NAME);
3703 $self->add (2, 0, new CFClient::UI::Label text => "Skill", @TOOLTIP_SKILL);
3704 $self->add (3, 0, new CFClient::UI::Label text => "Lvl" , @TOOLTIP_LVL);
3705 $self->add (4, 0, new CFClient::UI::Label text => "Sp/Gp", @TOOLTIP_SP);
3706 $self->add (5, 0, new CFClient::UI::Label text => "Dmg" , @TOOLTIP_DMG);
3707
3708 my $row = 0;
3709
3710 for (sort { $a cmp $b } keys %{ $self->{spell} }) {
3711 my $spell = $self->{spell}{$_};
3712
3713 $row++;
3714
3715 my $spell_cb = sub {
3716 my ($widget, $ev) = @_;
3717
3718 if ($ev->{button} == 1) {
3719 $::CONN->user_send ("cast $spell->{name}");
3720 } elsif ($ev->{button} == 2) {
3721 $::CONN->user_send ("invoke $spell->{name}");
3722 } elsif ($ev->{button} == 3) {
3723 (new CFClient::UI::Menu
3724 items => [
3725 ["bind <i>cast $spell->{name}</i> to a key" => sub { $::BIND_EDITOR->do_quick_binding (["cast $spell->{name}"]) }],
3726 ["bind <i>invoke $spell->{name}</i> to a key" => sub { $::BIND_EDITOR->do_quick_binding (["invoke $spell->{name}"]) }],
3727 ],
3728 )->popup ($ev);
3729 } else {
3730 return 0;
3731 }
3732
3733 1
3734 };
3735
3736 my $tooltip = "$spell->{message}$TOOLTIP_ALL";
3737
3738 #TODO: add path info to tooltip
3739 #$self->add (6, $row, new CFClient::UI::Label text => $spell->{path});
3740
3741 $self->add (0, $row, new CFClient::UI::Face
3742 face => $spell->{face},
3743 can_hover => 1,
3744 can_events => 1,
3745 tooltip => $tooltip,
3746 on_button_down => $spell_cb,
3747 );
3748
3749 $self->add (1, $row, new CFClient::UI::Label
3750 expand => 1,
3751 text => $spell->{name},
3752 can_hover => 1,
3753 can_events => 1,
3754 tooltip => $tooltip,
3755 on_button_down => $spell_cb,
3756 );
3757
3758 $self->add (2, $row, new CFClient::UI::Label text => $::CONN->{skill_info}{$spell->{skill}}, @TOOLTIP_SKILL);
3759 $self->add (3, $row, new CFClient::UI::Label text => $spell->{level}, @TOOLTIP_LVL);
3760 $self->add (4, $row, new CFClient::UI::Label text => $spell->{mana} || $spell->{grace}, @TOOLTIP_SP);
3761 $self->add (5, $row, new CFClient::UI::Label text => $spell->{damage}, @TOOLTIP_DMG);
3762 }
3763 });
3764}
3765
3766sub add_spell {
3767 my ($self, $spell) = @_;
3768
3769 $self->{spell}->{$spell->{name}} = $spell;
3770 $self->rebuild_spell_list;
3771}
3772
3773sub remove_spell {
3774 my ($self, $spell) = @_;
3775
3776 delete $self->{spell}->{$spell->{name}};
3777 $self->rebuild_spell_list;
3778}
3779
3780sub clear_spells {
3781 my ($self) = @_;
3782
3783 $self->{spell} = {};
3784 $self->rebuild_spell_list;
3785}
3786
3787#############################################################################
3788
3789package CFClient::UI::Root;
3790
3791our @ISA = CFClient::UI::Container::;
3792
3793use List::Util qw(min max);
3794
3795use CFClient::OpenGL;
3796
3797sub new {
3798 my $class = shift;
3799
3800 my $self = $class->SUPER::new (
3801 visible => 1,
3802 @_,
3803 );
3804
3805 Scalar::Util::weaken ($self->{root} = $self);
3806
3807 $self
3808}
3809
3810sub size_request {
3811 my ($self) = @_;
3812
3813 ($self->{w}, $self->{h})
3814}
3815
3816sub _to_pixel {
3817 my ($coord, $size, $max) = @_;
3818
3819 $coord =
3820 $coord eq "center" ? ($max - $size) * 0.5
3821 : $coord eq "max" ? $max
3822 : $coord;
3823
3824 $coord = 0 if $coord < 0;
3825 $coord = $max - $size if $coord > $max - $size;
3826
3827 int $coord + 0.5
3828}
3829
3830sub invoke_size_allocate {
3831 my ($self, $w, $h) = @_;
3832
3833 for my $child ($self->children) {
3834 my ($X, $Y, $W, $H) = @$child{qw(x y req_w req_h)};
3835
3836 $X = $child->{force_x} if exists $child->{force_x};
3837 $Y = $child->{force_y} if exists $child->{force_y};
3838
3839 $X = _to_pixel $X, $W, $self->{w};
3840 $Y = _to_pixel $Y, $H, $self->{h};
3841
3842 $child->configure ($X, $Y, $W, $H);
3843 }
3844
3845 1
3846}
3847
3848sub coord2local {
1523 my ($self, $x, $y) = @_; 3849 my ($self, $x, $y) = @_;
1524 3850
1525 ($x, $y) 3851 ($x, $y)
1526} 3852}
1527 3853
3854sub coord2global {
3855 my ($self, $x, $y) = @_;
3856
3857 ($x, $y)
3858}
3859
1528sub update { 3860sub update {
1529 my ($self) = @_; 3861 my ($self) = @_;
1530 3862
1531 $self->size_allocate (0, 0, $::WIDTH, $::HEIGHT); 3863 $::WANT_REFRESH++;
1532 ::refresh ();
1533} 3864}
1534 3865
1535sub add { 3866sub add {
1536 my ($self, $widget) = @_; 3867 my ($self, @children) = @_;
1537 3868
3869 $_->{is_toplevel} = 1
3870 for @children;
3871
1538 $self->SUPER::add ($widget); 3872 $self->SUPER::add (@children);
1539
1540 $widget->size_allocate ($widget->{x}, $widget->{y}, $widget->size_request);
1541} 3873}
1542 3874
3875sub remove {
3876 my ($self, @children) = @_;
3877
3878 $self->SUPER::remove (@children);
3879
3880 delete $self->{is_toplevel}
3881 for @children;
3882
3883 while (@children) {
3884 my $w = pop @children;
3885 push @children, $w->children;
3886 $w->set_invisible;
3887 }
3888}
3889
3890sub on_refresh {
3891 my ($self, $id, $cb) = @_;
3892
3893 $self->{refresh_hook}{$id} = $cb;
3894}
3895
3896sub on_post_alloc {
3897 my ($self, $id, $cb) = @_;
3898
3899 $self->{post_alloc_hook}{$id} = $cb;
3900}
3901
1543sub draw { 3902sub draw {
1544 my ($self) = @_; 3903 my ($self) = @_;
3904
3905 while ($self->{refresh_hook}) {
3906 $_->()
3907 for values %{delete $self->{refresh_hook}};
3908 }
3909
3910 if ($self->{realloc}) {
3911 my %queue;
3912 my @queue;
3913 my $widget;
3914
3915 outer:
3916 while () {
3917 if (my $realloc = delete $self->{realloc}) {
3918 for $widget (values %$realloc) {
3919 $widget->{visible} or next; # do not resize invisible widgets
3920
3921 $queue{$widget+0}++ and next; # duplicates are common
3922
3923 push @{ $queue[$widget->{visible}] }, $widget;
3924 }
3925 }
3926
3927 while () {
3928 @queue or last outer;
3929
3930 $widget = pop @{ $queue[-1] || [] }
3931 and last;
3932
3933 pop @queue;
3934 }
3935
3936 delete $queue{$widget+0};
3937
3938 my ($w, $h) = $widget->size_request;
3939
3940 $w = max $widget->{min_w}, $w + $widget->{padding_x} * 2;
3941 $h = max $widget->{min_h}, $h + $widget->{padding_y} * 2;
3942
3943 $w = min $widget->{max_w}, $w if exists $widget->{max_w};
3944 $h = min $widget->{max_h}, $h if exists $widget->{max_h};
3945
3946 $w = $widget->{force_w} if exists $widget->{force_w};
3947 $h = $widget->{force_h} if exists $widget->{force_h};
3948
3949 if ($widget->{req_w} != $w || $widget->{req_h} != $h
3950 || delete $widget->{force_realloc}) {
3951 $widget->{req_w} = $w;
3952 $widget->{req_h} = $h;
3953
3954 $self->{size_alloc}{$widget+0} = $widget;
3955
3956 if (my $parent = $widget->{parent}) {
3957 $self->{realloc}{$parent+0} = $parent
3958 unless $queue{$parent+0};
3959
3960 $parent->{force_size_alloc} = 1;
3961 $self->{size_alloc}{$parent+0} = $parent;
3962 }
3963 }
3964
3965 delete $self->{realloc}{$widget+0};
3966 }
3967 }
3968
3969 while (my $size_alloc = delete $self->{size_alloc}) {
3970 my @queue = sort { $b->{visible} <=> $a->{visible} }
3971 values %$size_alloc;
3972
3973 while () {
3974 my $widget = pop @queue || last;
3975
3976 my ($w, $h) = @$widget{qw(alloc_w alloc_h)};
3977
3978 $w = 0 if $w < 0;
3979 $h = 0 if $h < 0;
3980
3981 $w = int $w + 0.5;
3982 $h = int $h + 0.5;
3983
3984 if ($widget->{w} != $w || $widget->{h} != $h || delete $widget->{force_size_alloc}) {
3985 $widget->{old_w} = $widget->{w};
3986 $widget->{old_h} = $widget->{h};
3987
3988 $widget->{w} = $w;
3989 $widget->{h} = $h;
3990
3991 $widget->emit (size_allocate => $w, $h);
3992 }
3993 }
3994 }
3995
3996 while ($self->{post_alloc_hook}) {
3997 $_->()
3998 for values %{delete $self->{post_alloc_hook}};
3999 }
4000
4001
4002 glViewport 0, 0, $::WIDTH, $::HEIGHT;
4003 glClearColor +($::CFG->{fow_intensity}) x 3, 1;
4004 glClear GL_COLOR_BUFFER_BIT;
4005
4006 glMatrixMode GL_PROJECTION;
4007 glLoadIdentity;
4008 glOrtho 0, $::WIDTH, $::HEIGHT, 0, -10000, 10000;
4009 glMatrixMode GL_MODELVIEW;
4010 glLoadIdentity;
4011
4012 {
4013 package CFClient::UI::Base;
4014
4015 ($draw_x, $draw_y, $draw_w, $draw_h) =
4016 (0, 0, $self->{w}, $self->{h});
4017 }
1545 4018
1546 $self->_draw; 4019 $self->_draw;
1547} 4020}
1548 4021
1549############################################################################# 4022#############################################################################
1550 4023
1551package CFClient::UI; 4024package CFClient::UI;
1552 4025
1553$TOPLEVEL = new CFClient::UI::Toplevel; 4026$ROOT = new CFClient::UI::Root;
4027$TOOLTIP = new CFClient::UI::Tooltip z => 900;
1554 4028
15551 40291
1556 4030

Diff Legend

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