| 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__ | ||