App/Chart/Gtk2/Graph.pm

filter: Statementstmt 81.8% 9 / 11 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 4 / 4 Podpod n/a totaltotal 86.6% 13 / 15 CC 1 SCAR 0.7
CC
1
Cov
82%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.1
« App/Chart/Gtk2/DeleteSymlistDialog.pm ↑ Summary App/Chart/Gtk2/HAxis.pm »
1 # Graph widget.
2  
3 # Copyright 2007, 2008, 2009, 2010, 2011, 2013, 2018 Kevin Ryde
4  
5 # This file is part of Chart.
6 #
7 # Chart is free software; you can redistribute it and/or modify it under the
8 # terms of the GNU General Public License as published by the Free Software
9 # Foundation; either version 3, or (at your option) any later version.
10 #
11 # Chart is distributed in the hope that it will be useful, but WITHOUT ANY
12 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
14 # details.
15 #
16 # You should have received a copy of the GNU General Public License along
17 # with Chart. If not, see <http://www.gnu.org/licenses/>.
18  
19 package App::Chart::Gtk2::Graph;
20 1 ▶use 5.010;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 1 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
22 1 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 0 ▶use Gtk2 1.220;
Subroutine BEGIN: called CC=1 SCAR=2.6
24 use List::Util qw(min max);
25 use List::MoreUtils 0.24; # version 0.24 for bug fixes
26 use Module::Load;
27 use POSIX ();
28 use Set::IntSpan::Fast 1.10; # 1.10 for contains_all_range()
29 use Locale::Messages;
30 use Locale::TextDomain ('App-Chart');
31  
32 # alerts and lines last since they're xor based, umm, maybe
33 use Module::Pluggable require => 1;
34 my @plugins = sort __PACKAGE__->plugins;
35 ### Graph plugins: @plugins
36  
37 use Glib::Ex::SignalIds;
38 use Gtk2::Ex::AdjustmentBits 43; # v.43 for set_maybe()
39 use Gtk2::Ex::GdkBits 23; # v.23 for window_clear_region()
40  
41 use App::Chart::Glib::Ex::MoreUtils;
42 use App::Chart::Gtk2::GUI;
43 use App::Chart::Series;
44 use App::Chart::Gtk2::Graph::Plugin::Latest;
45  
46 # uncomment this to run the ### lines
47 # use Smart::Comments;
48  
49 use Glib::Object::Subclass
50 'Gtk2::DrawingArea',
51 signals => { button_press_event => \&_do_button_press,
52 expose_event => \&_do_expose_event,
53 # size_allocate => \&_do_size_allocate,
54 scroll_event => \&_do_scroll_event,
55  
56 # GtkToolbar in gtk 2.14.7 has a bug in its finalize
57 # provoking a ref_count>0 log error if anyone is hooked onto
58 # 'parent-set', even if in an unrelated class, so use notify
59 # instead
60 #
61 # parent_set => \&_do_parent_set,
62 #
63 # notify => \&_do_notify,
64  
65 set_scroll_adjustments =>
66 { param_types => ['Gtk2::Adjustment',
67 'Gtk2::Adjustment'],
68 return_type => undef,
69 class_closure => \&_do_set_scroll_adjustments },
70  
71 start_drag => { param_types => ['Glib::Int'],
72 return_type => undef,
73 class_closure => \&_do_start_drag,
74 flags => ['run-first','action'] },
75 start_lasso => { param_types => ['Glib::Int'],
76 return_type => undef,
77 class_closure => \&_do_start_lasso,
78 flags => ['run-first','action'] },
79 start_annotation_drag =>
80 { param_types => ['Glib::Int'],
81 return_type => undef,
82 class_closure => \&_do_start_annotation_drag,
83 flags => ['run-first','action'] },
84  
85 },
86 properties => [Glib::ParamSpec->object
87 ('hadjustment',
88 Locale::Messages::dgettext('gtk20-properties',
89 'Horizontal adjustment'), # per Gtk2::ScrolledWindow
90 'Blurb',
91 'Gtk2::Adjustment',
92 Glib::G_PARAM_READWRITE),
93  
94 Glib::ParamSpec->object
95 ('vadjustment',
96 Locale::Messages::dgettext('gtk20-properties',
97 'Vertical adjustment'), # per Gtk2::ScrolledWindow
98 'Blurb',
99 'Gtk2::Adjustment',
100 Glib::G_PARAM_READWRITE),
101  
102 Glib::ParamSpec->scalar
103 ('series-list',
104 'Series list',
105 'Arrayref of perl App::Chart::Series objects.',
106 Glib::G_PARAM_READWRITE),
107 ];
108 App::Chart::Gtk2::GUI::chart_style_class (__PACKAGE__);
109  
110 # priority level "gtk" treating this as widget level default, for overriding
111 # by application or user RC
112 Gtk2::Rc->parse_string (<<'HERE');
113 binding "App__Chart__Gtk2__Graph_keys" {
114 bind "<Shift>Pointer_Button1" { "start_lasso" (1) }
115 bind "Pointer_Button1" { "start_drag" (1) }
116 bind "Pointer_Button2" { "start_annotation_drag" (2) }
117 }
118 class "App__Chart__Gtk2__Graph" binding:gtk "App__Chart__Gtk2__Graph_keys"
119 HERE
120  
121  
122 #------------------------------------------------------------------------------
123  
124 sub INIT_INSTANCE {
125 my ($self) = @_;
126 $self->{'series_list'} = [];
127  
128 $self->set_double_buffered (0);
129 $self->set_app_paintable (1);
130  
131 $self->add_events (['button-press-mask',
132 'button-motion-mask',
133 'button-release-mask']);
134 $self->{'waiting_initial_allocate'} = 1;
135 }
136  
137 sub SET_PROPERTY {
138 my ($self, $pspec, $newval) = @_;
139 my $pname = $pspec->get_name;
140 ### Graph SET_PROPERTY(): $pname
141 my $oldval = $self->{$pname};
142 $self->{$pname} = $newval; # per default GET_PROPERTY
143  
144 if ($pname eq 'hadjustment') {
145 my $hadj = $newval;
146 my $ref_weak_self = App::Chart::Glib::Ex::MoreUtils::ref_weak($self);
147 $self->{'hadjustment_ids'} = $hadj && Glib::Ex::SignalIds->new
148 ($hadj,
149 $hadj->signal_connect(value_changed => \&_do_hadj_value_changed,
150 $ref_weak_self),
151 $hadj->signal_connect(changed => \&_do_hadj_other_changed,
152 $ref_weak_self));
153  
154 } elsif ($pname eq 'vadjustment') {
155 my $vadj = $newval;
156 my $ref_weak_self = App::Chart::Glib::Ex::MoreUtils::ref_weak($self);
157 $self->{'vadjustment_ids'} = $vadj && Glib::Ex::SignalIds->new
158 ($vadj,
159 $vadj->signal_connect (value_changed => \&_do_vadj_changed,
160 $ref_weak_self),
161 $vadj->signal_connect (changed => \&_do_vadj_changed,
162 $ref_weak_self));
163  
164 } elsif ($pname eq 'series_list') {
165 # initial page size and position when going from empty to non-empty
166 ### Graph set series_list, count: scalar(@$newval)
167 if (@$newval && ! @$oldval) {
168 $self->initial_scale;
169 }
170 $self->queue_draw;
171 }
172 }
173  
174 # sub _do_parent_set {
175 # my ($self, $parent) = @_;
176 # if (! $parent) {
177 # $self->{'waiting_initial_allocate'} = 1;
178 # }
179 # $self->signal_chain_from_overridden ($parent);
180 # }
181  
182 # # 'size-allocate' class closure
183 # sub _do_size_allocate {
184 # my ($self, $alloc) = @_;
185 # ### Graph _do_size_allocate(): $alloc->width."x".$alloc->height
186 # $self->signal_chain_from_overridden($alloc);
187 #
188 # # after superclass has set $alloc into $self->allocation
189 # if ($alloc->width != 1 && $alloc->height != 1) {
190 # if (delete $self->{'waiting_initial_allocate'}) {
191 # _initial_scale ($self);
192 # }
193 # }
194 # }
195 #
196 # sub _do_notify {
197 # my ($self, $pspec) = @_;
198 # if ($pspec->get_name eq 'parent') {
199 # if (! $self->get_parent) {
200 # $self->{'waiting_initial_allocate'} = 1;
201 # }
202 # }
203 # return shift->signal_chain_from_overridden(@_);
204 # }
205  
206 sub initial_scale {
207 my ($self) = @_;
208 $self->{'initial_scale'} = 1;
209 }
210  
211 sub _initial_scale {
212 my ($self) = @_;
213 ### Graph _initial_scale(): "$self"
214  
215 # {
216 # my $alloc = $self->allocation;
217 # ### Graph _initial_scale() size: $alloc->width."x".$alloc->height
218 # return if ($alloc->width == 1 || $alloc->height == 1);
219 # }
220  
221 my $series_list = $self->{'series_list'};
222 my $series = $series_list->[0] || do {
223 ### no series...
224 return;
225 };
226  
227 my $hadj = $self->{'hadjustment'};
228 my $vadj = $self->{'vadjustment'};
229 my ($lo, $hi) = $hadj->value_range_inc;
230 ### hadj: "$lo $hi, on ".ref($series)
231  
232 if (my ($p_lo, $p_hi) = $series->initial_range ($lo, $hi)) {
233 ### series initial_range(): ($p_lo//'undef')." to ".($p_hi//'undef')." from $lo to $hi on ".ref($series)
234 ($p_lo, $p_hi) = stretch_range ($p_lo, $p_hi);
235 ### stretched to: ($p_lo//'undef')." to ".($p_hi//'undef')
236 if (defined $p_lo) {
237 $vadj->set_page_range ($p_lo, $p_hi);
238 }
239 $self->queue_draw;
240 }
241 # expanding on initial ...
242 $self->{'vrange_span'} = undef;
243 update_v_range ($self);
244 }
245  
246 # 'set-scroll-adjustments' class closure
247 sub _do_set_scroll_adjustments {
248 my ($self, $hadj, $vadj) = @_;
249 $self->set (hadjustment => $hadj,
250 vadjustment => $vadj);
251 }
252  
253 sub scale_x_step {
254 my ($self) = @_;
255 return $self->{'hadjustment'}->get_pixel_per_value;
256 }
257  
258 sub scale_x {
259 my ($self, $t) = @_;
260 return $self->{'hadjustment'}->value_to_pixel ($t);
261 }
262  
263 sub scale_x_proc {
264 my ($self) = @_;
265 return $self->{'hadjustment'}->value_to_pixel_proc;
266 }
267  
268 sub x_to_date {
269 my ($self, $x) = @_;
270 return POSIX::floor ($self->{'hadjustment'}->pixel_to_value ($x));
271 }
272  
273 sub scale_y {
274 my ($self, $y) = @_;
275 return $self->{'vadjustment'}->value_to_pixel ($y);
276 }
277  
278 sub scale_y_proc {
279 my ($self) = @_;
280 return $self->{'vadjustment'}->value_to_pixel_proc;
281  
282 # my $price_lo = $self->{'vadjustment'}->get_value;
283 # my $price_height = $self->{'vadjustment'}->page_size;
284 # if ($price_height == 0) { $price_height = 1; }
285 # my ($win_width, $win_height) = $self->window->get_size();
286 # my $factor = $win_height / $price_height;
287 #
288 # return sub {
289 # my ($price) = @_;
290 # return $win_height - $factor * ($price - $price_lo);
291 # };
292 }
293  
294 sub y_to_value {
295 my ($self, $y) = @_;
296 return $self->{'vadjustment'}->pixel_to_value ($y);
297  
298 # my $win_height = $self->allocation->height;
299 # my $vadj = $self->{'vadjustment'};
300 # my $factor = $vadj->value
301 # + ($win_height - $y) * $vadj->page_size / $win_height;
302 }
303  
304 sub draw_t_range {
305 my ($self) = @_;
306 my $hadj = $self->{'hadjustment'} || return (0, -1);
307 my ($lo, $hi) = $hadj->value_range_inc;
308 $lo = max (0, $lo);
309 return ($lo, $hi);
310 }
311  
312 # 'expose' class closure
313 sub _do_expose_event {
314 my ($self, $event) = @_;
315 ### Graph _do_expose_event() ...
316  
317 if (delete $self->{'initial_scale'}) {
318 _initial_scale ($self);
319 $self->queue_draw;
320 return Gtk2::EVENT_PROPAGATE;
321 }
322  
323 my $series_list = $self->get('series_list');
324 if (! $self->{'vadjustment'}) { return Gtk2::EVENT_PROPAGATE; }
325  
326 my $region = $event->region;
327 Gtk2::Ex::GdkBits::window_clear_region ($self->window, $region);
328  
329 if (! @$series_list) {
330 App::Chart::Gtk2::GUI::draw_text_centred
331 ($self, $event, __('Use File/Open to open or add a symbol'));
332  
333 } else {
334 _draw_region ($self, $region);
335 }
336 ### Graph _do_expose_event() end ...
337 return Gtk2::EVENT_PROPAGATE;
338 }
339  
340 sub _draw_region {
341 my ($self, $region) = @_;
342 ### Graph _draw_region() ...
343  
344 my $series_list = $self->get('series_list');
345 my $any = 0;
346 foreach my $series (@$series_list) {
347 ### Graph draw_region linestyle: $series->linestyle_class
348 my $class = $series->linestyle_class // next;
349 Module::Load::load ($class);
350 $any |= $class->draw ($self, $series, $region);
351 }
352 if (! $any) {
353 ### Graph _draw_region() no data ...
354 App::Chart::Gtk2::GUI::draw_text_centred ($self, $region, __('no data'));
355 }
356  
357 foreach my $class (@plugins) {
358 $class->draw ($self, $region);
359 }
360 ### Graph _draw_region() end ...
361 }
362  
363 # 'changed' and 'value-changed' signals on vadjustment
364 sub _do_vadj_changed {
365 my ($adj, $ref_weak_self) = @_;
366 my $self = $$ref_weak_self || return;
367 ### Graph vadj changed, redraw: "value=@{[$adj->value]} upper=@{[$adj->upper]} lower=@{[$adj->lower]}"
368 # if ($adj->value < 0) {
369 # require Devel::StackTrace;
370 # my $trace = Devel::StackTrace->new;
371 # print $trace->as_string; # like carp
372 # }
373  
374 $self->queue_draw;
375 }
376  
377 # Expand $adj so its lower/upper covers all of @values.
378 #
379 # If lower==upper==page_size==0 in the existing $adj settings it's treated
380 # as uninitialized and that 0 lower/upper is ignored, just @values is used.
381 #
382 # undefs in @values are ignored, and if all are undef then $adj is not
383 # changed.
384 #
385 sub adjustment_expand {
386 my ($adj, @values) = @_;
387 @values = grep {defined} @values;
388 ### Graph adjustment_expand(): join(' ',@values)
389 if (! @values) { return; }
390  
391 my ($new_lower, $new_upper) = List::MoreUtils::minmax (@values);
392 ### base: " new_lower $new_lower new_upper $new_upper"
393 ($new_lower, $new_upper) = stretch_range ($new_lower, $new_upper);
394 ### stretch: "new_lower $new_lower new_upper $new_upper"
395  
396 my $old_lower = $adj->lower;
397 my $old_upper = $adj->upper;
398 ### old: " old_lower $old_lower old_upper $old_upper old_page ".$adj->page_size
399 if (! ($old_lower == 0 && $old_upper == 0 && $adj->page_size == 0)) {
400 ($new_lower, $new_upper) = List::MoreUtils::minmax
401 ($new_lower, $new_upper, $old_lower, $old_upper);
402 }
403  
404 ### new: " new_lower $new_lower new_upper $new_upper"
405 Gtk2::Ex::AdjustmentBits::set_maybe
406 ($adj,
407 lower => $new_lower,
408 upper => $new_upper);
409 }
410  
411 sub stretch_range {
412 my ($lo, $hi) = @_;
413 my $extra = ($hi - $lo) * 0.1;
414 if ($lo < 0) {
415 $lo -= $extra;
416 } else {
417 $lo = max ($lo - $extra, $lo * 0.5);
418 }
419 $hi += $extra;
420 return ($lo, $hi);
421 }
422  
423 sub update_v_range {
424 my ($self) = @_;
425 my $vadj = $self->{'vadjustment'} || return;
426  
427 my ($lo, $hi) = $self->draw_t_range;
428 my $vrange_span = ($self->{'vrange_span'} ||= do {
429 require Set::IntSpan::Fast;
430 Set::IntSpan::Fast->new
431 });
432 if ($vrange_span->contains_all_range ($lo, $hi)) { return; }
433  
434 ### Graph update_v_range for: "$lo to $hi"
435 my $series_list = $self->{'series_list'};
436 adjustment_expand ($vadj,
437 (map {
438 $_->vrange ($self, $series_list);
439 } @plugins),
440 (map {
441 _series_v_range($_, $lo, $hi)
442 } @$series_list));
443 $vrange_span->add_range ($lo, $hi);
444 }
445 sub _series_v_range {
446 my ($series, $lo, $hi) = @_;
447 my @ret;
448 my $min = $series->minimum; push @ret, $min;
449 my $max = $series->maximum; push @ret, $max;
450 $series->fill ($lo, $hi);
451  
452 foreach my $p ($series->filled_low, $series->filled_high) {
453 $p // next;
454 push @ret, $p;
455 # foreach my $w ($p * 1.1, $p / 1.1) {
456 # if (defined $min) { $w = max ($w, $min); }
457 # if (defined $max) { $w = min ($w, $max); }
458 # push @ret, $w;
459 # }
460 }
461 return @ret;
462 }
463  
464 # 'value-changed' signal on hadjustment
465 sub _do_hadj_value_changed {
466 my ($adj, $ref_weak_self) = @_;
467 my $self = $$ref_weak_self || return;
468 ### Graph hadj changed, v_range and redraw: "value=@{[$adj->value]} upper=@{[$adj->upper]} lower=@{[$adj->lower]}"
469  
470 update_v_range ($self);
471 $self->queue_draw;
472 }
473  
474 # 'changed' signal on hadjustment
475 *_do_hadj_other_changed = \&_do_hadj_value_changed;
476 # my ($adj, $ref_weak_self) = @_;
477 # my $self = $$ref_weak_self || return;
478 # update_v_range ($self);
479 # $self->queue_draw;
480 # }
481  
482 # 'button-press-event' class closure
483 sub _do_button_press {
484 my ($self, $event) = @_;
485 ### Graph _do_button_press(): $event->button
486 require App::Chart::Gtk2::Ex::BindingBits;
487 App::Chart::Gtk2::Ex::BindingBits::activate_button_event
488 ('App__Chart__Gtk2__Graph_keys', $event, $self);
489 return shift->signal_chain_from_overridden(@_);
490 }
491  
492 sub centre {
493 my ($self) = @_;
494 ### Graph centre()
495 my $vadj = $self->{'vadjustment'};
496 my $page = $vadj->page_size * 0.9; # gap at ends
497 my $series_list = $self->{'series_list'};
498  
499 my ($lo, $hi) = $self->draw_t_range;
500 ### Graph centre() on drawn: "$lo $hi (of ".$self->{'hadjustment'}->lower." ".$self->{'hadjustment'}->upper.")"
501  
502 my ($l, $h);
503 my $accumulate = sub {
504 my ($value) = @_;
505 ### accumulate: $value
506 if (! defined $value) { return 1; }
507 if (! defined $l) { $l = $h = $value; return 1; }
508  
509 my $new_l = min ($l, $value);
510 my $new_h = max ($h, $value);
511 my $new_page = $new_h - $new_l;
512 if ($new_page <= $page) {
513 $l = $new_l;
514 $h = $new_h;
515 return 1;
516 }
517  
518 if ($new_l < $l) {
519 $l = $h - $page;
520 } else {
521 $h = $l + $page;
522 }
523 return 0;
524 };
525  
526 if (my $series = $series_list->[0]) {
527 if (defined (my $symbol = $series->symbol)) {
528 my ($latest_lo,$latest_hi)
529 = App::Chart::Gtk2::Graph::Plugin::Latest->hrange ($self, $series_list);
530 ### latest hrange: $latest_lo,$latest_hi
531 if (defined $lo
532 && App::Chart::overlap_inclusive_p ($lo,$hi,
533 $latest_lo,$latest_hi)) {
534 my $latest = App::Chart::Latest->get($symbol);
535 if ($series->isa('App::Chart::Series::Derived::Volume')) {
536 $accumulate->($latest->{'volume'});
537 } else {
538 $accumulate->($latest->{'last'})
539 and $accumulate->($latest->{'bid'})
540 and $accumulate->($latest->{'offer'})
541 and $accumulate->($latest->{'high'})
542 and $accumulate->($latest->{'low'});
543 }
544 }
545 }
546 }
547  
548 my @arrays;
549 foreach my $series (@$series_list) {
550 $series->fill ($lo, $hi);
551 my $values = $series->values_array;
552 push @arrays, $values;
553 if (my $highs = $series->array('highs')) {
554 if ($highs != $values) { push @arrays, $highs; }
555 }
556 if (my $lows = $series->array('lows')) {
557 if ($lows != $values) { push @arrays, $lows; }
558 }
559 }
560  
561 OUTER: for (my $i = $hi; $i >= $lo; $i--) {
562 foreach my $array (@arrays) {
563 $accumulate->($array->[$i])
564 or last OUTER;
565 }
566 }
567 if (! defined $l) { return; }
568 ### decided: "$l to $h"
569  
570 my $extra = $page - ($h - $l);
571 $l -= $extra / 2;
572 ### expand to: "low $l on page $page"
573 $vadj->set_value ($l);
574 }
575  
576  
577 #------------------------------------------------------------------------------
578 # scrolling
579  
580 # 'scroll-event' class closure
581 sub _do_scroll_event {
582 my ($self, $event) = @_;
583 ### Graph _do_scroll_event(): "$self->{'hadjustment'}, $self->{'vadjustment'}"
584  
585 my $direction = $event->direction;
586 if ($direction eq 'up') { $self->{'vadjustment'}->scroll_step(1); }
587 elsif ($direction eq 'down') { $self->{'vadjustment'}->scroll_step(-1); }
588 elsif ($direction eq 'left') { $self->{'hadjustment'}->scroll_step(1); }
589 elsif ($direction eq 'right') { $self->{'hadjustment'}->scroll_step(-1); }
590  
591 return $self->signal_chain_from_overridden ($event);
592 }
593  
594  
595 #------------------------------------------------------------------------------
596 # action signal handlers
597  
598 sub _do_start_drag {
599 my ($self, $button) = @_;
600 my $hadj = $self->{'hadjustment'} || return; # only when adj set
601 my $vadj = $self->{'vadjustment'} || return; # only when adj set
602 my $dragger = ($self->{'dragger'} ||= do {
603 require Gtk2::Ex::Dragger;
604 Gtk2::Ex::Dragger->new (widget => $self,
605 hadjustment => $hadj,
606 vadjustment => $vadj,
607 vinverted => 1,
608 confine => 1,
609 cursor => 'fleur')
610 });
611 $dragger->start (Gtk2->get_current_event);
612 }
613  
614 sub _do_start_lasso {
615 my ($self, $button) = @_;
616 my $lasso = ($self->{'lasso'} ||= do {
617 require Gtk2::Ex::Lasso;
618 my $l = Gtk2::Ex::Lasso->new (widget => $self);
619 $l->signal_connect (ended => \&_do_lasso_ended);
620 $l
621 });
622 $lasso->start (Gtk2->get_current_event);
623 }
624 sub _do_lasso_ended {
625 my ($lasso, $x1,$y1, $x2,$y2) = @_;
626 my $self = $lasso->get('widget') || return;
627  
628 my $hadj = $self->{'hadjustment'};
629 my $t1 = $self->x_to_date ($x1);
630 my $t2 = $self->x_to_date ($x2);
631 $hadj->set_value_range (min($t1,$t2), max($t1,$t2));
632  
633 my $vadj = $self->{'vadjustment'};
634 my $p1 = $self->y_to_value ($y1);
635 my $p2 = $self->y_to_value ($y2);
636 $vadj->set_value_range (min($p1,$p2), max($p1,$p2));
637 }
638  
639 sub _do_start_annotation_drag {
640 my ($self, $button) = @_;
641 require App::Chart::Gtk2::AnnDrag;
642 App::Chart::Gtk2::AnnDrag::start ($self, Gtk2->get_current_event);
643 }
644  
645  
646 1;
647 __END__
« App/Chart/Gtk2/DeleteSymlistDialog.pm ↑ Summary App/Chart/Gtk2/HAxis.pm »