expand results from the CPAN

expand

App-Chart

view release on metacpan or search on metacpan

lib/App/Chart/Gtk2/Graph.pm view on Meta::CPAN


# # 'size-allocate' class closure
# sub _do_size_allocate {
#   my ($self, $alloc) = @_;
#   ### Graph _do_size_allocate(): $alloc->width."x".$alloc->height
#   $self->signal_chain_from_overridden($alloc);
# 
#   # after superclass has set $alloc into $self->allocation
#   if ($alloc->width != 1 && $alloc->height != 1) {
#     if (delete $self->{'waiting_initial_allocate'}) {
#       _initial_scale ($self);
#     }
#   }
# }
# 
# sub _do_notify {
#   my ($self, $pspec) = @_;
#   if ($pspec->get_name eq 'parent') {
#     if (! $self->get_parent) {
#       $self->{'waiting_initial_allocate'} = 1;
#     }
#   }
#   return shift->signal_chain_from_overridden(@_);
# }

sub initial_scale {
  my ($self) = @_;
  $self->{'initial_scale'} = 1;
}

sub _initial_scale {
  my ($self) = @_;
  ### Graph _initial_scale(): "$self"

#   {
#     my $alloc = $self->allocation;
#     ### Graph _initial_scale() size: $alloc->width."x".$alloc->height
#     return if ($alloc->width == 1 || $alloc->height == 1);
#   }

  my $series_list = $self->{'series_list'};
  my $series = $series_list->[0] || do {
    ### no series...
    return;
  };

  my $hadj = $self->{'hadjustment'};
  my $vadj = $self->{'vadjustment'};
  my ($lo, $hi) = $hadj->value_range_inc;
  ### hadj: "$lo $hi, on ".ref($series)

  if (my ($p_lo, $p_hi) = $series->initial_range ($lo, $hi)) {
    ### series initial_range(): ($p_lo//'undef')." to ".($p_hi//'undef')." from $lo to $hi on ".ref($series)
    ($p_lo, $p_hi) = stretch_range ($p_lo, $p_hi);
    ### stretched to: ($p_lo//'undef')." to ".($p_hi//'undef')
    if (defined $p_lo) {
      $vadj->set_page_range ($p_lo, $p_hi);
    }
    $self->queue_draw;
  }
  # expanding on initial ...
  $self->{'vrange_span'} = undef;
  update_v_range ($self);
}

# 'set-scroll-adjustments' class closure
sub _do_set_scroll_adjustments {
  my ($self, $hadj, $vadj) = @_;
  $self->set (hadjustment => $hadj,
              vadjustment => $vadj);
}

sub scale_x_step {
  my ($self) = @_;
  return $self->{'hadjustment'}->get_pixel_per_value;
}

sub scale_x {
  my ($self, $t) = @_;
  return $self->{'hadjustment'}->value_to_pixel ($t);
}

sub scale_x_proc {
  my ($self) = @_;
  return $self->{'hadjustment'}->value_to_pixel_proc;
}

sub x_to_date {
  my ($self, $x) = @_;
  return POSIX::floor ($self->{'hadjustment'}->pixel_to_value ($x));
}

sub scale_y {
  my ($self, $y) = @_;
  return $self->{'vadjustment'}->value_to_pixel ($y);
}

sub scale_y_proc {
  my ($self) = @_;
  return $self->{'vadjustment'}->value_to_pixel_proc;

#   my $price_lo = $self->{'vadjustment'}->get_value;
#   my $price_height = $self->{'vadjustment'}->page_size;
#   if ($price_height == 0) { $price_height = 1; }
#   my ($win_width, $win_height) = $self->window->get_size();
#   my $factor = $win_height / $price_height;
#
#   return sub {
#     my ($price) = @_;
#     return $win_height - $factor * ($price - $price_lo);
#   };
}

sub y_to_value {
  my ($self, $y) = @_;
  return $self->{'vadjustment'}->pixel_to_value ($y);

#   my $win_height = $self->allocation->height;
#   my $vadj = $self->{'vadjustment'};
#   my $factor = $vadj->value
#     + ($win_height - $y) * $vadj->page_size / $win_height;

lib/App/Chart/Gtk2/Graph.pm view on Meta::CPAN


  my $region = $event->region;
  Gtk2::Ex::GdkBits::window_clear_region ($self->window, $region);

  if (! @$series_list) {
    App::Chart::Gtk2::GUI::draw_text_centred
        ($self, $event, __('Use File/Open to open or add a symbol'));

  } else {
    _draw_region ($self, $region);
  }
  ### Graph _do_expose_event() end ...
  return Gtk2::EVENT_PROPAGATE;
}

