view release on metacpan or  search on metacpan

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

  $vbox->pack_start ($hbox, 0,0,0);

  my $entry_label = Gtk2::Label->new (__('New List'));
  $hbox->pack_start ($entry_label, 0,0,0);

  my $entry = $self->{'symlist_entry'} = Gtk2::Entry->new;
  $hbox->pack_start ($entry, 1,1,0);
  $entry->signal_connect (activate => \&_do_symlist_entry_activate);

  { my $button = Gtk2::Button->new_with_label (__('Insert'));
    $hbox->pack_start ($button, 0,0,0);
    $button->signal_connect (clicked => \&_do_symlist_entry_activate);
  }

  $self->{'symlists_setup'} = 1;
  $vbox->show_all;
}

sub SET_PROPERTY {
  my ($self, $pspec, $newval) = @_;
  my $pname = $pspec->get_name;
  if ($pspec->get_name eq 'symlist') {
    $self->set_symlist ($newval);
  } else {
    $self->{$pname} = $newval;  # per default GET_PROPERTY
  }
}

sub get_selected_symbol {
  my ($self) = @_;
  my $treeview = $self->{'symbols_treeview'};
  my $selection = $treeview->get_selection;
  my ($model, $iter) = $selection->get_selected;
  if (! defined $iter) { return undef; }
  my ($symbol) = $model->get ($iter, 0);
  return $symbol;
}

sub set_symlist {
  my ($self, $symlist) = @_;
  ### Watchlist set_symlist()

  if (my $conn = delete $self->{'symlist_name_conn'}) {
    $conn->disconnect;
  }
  my $label = $self->{'symbols_tab_label'};
  if ($symlist) {
    $self->{'symlist_name_conn'}
      = Glib::Ex::ConnectProperties->new ([$symlist,'name'],
                                          [$label,  'label']);
  } else {
    $label->set_text (__('(No list)'));
  }

  if (($symlist||0) eq ($self->{'symlist'}||0)) {
    ### symlist unchanged
    return;
  }

  ### new symlist: "$symlist"
  Gtk2::Ex::WidgetCursor->busy;
  my $model = $symlist && App::Chart::Gtk2::WatchlistModel->new ($symlist);

  {
    my $reorderable = $symlist && $symlist->can_edit;
    my $symbols_treeview = $self->{'symbols_treeview'};
    ### $reorderable
    $symbols_treeview->set (model       => $model,
                            reorderable => $reorderable);

    # FIXME: what was this? dragging text to add a symbol? doing it turns
    # off reorderable circa gtk 2.24 -- another incompatible change probably ...
    #
    # if ($reorderable) {
    #   $symbols_treeview->enable_model_drag_dest
    #     (['move'], { target => 'text/plain',
    #                  flags => []});  # 'other-app'
    # }
  }

  $self->{'symlist'} = $symlist;

  if ($symlist) {
    if (my $treeview = $self->{'symlists_treeview'}) {
      my $model = $treeview->get_model;
      my $key = $symlist->key;
      $model->foreach
        (sub {
           my ($model, $path, $iter) = @_;
           my $this_key = $model->get_value ($iter, $model->COL_KEY);
           if ($this_key ne $key) { return 0; } # keep iterating
           my $selection = $treeview->get_selection;
           $selection->select_path ($path);
           return 1; # stop iterating
         });
    }
  }

  my $editable = $symlist && $symlist->can_edit;
  ### symbol column editable: $editable
  $self->{'symbol_renderer'}->set (editable => $editable);

  $self->notify ('symlist');
}

sub get_symlists_selected_key {
  my ($self) = @_;
  my $treeview = $self->{'symlists_treeview'} || return; # if created yet
  my $selection = $treeview->get_selection;
  my ($model, $iter) = $selection->get_selected;
  if (! defined $iter) { return; }
  my ($symbol) = $model->get ($iter, $model->COL_KEY);
  return $symbol;
}

