kgsueme/kgsueme/gamelist.pl

package gamelist;

use KGS::Constants;

use base gtk::widget;

sub new {
   my $class = shift;
   my $self = $class->SUPER::new(@_);

   $self->{widget} = new Gtk2::VPaned;
   $self->{widget}->set(position_set => 1);
   gtk::state $self->{widget}, "gamelist::vpane", undef, position => 60;

   $self->{model1} = new Gtk2::ListStore Glib::Scalar,
        Glib::String, Glib::String, Glib::String, Glib::String, Glib::Int, Glib::String, Glib::String;
   gtk::state $self->{model1}, "gamelist::model1", undef, modelsortorder => [4, 'descending'];

   $self->{widget}->add(my $sw = new Gtk2::ScrolledWindow);
   $sw->set_policy("never", "always");
   $sw->add($self->{view1} = new Gtk2::TreeView $self->{model1});
   $self->{view1}->set_search_column(1);

   $self->{model2} = new Gtk2::ListStore Glib::Scalar,
        Glib::String, Glib::String, Glib::String, Glib::String, Glib::Int,
        Glib::String, Glib::String, Glib::Int, Glib::Int, Glib::Int, Glib::String;
   gtk::state $self->{model2}, "gamelist::model1", undef, modelsortorder => [4, 'descending'];

   $self->{widget}->add(my $sw = new Gtk2::ScrolledWindow);
   $sw->set_policy("never", "always");
   $sw->add($self->{view2} = new Gtk2::TreeView $self->{model2});
   $self->{view2}->set_search_column(1);

   for my $view ($self->{view1}, $self->{view2}) {
      push @{$self->{rlcolumns}}, my $column =
         Gtk2::TreeViewColumn->new_with_attributes ("Room", $gtk::text_renderer, text => 1);
      $column->set_sort_column_id(1);
      $column->set(resizable => 1);
      $column->set(sizing => 'fixed');
      gtk::state $column, "gamelist::model::Room", undef, column_size => 80;
      $view->append_column ($column);

      push @{$self->{rlcolumns}}, my $column =
         Gtk2::TreeViewColumn->new_with_attributes ("T", $gtk::text_renderer, text => 2);
      $column->set_sort_column_id(2);
      $column->set(sizing => 'grow-only');
      $view->append_column ($column);

      push @{$self->{rlcolumns}}, my $column =
         Gtk2::TreeViewColumn->new_with_attributes ("Owner", $gtk::text_renderer, text => 3);
      $column->set_sort_column_id(3);
      $column->set(resizable => 1);
      $column->set(sizing => 'fixed');
      gtk::state $column, "gamelist::model::Owner", undef, column_size => 100;
      $view->append_column ($column);

      push @{$self->{rlcolumns}}, my $column =
         Gtk2::TreeViewColumn->new_with_attributes ("Rk", $gtk::text_renderer, text => 4);
      $column->set_sort_column_id(5);
      $column->set(sizing => 'grow-only');
      $view->append_column ($column);
   }

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Info", $gtk::text_renderer, text => 6);
   $column->set(resizable => 1);
   $column->set(sizing => 'autosize');
   gtk::state $column, "gamelist::model::Info", undef, column_size => 80;
   $self->{view1}->append_column ($column);

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Notes", $gtk::text_renderer, text => 7);
   $column->set(resizable => 1);
   $column->set(sizing => 'autosize');
   gtk::state $column, "gamelist::model::Notes", undef, column_size => 200;
   $self->{view1}->append_column ($column);

   ###########

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Opponent", $gtk::text_renderer, text => 6);
   $column->set(resizable => 1);
   $column->set(sizing => 'fixed');
   gtk::state $column, "gamelist::model::Opponent", undef, column_size => 120;
   $self->{view2}->append_column ($column);

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Rk", $gtk::text_renderer, text => 7);
   $column->set_sort_column_id(8);
   $column->set(sizing => 'grow-only');
   $self->{view2}->append_column ($column);

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Mv", $gtk::int_renderer, text => 9);
   $column->set_sort_column_id(9);
   $column->set(sizing => 'grow-only');
   $self->{view2}->append_column ($column);

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Ob", $gtk::int_renderer, text => 10);
   $column->set_sort_column_id(10);
   $column->set(sizing => 'grow-only');
   $self->{view2}->append_column ($column);

   push @{$self->{rlcolumns}}, my $column =
      Gtk2::TreeViewColumn->new_with_attributes ("Info", $gtk::text_renderer, text => 11);
   $column->set(resizable => 1);
   $column->set(sizing => 'autosize');
   gtk::state $column, "gamelist::model::Info", undef, column_size => 120;
   $self->{view2}->append_column ($column);

   ###########

   $self->{view1}->signal_connect(row_activated => sub {
      my ($widget, $path, $column) = @_;
      my $game = $self->{model1}->get ($self->{model1}->get_iter ($path), 0);
      ($self->{game}{$game->{channel}} ||= new game %$game, conn => $self->{conn})
         ->join;
      1;
   });

   $self->{view2}->signal_connect(row_activated => sub {
      my ($widget, $path, $column) = @_;
      my $game = $self->{model2}->get ($self->{model2}->get_iter ($path), 0);
      ($self->{game}{$game->{channel}} ||= new game %$game, conn => $self->{conn})
         ->join;
      1;
   });

   $self;
}