sub _draw_region {
  my ($self, $region) = @_;
  ### Graph _draw_region() ...

  my $series_list = $self->get('series_list');
  my $any = 0;
  foreach my $series (@$series_list) {
    ### Graph draw_region linestyle: $series->linestyle_class
    my $class = $series->linestyle_class // next;
    Module::Load::load ($class);
    $any |= $class->draw ($self, $series, $region);
  }
  if (! $any) {
    ### Graph _draw_region() no data ...
    App::Chart::Gtk2::GUI::draw_text_centred ($self, $region, __('no data'));
  }

  foreach my $class (@plugins) {
    $class->draw ($self, $region);
  }
  ### Graph _draw_region() end ...
}

# 'changed' and 'value-changed' signals on vadjustment
sub _do_vadj_changed {
  my ($adj, $ref_weak_self) = @_;
  my $self = $$ref_weak_self || return;
  ### Graph vadj changed, redraw: "value=@{[$adj->value]} upper=@{[$adj->upper]} lower=@{[$adj->lower]}"
  #                if ($adj->value < 0) {
  #                  require Devel::StackTrace;
  #                  my $trace = Devel::StackTrace->new;
  #                  print $trace->as_string; # like carp
  #                }

  $self->queue_draw;
}

# Expand $adj so its lower/upper covers all of @values.
#
# If lower==upper==page_size==0 in the existing $adj settings it's treated
# as uninitialized and that 0 lower/upper is ignored, just @values is used.
#
# undefs in @values are ignored, and if all are undef then $adj is not
# changed.
#
sub adjustment_expand {
  my ($adj, @values) = @_;
  @values = grep {defined} @values;
  ### Graph adjustment_expand(): join(' ',@values)
  if (! @values) { return; }

  my ($new_lower, $new_upper) = List::MoreUtils::minmax (@values);
  ### base: "   new_lower $new_lower  new_upper $new_upper"
  ($new_lower, $new_upper) = stretch_range ($new_lower, $new_upper);
  ### stretch: "new_lower $new_lower  new_upper $new_upper"

  my $old_lower = $adj->lower;
  my $old_upper = $adj->upper;
  ### old: "    old_lower $old_lower  old_upper $old_upper  old_page ".$adj->page_size
  if (! ($old_lower == 0 && $old_upper == 0 && $adj->page_size == 0)) {
    ($new_lower, $new_upper) = List::MoreUtils::minmax
      ($new_lower, $new_upper, $old_lower, $old_upper);
  }

  ### new: "    new_lower $new_lower  new_upper $new_upper"
  Gtk2::Ex::AdjustmentBits::set_maybe
      ($adj,
       lower => $new_lower,
       upper => $new_upper);
}

sub stretch_range {
  my ($lo, $hi) = @_;
  my $extra = ($hi - $lo) * 0.1;
  if ($lo < 0) {
    $lo -= $extra;
  } else {
    $lo = max ($lo - $extra, $lo * 0.5);
  }
  $hi += $extra;
  return ($lo, $hi);
}

sub update_v_range {
  my ($self) = @_;
  my $vadj = $self->{'vadjustment'} || return;

  my ($lo, $hi) = $self->draw_t_range;
  my $vrange_span = ($self->{'vrange_span'} ||= do {
    require Set::IntSpan::Fast;
    Set::IntSpan::Fast->new
    });
  if ($vrange_span->contains_all_range ($lo, $hi)) { return; }

  ### Graph update_v_range for: "$lo to $hi"
  my $series_list = $self->{'series_list'};
  adjustment_expand ($vadj,
                     (map {
                       $_->vrange ($self, $series_list);
                     } @plugins),
                     (map {
                       _series_v_range($_, $lo, $hi)
                     } @$series_list));
  $vrange_span->add_range ($lo, $hi);
}
sub _series_v_range {
  my ($series, $lo, $hi) = @_;
  my @ret;
  my $min = $series->minimum;  push @ret, $min;
  my $max = $series->maximum;  push @ret, $max;
  $series->fill ($lo, $hi);

  foreach my $p ($series->filled_low, $series->filled_high) {
    $p // next;
    push @ret, $p;
#     foreach my $w ($p * 1.1, $p / 1.1) {
#       if (defined $min) { $w = max ($w, $min); }
#       if (defined $max) { $w = min ($w, $max); }
#       push @ret, $w;
#     }
  }
  return @ret;
}

# 'value-changed' signal on hadjustment
sub _do_hadj_value_changed {
  my ($adj, $ref_weak_self) = @_;
  my $self = $$ref_weak_self || return;
  ### Graph hadj changed, v_range and redraw: "value=@{[$adj->value]} upper=@{[$adj->upper]} lower=@{[$adj->lower]}"

  update_v_range ($self);
  $self->queue_draw;
}

# 'changed' signal on hadjustment
*_do_hadj_other_changed = \&_do_hadj_value_changed;
#   my ($adj, $ref_weak_self) = @_;
#   my $self = $$ref_weak_self || return;
#   update_v_range ($self);
#   $self->queue_draw;
# }

