Gtk2::Ex::FormFactory::List - A List in a FormFactory framework

  Gtk2::Ex::FormFactory::List->new (
    attr_select        => Attribute name for selection tracking,
    attr_select_column => Use this column's value to store in attr_select
    columns            => Titles of the list columns,
    types              => Types of the list columns,
    editable           => Which columns are editable?,
    visible            => Which columns are visible?
    selection_mode     => Selection mode of this list,
    no_header          => Omit header?
    update_selection_only => Boolean, whether updates should only
    			     change the selection, not the list
			     of values,
    ...
    Gtk2::Ex::FormFactory::Widget attributes
  );

  Gtk2::Ex::FormFactory::Intro

  Gtk2::Ex::FormFactory::Widget
  +--- Gtk2::Ex::FormFactory::List

  Gtk2::Ex::FormFactory::Layout
  Gtk2::Ex::FormFactory::Rules
  Gtk2::Ex::FormFactory::Context
  Gtk2::Ex::FormFactory::Proxy

 Jörn Reder <joern at zyn dot de>

package Gtk2::Ex::FormFactory::List;

use strict;
use Carp;

use base qw( Gtk2::Ex::FormFactory::Widget );

sub get_type { "list" }

sub get_attr_select		{ shift->{attr_select}			}
sub get_attr_select_column	{ shift->{attr_select_column}		}
sub get_update_selection_only	{ shift->{update_selection_only}	}
sub get_columns			{ shift->{columns}			}
sub get_types			{ shift->{types}			}
sub get_visible			{ shift->{visible}			}
sub get_editable		{ shift->{editable}			}
sub get_selection_mode		{ shift->{selection_mode}		}
sub get_is_editable		{ shift->{is_editable}			}
sub get_selection_backup	{ shift->{selection_backup}		}
sub get_no_header		{ shift->{no_header}			}
sub get_last_applied_selection	{ shift->{last_applied_selection}	}

sub set_attr_select		{ shift->{attr_select}		= $_[1]	}
sub set_attr_select_column	{ shift->{attr_select_column}	= $_[1]	}
sub set_update_selection_only	{ shift->{update_selection_only}= $_[1]	}
sub set_columns			{ shift->{columns}		= $_[1]	}
sub set_types			{ shift->{types}		= $_[1]	}
sub set_visible			{ shift->{visible}		= $_[1]	}
sub set_editable		{ shift->{editable}		= $_[1]	}
sub set_selection_mode		{ shift->{selection_mode}	= $_[1]	}
sub set_is_editable		{ shift->{is_editable}		= $_[1]	}
sub set_selection_backup	{ shift->{selection_backup}	= $_[1]	}
sub set_no_header		{ shift->{no_header}		= $_[1]	}
sub set_last_applied_selection	{ shift->{last_applied_selection}= $_[1]}

sub has_additional_attrs	{ [ "select" ] 				}

sub get_selected_rows {
	my $self = shift;
	my @sel = $self->get_gtk_widget->get_selected_indices;
	return \@sel;
}

sub get_data {
	my $self = shift;
	return $self->get_gtk_widget->{data};
}

sub select_row_by_attr {
	my $self = shift;
	my ($attr_value) = @_;
	
	my $column = $self->get_attr_select_column;
	my $data = $self->get_data;

	for ( my $i=0; $i < @{$data}; ++$i ) {
		if ( $data->[$i][$column] eq $attr_value ) {
			$self->get_gtk_widget->select($i);
			last;
		}
	}
	
	1;		
}

sub new {
	my $class = shift;
	my %par = @_;
	my  ($attr_select, $columns, $types, $editable, $visible) =
	@par{'attr_select','columns','types','editable','visible'};
	my  ($update_selection_only, $selection_mode) =
	@par{'update_selection_only','selection_mode'};
	my  ($attr_select_column, $no_header) =
	@par{'attr_select_column','no_header'};

	croak "'columns' attribute is mandatory" unless $columns;

	my $self = $class->SUPER::new(@_);
	
	$self->set_attr_select	  	($attr_select);
	$self->set_attr_select_column	($attr_select_column);
	$self->set_columns		($columns);
	$self->set_visible		($visible);
	$self->set_types		($types);
	$self->set_editable		($editable);
	$self->set_selection_mode	($selection_mode);
	$self->set_update_selection_only($update_selection_only);
	$self->set_no_header		($no_header);

	my $is_editable = 0;
	map { $is_editable = 1 if $_ } @{$editable};
	
	$self->set_is_editable($is_editable);
	
	return $self;
}

