File Coverage

blib/lib/Gtk2/Ex/Spinner/EntryWithCancel.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package Gtk2::Ex::Spinner::EntryWithCancel;
use 5.008;
use strict;
use warnings;
# version 1.180 for perl subclass to override GInterfaces from superclass
use Gtk2 1.180;

our $VERSION = 5.1;

use constant DEBUG => 0;

use Glib::Object::Subclass
  'Gtk2::Entry',
  signals => { activate        => \&_do_activate,
               editing_done    => \&_do_editing_done,
               cancel => { param_types   => [],
                           return_type   => undef,
                           flags         => [ 'action','run-last' ],
                           class_closure => \&_do_cancel,
                         },
             },
  interfaces => [ 'Gtk2::CellEditable' ],
  properties => [ Glib::ParamSpec->boolean
                  ('editing-cancelled',
                   'editing-cancelled',
                   'True if editing was cancelled with Escape rather than activated with Return etc.',
                   0, # default
                   Glib::G_PARAM_READWRITE) ];

# In GtkCellRendererText and the GtkEntry it creates the cancel is noticed
# by gtk_cell_editable_key_press_event() installed on key-press-event.  Here
# it's through key bindings, in the interests of possible configurability.
#
# FIXME: Up and Down are specific to moving between view cells to end an
# edit, rather than an "edit with cancel" as such.  Would it be better for
# Spinner::CellRenderer to give its created entry a widget name and
# establish bindings that way?
#
sub INIT_INSTANCE {

  # once only RC additions, done at first instance creation

  # priority level "gtk" treating this as widget level default, for
  # overriding by application or user RC
  Gtk2::Rc->parse_string (<<'HERE');
binding "Gtk2__Ex__Spinner__EntryWithCancel_keys" {
  bind "Escape" { "cancel" () }
  bind "Up"     { "activate" () }
  bind "Down"   { "activate" () }
}
class "Gtk2__Ex__Spinner__EntryWithCancel"
  binding:gtk "Gtk2__Ex__Spinner__EntryWithCancel_keys"
HERE
  { no warnings; *INIT_INSTANCE = \&Glib::FALSE; }
}

# if (DEBUG) {
#   *SET_PROPERTY = sub {
#     my ($self, $pspec, $newval) = @_;
#     if (DEBUG) { print "EntryWithCancel: SET_PROPERTY ",$pspec->get_name,
#                    " ",(defined $newval ? $newval : 'undef'),"\n"; }
#     $self->{$pspec->get_name} = $newval;
#   };
# }

# gtk_cell_editable_start_editing(), cf. gtk_entry_start_editing()
#
sub START_EDITING {
  my ($self, $event) = @_;
  if (DEBUG) { print "EntryWithCancel: START_EDITING\n"; }
  $self->set ('editing-cancelled', 0);
  $self->{'editing_active'} = 1;
}

# 'editing-done' class closure, from GtkCellEditable interface
sub _do_editing_done {
  my ($self) = @_;
  $self->{'editing_active'} = 0;
  return $self->signal_chain_from_overridden;
}

# like gtk_cell_editable_entry_activated()
#
# In GtkEntry gtk_cell_editable_entry_activated() and
# gtk_cell_editable_key_press_event() are as a signal connections on self.
# Is there a reason for that?  Seems easier to test a flag for when to act
# rather than connect and disconnect.
#
sub _do_activate {
  my ($self) = @_;
  if (DEBUG) { print "EntryWithCancel: _do_activate\n"; }
  $self->set ('editing-cancelled', 0);
  _emit_editing_done ($self, 0);
  return $self->signal_chain_from_overridden;
}

sub cancel {
  my ($self) = @_;
  $self->signal_emit ('cancel');
}

# 'cancel' class closure
sub _do_cancel {
  my ($self) = @_;
  if (DEBUG) { print "EntryWithCancel: cancel signal\n"; }
  $self->set ('editing-cancelled', 1);
  _emit_editing_done ($self, 1); # if active
}

sub _emit_editing_done {
  my ($self, $cancelled) = @_;
  if ($self->{'editing_active'}) {
    $self->editing_done;
    $self->remove_widget;
  }
}

1;
__END__