# 'button-press-event' class closure
sub _do_button_press {
  my ($self, $event) = @_;
  ### Graph _do_button_press(): $event->button
  require App::Chart::Gtk2::Ex::BindingBits;
  App::Chart::Gtk2::Ex::BindingBits::activate_button_event
      ('App__Chart__Gtk2__Graph_keys', $event, $self);
  return shift->signal_chain_from_overridden(@_);
}

sub centre {
  my ($self) = @_;
  ### Graph centre()
  my $vadj = $self->{'vadjustment'};
  my $page = $vadj->page_size * 0.9; # gap at ends

lib/App/Chart/Gtk2/Graph.pm view on Meta::CPAN

    if ($new_page <= $page) {
      $l = $new_l;
      $h = $new_h;
      return 1;
    }

    if ($new_l < $l) {
      $l = $h - $page;
    } else {
      $h = $l + $page;
    }
    return 0;
  };

  if (my $series = $series_list->[0]) {
    if (defined (my $symbol = $series->symbol)) {
      my ($latest_lo,$latest_hi)
        = App::Chart::Gtk2::Graph::Plugin::Latest->hrange ($self, $series_list);
      ### latest hrange: $latest_lo,$latest_hi
      if (defined $lo
          && App::Chart::overlap_inclusive_p ($lo,$hi,
                                              $latest_lo,$latest_hi)) {
        my $latest = App::Chart::Latest->get($symbol);
        if ($series->isa('App::Chart::Series::Derived::Volume')) {
          $accumulate->($latest->{'volume'});
        } else {
          $accumulate->($latest->{'last'})
            and $accumulate->($latest->{'bid'})
              and $accumulate->($latest->{'offer'})
                and $accumulate->($latest->{'high'})
                  and $accumulate->($latest->{'low'});
        }
      }
    }
  }

  my @arrays;
  foreach my $series (@$series_list) {
    $series->fill ($lo, $hi);
    my $values = $series->values_array;
    push @arrays, $values;
    if (my $highs = $series->array('highs')) {
      if ($highs != $values) { push @arrays, $highs; }
    }
    if (my $lows = $series->array('lows')) {
      if ($lows != $values) { push @arrays, $lows; }
    }
  }

 OUTER: for (my $i = $hi; $i >= $lo; $i--) {
    foreach my $array (@arrays) {
      $accumulate->($array->[$i])
        or last OUTER;
    }
  }
  if (! defined $l) { return; }
  ### decided: "$l to $h"

  my $extra = $page - ($h - $l);
  $l -= $extra / 2;
  ### expand to: "low $l on page $page"
  $vadj->set_value ($l);
}


#------------------------------------------------------------------------------
# scrolling

# 'scroll-event' class closure
sub _do_scroll_event {
  my ($self, $event) = @_;
  ### Graph _do_scroll_event(): "$self->{'hadjustment'}, $self->{'vadjustment'}"

  my $direction = $event->direction;
  if    ($direction eq 'up')    { $self->{'vadjustment'}->scroll_step(1); }
  elsif ($direction eq 'down')  { $self->{'vadjustment'}->scroll_step(-1); }
  elsif ($direction eq 'left')  { $self->{'hadjustment'}->scroll_step(1); }
  elsif ($direction eq 'right') { $self->{'hadjustment'}->scroll_step(-1); }

  return $self->signal_chain_from_overridden ($event);
}


#------------------------------------------------------------------------------
# action signal handlers

sub _do_start_drag {
  my ($self, $button) = @_;
  my $hadj = $self->{'hadjustment'} || return; # only when adj set
  my $vadj = $self->{'vadjustment'} || return; # only when adj set
  my $dragger = ($self->{'dragger'} ||= do {
    require Gtk2::Ex::Dragger;
    Gtk2::Ex::Dragger->new (widget => $self,
                            hadjustment => $hadj,
                            vadjustment => $vadj,
                            vinverted   => 1,
                            confine     => 1,
                            cursor      => 'fleur')
    });
  $dragger->start (Gtk2->get_current_event);
}

sub _do_start_lasso {
  my ($self, $button) = @_;
  my $lasso = ($self->{'lasso'} ||= do {
    require Gtk2::Ex::Lasso;
    my $l = Gtk2::Ex::Lasso->new (widget => $self);
    $l->signal_connect (ended => \&_do_lasso_ended);
    $l
  });
  $lasso->start (Gtk2->get_current_event);
}
sub _do_lasso_ended {
  my ($lasso, $x1,$y1, $x2,$y2) = @_;
  my $self = $lasso->get('widget') || return;

  my $hadj = $self->{'hadjustment'};
  my $t1 = $self->x_to_date ($x1);
  my $t2 = $self->x_to_date ($x2);
  $hadj->set_value_range (min($t1,$t2), max($t1,$t2));

( run in 0.445 second using v1.01-cache-2.11-cpan-5623c5533a1 )