sub _update_delete_sensitive {
  my ($self) = @_;
  ### Watchlist _update_delete_sensitive()
  $self->set_response_sensitive (RESPONSE_DELETE,
                                 _want_delete_sensitive($self));
}

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

      $treeview = $self->{'symlists_treeview'};
      # supposed to be insensitive when no selection, but check anyway
      my $key = $self->get_symlists_selected_key || return;

      # ignore somehow unknown key
      my $symlist = App::Chart::Gtk2::Symlist->new_from_key ($key) || return;

      if (! $symlist->is_empty) {
        # dialog if symlist not empty
        require App::Chart::Gtk2::DeleteSymlistDialog;
        App::Chart::Gtk2::DeleteSymlistDialog->popup ($symlist, $self);
        return;
      }
    } else {
      $treeview = $self->{'symbols_treeview'};
    }
    require Gtk2::Ex::TreeViewBits;
    Gtk2::Ex::TreeViewBits::remove_selected_rows ($treeview);

  } elsif ($response eq RESPONSE_INTRADAY) {
    # supposed to be insensitive when no selected symbol, but check anyway
    my $symbol = $self->get_selected_symbol // return;
    App::Chart::Gtk2::Ex::ToplevelBits::popup
        ('App::Chart::Gtk2::IntradayDialog',
         properties => { symbol => $symbol },
         screen => $self);

  } elsif ($response eq RESPONSE_EDIT_NAME) {
    my $notebook = $self->{'notebook'};
    my $pagenum = $notebook->get_current_page;
    # supposed to be visible only when symlists showing, but check anyway
    ($pagenum == NOTEBOOK_PAGENUM_SYMLISTS) or return;

    my $treeview = $self->{'symlists_treeview'};
    my $selection = $treeview->get_selection;
    my ($symlists_model, $iter) = $selection->get_selected;
    # supposed to be insensitive if no selection, but check anyway
    if (! defined $iter) { return; }

    my $path = $symlists_model->get_path($iter);
    ### set_cursor to path: $path->to_string
    $treeview->grab_focus;
    my $renderer = $self->{'symlists_name_renderer'};
    $renderer->set (editable => 1);
    $treeview->set_cursor ($path, $self->{'symlists_name_treecolumn'}, 1);
    $renderer->set (editable => 0);

  } elsif ($response eq 'close') {
    # as per a keyboard close, defaults to raising 'delete-event', which in
    # turn defaults to a destroy
    $self->signal_emit ('close');

  } elsif ($response eq 'help') {
    require App::Chart::Manual;
    App::Chart::Manual->open(__p('manual-node','Watchlist'), $self);
  }
}

sub refresh {
  my ($self) = @_;
  Gtk2::Ex::WidgetCursor->busy;
  if (my $symlist = $self->{'symlist'}) {
    require App::Chart::Gtk2::Job::Latest;
    App::Chart::Gtk2::Job::Latest->start_symlist ($symlist);
  }
}

sub _do_symbol_menu_popup {
  my ($treeview, $event) = @_;
  if ($event->button == 3) {
    require App::Chart::Gtk2::WatchlistSymbolMenu;
    App::Chart::Gtk2::WatchlistSymbolMenu->popup_from_treeview ($event, $treeview);
  }
  return Gtk2::EVENT_PROPAGATE;
}

sub _do_symlist_menu_popup {
  # nothing yet ...
  #   my ($treeview, $event) = @_;
  #   my $self = $treeview->get_toplevel;
  return Gtk2::EVENT_PROPAGATE;
}

# 'query-tooltip' signal on symbols_treeview
sub _do_query_tooltip {
  my ($treeview, $x, $y, $keyboard_tip, $tooltip) = @_;
  # ### Watchlist _do_query_tooltip() "$x,$y"

  my ($bin_x, $bin_y, $model, $path, $iter)
    = $treeview->get_tooltip_context ($x, $y, $keyboard_tip);
  if (! defined $path) { return 0; }

  my $symbol = $model->get_value($iter, $model->COL_SYMBOL);
  if (! defined $symbol) { return 0; }
  require App::Chart::Latest;
  my $latest = App::Chart::Latest->get ($symbol);

  require App::Chart::Database;
  my $tip = $symbol;
  if (my $name = ($latest->{'name'}
                  || App::Chart::Database->symbol_name ($symbol))) {
    $tip .= ' - ' . $name;
  }
  $tip .= "\n";

  if (my $quote_date = $latest->{'quote_date'}) {
    my $quote_time = $latest->{'quote_time'} || '';
    $tip .= __x("Quote: {quote_date} {quote_time}",
                quote_date => $quote_date,
                quote_time => $quote_time);
    $tip .= "\n";
  }

  if (my $last_date = $latest->{'last_date'}) {
    my $last_time = $latest->{'last_time'} || '';
    $tip .= __x("Last:  {last_date} {last_time}",
                last_date => $last_date,
                last_time => $last_time);
    $tip .= "\n";
  }