sub update {
   my ($self, $room, $add, $update, $remove) = @_;

   $self->{games}{$room->{name}} = $room->{games};

   my $m1 = $self->{model1};
   my $m2 = $self->{model2};

   for (@$remove) {
      (delete $_->{model})->remove (delete $_->{iter}) if $_->{model};
   }

   for (@$add, @$update) {
      my $owner = $_->owner;
      if ($_->is_valid) {
         (delete $_->{model})->remove (delete $_->{iter}) if $_->{model} && $_->{model} != $m2;#d#
         $_->{model} = $m2;
         $m2->set ($_->{iter} ||= $m2->append,
                      0, $_,
                      1, $room->{name},
                      2, (uc substr $gametype{$_->type}, 0, 1),#d# should use ->gametype_char, which also does P, S
                      3, $owner->{name},
                      4, $owner->rank_string,
                      5, $owner->rank,
                      6, $_->opponent_string,
                      7, $_->{user1}->rank_string,
                      8, $_->{user1}->rank,
                      9, $_->moves,
                     10, $_->{observers},
                     11, $_->rules,
                  );
      } else {
         warn "IG before $_->{model},$_->{iter},$room->{name},$owner->{name}\n";#d#
         (delete $_->{model})->remove (delete $_->{iter}) if $_->{model} && $_->{model} != $m1;#d#
         $_->{model} = $m1;
         $m1->set ($_->{iter} ||= $m1->append,
                      0, $_,
                      1, $room->{name},
                      2, (uc substr $gametype{$_->type}, 0, 1),#d# should use ->gametype_char, which also does P, S
                      3, $owner->{name},
                      4, $owner->rank_string,
                      5, $owner->rank,
                      6, $_->rules,
                      7, $_->{notes},
                  );
         warn "IG after  $_->{model},$_->{iter},$room->{name},$owner->{name}\n";#d#
      }
   }
}

1;