sub object_to_widget {
	my $self = shift;

	my $object_value = $self->get_object_value || [];

	my $slist_was_empty = ! scalar(@{$self->get_gtk_widget->{data}});

	if ( not $self->get_update_selection_only ) {
		$self->get_gtk_widget
		     ->set_data_array($object_value);
	} else {
		$self->get_gtk_widget
		     ->set_data_array($object_value)
			if @{$self->get_gtk_widget->{data}} == 0;
	}

	if ( $self->get_attr_select ) {
		my $proxy = $self->get_proxy;
		my $idx = $proxy->get_attr (
			$self->get_attr_select
		);
		my $sel;
		$sel = join("\t",@{$idx}) if $idx;
		$self->set_last_applied_selection($sel);
		my $gtk_simple_list = $self->get_gtk_widget;
		if ( defined $idx and @{$idx} and @{$self->get_gtk_widget->{data}} != 0 ) {
			if ( defined $self->get_attr_select_column ) {
				my $i = 0;
				my $col  = $self->get_attr_select_column;
				my $data = $self->get_gtk_widget->{data};
				my %col2idx = map { ($_->[$col], $i++) } @{$data};
				my @idx = map { $col2idx{$_} } @{$idx};
				$idx = \@idx;
			}

			if ( @{$idx} && defined $idx->[0] ) {
				$gtk_simple_list->select(@{$idx});
				$gtk_simple_list->scroll_to_cell(
					Gtk2::TreePath->new_from_string($idx->[0]),
					($gtk_simple_list->get_columns)[0],
					0, 0
				) if $slist_was_empty;
			} else {
				$gtk_simple_list->get_selection->unselect_all;
				$proxy->set_attr($self->get_attr_select, undef);
			}
		} else {
			$gtk_simple_list->get_selection->unselect_all;
		}

		Glib::Idle->add (sub {
			$self->widget_selection_to_object;
			0;
		});
	}

	1;
}

sub widget_to_object {
	my $self = shift;
	
	if ( $self->get_is_editable ) {
		my $data = $self->get_gtk_widget->{data};
		my @value = @{$data};
		$self->set_object_value (\@value);
	}

	$self->widget_selection_to_object
		if $self->get_attr_select;
	
	1;
}

sub widget_selection_to_object {
	my $self = shift;
	
	return 1 if ! $self->get_proxy->get_object($self->get_object);
	
	my @sel = $self->get_gtk_widget->get_selected_indices;

	if ( defined $self->get_attr_select_column ) {
		my $column = $self->get_attr_select_column;
		my $data   = $self->get_gtk_widget->{data};
		$_ = $data->[$_][$column] for @sel;
	}

	my $sel = join("\t",@sel);
	return if $sel eq $self->get_last_applied_selection;
	$self->set_last_applied_selection($sel);

	$self->get_proxy->set_attr (
		$self->get_attr_select, \@sel
	); 

	1;
}

sub empty_widget {
	my $self = shift;

	$self->get_gtk_widget->set_data_array([]);
	$self->get_gtk_widget->get_selection->unselect_all;

	1;
}

sub backup_widget_value {
	my $self = shift;

	if ( $self->get_is_editable ) {
		my $data = $self->get_gtk_widget->{data};
		my @value = @{$data};
		$self->set_backup_widget_value (\@value);
	}
	
	if ( $self->get_attr_select ) {
		my @sel = $self->get_gtk_widget->get_selected_indices;
		$self->set_selection_backup(\@sel);
	}

	1;
}

sub restore_widget_value {
	my $self = shift;

	if ( $self->get_is_editable ) {
		$self->get_gtk_widget
		     ->set_data_array($self->get_backup_widget_value||[]);
	}

	if ( $self->get_attr_select ) {
		my $idx = $self->get_selection_backup;
		$self->get_gtk_widget->select(@{$idx});
	}

	1;
}

sub get_widget_check_value {
	$_[0]->get_gtk_widget->{data};
}

sub connect_changed_signal {
	my $self = shift;
	
	if ( $self->get_is_editable ) {
		$self->get_gtk_widget->get_model->signal_connect (
		  'row-changed' => sub { $self->widget_value_changed },
		);
	}
	
	if ( $self->get_attr_select ) {
		$self->get_gtk_widget->get_selection->signal_connect (
		  'changed'	=> sub { $self->widget_value_changed },
		);
	}
	

	1;
}

1;

__END__