Revision:	1.15
Committed:	Tue Jun 10 10:04:36 2003 UTC (20 years, 11 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.14:	+4 -5 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	package gamelist;
2
3	pcg	1.9	use KGS::Constants;
4
5	pcg	1.1	use base gtk::widget;
6
7			sub new {
8			my $class = shift;
9			my $self = $class->SUPER::new(@_);
10
11			$self->{widget} = new Gtk2::VPaned;
12			$self->{widget}->set(position_set => 1);
13			gtk::state $self->{widget}, "gamelist::vpane", undef, position => 60;
14
15			$self->{model1} = new Gtk2::ListStore Glib::Scalar,
16			Glib::String, Glib::String, Glib::String, Glib::String, Glib::Int, Glib::String, Glib::String;
17	pcg	1.7	gtk::state $self->{model1}, "gamelist::model1", undef, modelsortorder => [4, 'descending'];
18	pcg	1.1
19			$self->{widget}->add(my $sw = new Gtk2::ScrolledWindow);
20			$sw->set_policy("never", "always");
21			$sw->add($self->{view1} = new Gtk2::TreeView $self->{model1});
22			$self->{view1}->set_search_column(1);
23
24			$self->{model2} = new Gtk2::ListStore Glib::Scalar,
25	pcg	1.2	Glib::String, Glib::String, Glib::String, Glib::String, Glib::Int,
26			Glib::String, Glib::String, Glib::Int, Glib::Int, Glib::Int, Glib::String;
27	pcg	1.7	gtk::state $self->{model2}, "gamelist::model1", undef, modelsortorder => [4, 'descending'];
28	pcg	1.1
29			$self->{widget}->add(my $sw = new Gtk2::ScrolledWindow);
30			$sw->set_policy("never", "always");
31			$sw->add($self->{view2} = new Gtk2::TreeView $self->{model2});
32			$self->{view2}->set_search_column(1);
33
34			for my $view ($self->{view1}, $self->{view2}) {
35			push @{$self->{rlcolumns}}, my $column =
36			Gtk2::TreeViewColumn->new_with_attributes ("Room", $gtk::text_renderer, text => 1);
37			$column->set_sort_column_id(1);
38			$column->set(resizable => 1);
39			$column->set(sizing => 'fixed');
40			gtk::state $column, "gamelist::model::Room", undef, column_size => 80;
41			$view->append_column ($column);
42
43			push @{$self->{rlcolumns}}, my $column =
44	pcg	1.3	Gtk2::TreeViewColumn->new_with_attributes ("T", $gtk::text_renderer, text => 2);
45	pcg	1.1	$column->set_sort_column_id(2);
46	pcg	1.3	$column->set(sizing => 'grow-only');
47	pcg	1.1	$view->append_column ($column);
48
49			push @{$self->{rlcolumns}}, my $column =
50			Gtk2::TreeViewColumn->new_with_attributes ("Owner", $gtk::text_renderer, text => 3);
51			$column->set_sort_column_id(3);
52			$column->set(resizable => 1);
53			$column->set(sizing => 'fixed');
54			gtk::state $column, "gamelist::model::Owner", undef, column_size => 100;
55			$view->append_column ($column);
56
57			push @{$self->{rlcolumns}}, my $column =
58	pcg	1.2	Gtk2::TreeViewColumn->new_with_attributes ("Rk", $gtk::text_renderer, text => 4);
59	pcg	1.1	$column->set_sort_column_id(5);
60	pcg	1.3	$column->set(sizing => 'grow-only');
61	pcg	1.1	$view->append_column ($column);
62	pcg	1.2	}
63	pcg	1.1
64	pcg	1.2	push @{$self->{rlcolumns}}, my $column =
65			Gtk2::TreeViewColumn->new_with_attributes ("Info", $gtk::text_renderer, text => 6);
66			$column->set(resizable => 1);
67	pcg	1.3	$column->set(sizing => 'autosize');
68	pcg	1.2	gtk::state $column, "gamelist::model::Info", undef, column_size => 80;
69			$self->{view1}->append_column ($column);
70	pcg	1.1
71			push @{$self->{rlcolumns}}, my $column =
72			Gtk2::TreeViewColumn->new_with_attributes ("Notes", $gtk::text_renderer, text => 7);
73			$column->set(resizable => 1);
74	pcg	1.3	$column->set(sizing => 'autosize');
75	pcg	1.1	gtk::state $column, "gamelist::model::Notes", undef, column_size => 200;
76			$self->{view1}->append_column ($column);
77
78			###########
79
80			push @{$self->{rlcolumns}}, my $column =
81	pcg	1.2	Gtk2::TreeViewColumn->new_with_attributes ("Opponent", $gtk::text_renderer, text => 6);
82	pcg	1.4	$column->set(resizable => 1);
83	pcg	1.2	$column->set(sizing => 'fixed');
84			gtk::state $column, "gamelist::model::Opponent", undef, column_size => 120;
85			$self->{view2}->append_column ($column);
86
87			push @{$self->{rlcolumns}}, my $column =
88			Gtk2::TreeViewColumn->new_with_attributes ("Rk", $gtk::text_renderer, text => 7);
89			$column->set_sort_column_id(8);
90	pcg	1.3	$column->set(sizing => 'grow-only');
91	pcg	1.2	$self->{view2}->append_column ($column);
92
93			push @{$self->{rlcolumns}}, my $column =
94			Gtk2::TreeViewColumn->new_with_attributes ("Mv", $gtk::int_renderer, text => 9);
95	pcg	1.5	$column->set_sort_column_id(9);
96	pcg	1.3	$column->set(sizing => 'grow-only');
97	pcg	1.1	$self->{view2}->append_column ($column);
98
99			push @{$self->{rlcolumns}}, my $column =
100	pcg	1.2	Gtk2::TreeViewColumn->new_with_attributes ("Ob", $gtk::int_renderer, text => 10);
101	pcg	1.5	$column->set_sort_column_id(10);
102	pcg	1.3	$column->set(sizing => 'grow-only');
103	pcg	1.1	$self->{view2}->append_column ($column);
104
105	pcg	1.2	push @{$self->{rlcolumns}}, my $column =
106			Gtk2::TreeViewColumn->new_with_attributes ("Info", $gtk::text_renderer, text => 11);
107			$column->set(resizable => 1);
108	pcg	1.3	$column->set(sizing => 'autosize');
109	pcg	1.2	gtk::state $column, "gamelist::model::Info", undef, column_size => 120;
110			$self->{view2}->append_column ($column);
111
112	pcg	1.1	###########
113
114			$self->{view1}->signal_connect(row_activated => sub {
115			my ($widget, $path, $column) = @_;
116			my $game = $self->{model1}->get ($self->{model1}->get_iter ($path), 0);
117			($self->{game}{$game->{channel}} \|\|= new game %$game, conn => $self->{conn})
118			->join;
119	pcg	1.6	1;
120	pcg	1.1	});
121
122			$self->{view2}->signal_connect(row_activated => sub {
123			my ($widget, $path, $column) = @_;
124			my $game = $self->{model2}->get ($self->{model2}->get_iter ($path), 0);
125			($self->{game}{$game->{channel}} \|\|= new game %$game, conn => $self->{conn})
126			->join;
127	pcg	1.6	1;
128	pcg	1.1	});
129
130			$self;
131			}
132
133			sub update {
134	pcg	1.6	my ($self, $room, $add, $update, $remove) = @_;
135	pcg	1.1
136			$self->{games}{$room->{name}} = $room->{games};
137
138	pcg	1.6	my $m1 = $self->{model1};
139			my $m2 = $self->{model2};
140
141	pcg	1.12	for (@$remove) {
142	pcg	1.8	(delete $_->{model})->remove (delete $_->{iter}) if $_->{model};
143	pcg	1.6	}
144
145			for (@$add, @$update) {
146			my $owner = $_->owner;
147	pcg	1.8	if ($_->is_valid) {
148	pcg	1.15	(delete $_->{model})->remove (delete $_->{iter}) if $_->{model} && $_->{model} != $m2;#d#
149	pcg	1.8	$_->{model} = $m2;
150			$m2->set ($_->{iter} \|\|= $m2->append,
151			0, $_,
152			1, $room->{name},
153	pcg	1.9	2, (uc substr $gametype{$_->type}, 0, 1),#d# should use ->gametype_char, which also does P, S
154	pcg	1.8	3, $owner->{name},
155			4, $owner->rank_string,
156			5, $owner->rank,
157			6, $_->opponent_string,
158			7, $_->{user1}->rank_string,
159			8, $_->{user1}->rank,
160			9, $_->moves,
161			10, $_->{observers},
162			11, $_->rules,
163			);
164			} else {
165	pcg	1.15	warn "IG before $_->{model},$_->{iter},$room->{name},$owner->{name}\n";#d#
166			(delete $_->{model})->remove (delete $_->{iter}) if $_->{model} && $_->{model} != $m1;#d#
167	pcg	1.6	$_->{model} = $m1;
168			$m1->set ($_->{iter} \|\|= $m1->append,
169	pcg	1.8	0, $_,
170			1, $room->{name},
171	pcg	1.9	2, (uc substr $gametype{$_->type}, 0, 1),#d# should use ->gametype_char, which also does P, S
172	pcg	1.8	3, $owner->{name},
173			4, $owner->rank_string,
174			5, $owner->rank,
175			6, $_->rules,
176			7, $_->{notes},
177	pcg	1.6	);
178	pcg	1.15	warn "IG after $_->{model},$_->{iter},$room->{name},$owner->{name}\n";#d#
179	pcg	1.1	}
180	pcg	1.6	}
181	pcg	1.1	}
182
183			1;
184