kgsueme/kgsueme/room.pl

package room;

use KGS::Constants;

use base KGS::Listener::Room;

use Glib::Object::Subclass
   Gtk2::Frame;

sub new {
   my ($self, %arg) = @_;
   $self = $self->Glib::Object::new;
   $self->{$_} = delete $arg{$_} for keys %arg;

   $self->signal_connect (destroy => sub {
      delete $::config->{rooms}{$self->{channel}};
      delete $self->{app}{room}{$self->{channel}};
      (remove Glib::Source delete $self->{gameupdate}) if $self->{gameupdate};
      $self->unlisten;
      %{$_[0]} = ();
   });

   $self->listen ($self->{conn}, qw(msg_room:));

   $self->signal_connect (delete_event => sub { $self->part; 1 });

   $self->add (my $hbox = new Gtk2::HBox);

   $hbox->pack_start ((my $vbox = new Gtk2::VBox), 1, 1, 0);
   
   $vbox->add ($self->{chat} = new chat);

   $self->{chat}->signal_connect(command => sub {
      my ($chat, $cmd, $arg) = @_;
      $self->{app}->do_command ($chat, $cmd, $arg, userlist => $self->{userlist}, room => $self);
   });

   $hbox->pack_start ((my $vbox = new Gtk2::VBox), 0, 1, 0);

   $vbox->pack_start ((my $button = new_with_label Gtk2::Button "Close"), 0, 1, 0);
   $button->signal_connect (clicked => sub { $self->part });
   
   $vbox->pack_start ((my $button = new_with_label Gtk2::Button "New Game"), 0, 1, 0);
   $button->signal_connect (clicked => sub { $self->new_game });

   $vbox->pack_start ((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0);
   $sw->set_policy("automatic", "always");

   $sw->add ($self->{userlist} = new userlist);

   $self;
}

sub FINALIZE_INSTANCE { print "FIN room\n" } # never called MEMLEAK #d#TODO#

sub part {
   my ($self) = @_;
   $self->SUPER::part;

   $self->hide_all;
}

sub inject_msg_room {
   my ($self, $msg) = @_;

   # secret typoe ;-)
   $self->{chat}->append_text ("\n<header><user>" . (util::toxml $msg->{name})
                               . "</user>: </header>" . (util::toxml $msg->{message}));
}

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

   $self->{userlist}->update ($add, $update, $remove);
}

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

   $self->{app}{gamelist}->update ($self, $add, $update, $remove);

   # try to identify any new games assigned to us. stupid protocol
   # first updates the game, joins you and THEN tells you that
   # which of the games you asked for this is.

   for (@$add) {
      if ($_->is_playing ($self->{conn}{name})
          and my $game = shift @{$self->{new_game}}) {
         $game->inject_upd_game ({ game => $_ });
         $game->set_channel ($game->{channel});
      }
   }
}

sub event_join {
   my ($self) = @_;
   $self->SUPER::event_join;

   $::config->{rooms}{$self->{channel}} = { channel => $self->{channel}, name => $self->{name} };

   # mysteriously enough, we have to request game updates manually
   $self->{gameupdate} ||= add Glib::Timeout INTERVAL_GAMEUPDATES * 1000, sub {
      $self->req_games;
      1;
   };

   $self->show_all;
}

sub event_part {
   my ($self) = @_;

   $self->SUPER::event_part;
   $self->destroy;
}

sub event_update_roominfo {
   my ($self) = @_;

   $self->{chat}->append_text("\n<user>" . (util::toxml $self->{owner}) . "</user>\n"
                              . "<description>" . (util::toxml $self->{description}) . "</description>\n");
}

sub new_game {
   my ($self) = @_;

   my $d = $self->{app}{defaults};

   my $game = new game conn => $self->{conn}, app => $self->{app}, roomid => $self->{channel};
   $game->{challenge}{""} = {
      type     => $d->{type},
      flags    => 0,
      notes    => $d->{stones},
      rules    => {
         ruleset  => $d->{ruleset},
         size     => $d->{size},
         timesys  => $d->{timesys},
         time     => $d->{time},
         interval => $d->{timesys} == TIMESYS_BYO_YOMI ? $d->{byo_time}    : $d->{can_time},
         count    => $d->{timesys} == TIMESYS_BYO_YOMI ? $d->{byo_periods} : $d->{can_stones},
      },

      inlay => $game->{chat}->new_inlay,
   };
   $game->draw_challenge ("");
   $game->show_all;

   push @{$self->{new_game}}, $game;
}

1;

Revision:	1.20
Committed:	Sat May 29 06:38:27 2004 UTC (19 years, 11 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.19:	+36 -4 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	package room;
2
3	pcg	1.11	use KGS::Constants;
4
5	pcg	1.1	use base KGS::Listener::Room;
6	pcg	1.17
7			use Glib::Object::Subclass
8	pcg	1.19	Gtk2::Frame;
9	pcg	1.1
10			sub new {
11	pcg	1.17	my ($self, %arg) = @_;
12			$self = $self->Glib::Object::new;
13			$self->{$_} = delete $arg{$_} for keys %arg;
14
15	pcg	1.18	$self->signal_connect (destroy => sub {
16			delete $::config->{rooms}{$self->{channel}};
17			delete $self->{app}{room}{$self->{channel}};
18			(remove Glib::Source delete $self->{gameupdate}) if $self->{gameupdate};
19			$self->unlisten;
20			%{$_[0]} = ();
21			});
22	pcg	1.1
23	pcg	1.17	$self->listen ($self->{conn}, qw(msg_room:));
24	pcg	1.1
25	pcg	1.17	$self->signal_connect (delete_event => sub { $self->part; 1 });
26	pcg	1.1
27	pcg	1.19	$self->add (my $hbox = new Gtk2::HBox);
28	pcg	1.1
29	pcg	1.19	$hbox->pack_start ((my $vbox = new Gtk2::VBox), 1, 1, 0);
30	pcg	1.1
31	pcg	1.17	$vbox->add ($self->{chat} = new chat);
32	pcg	1.1
33	pcg	1.15	$self->{chat}->signal_connect(command => sub {
34			my ($chat, $cmd, $arg) = @_;
35	pcg	1.16	$self->{app}->do_command ($chat, $cmd, $arg, userlist => $self->{userlist}, room => $self);
36	pcg	1.1	});
37
38	pcg	1.19	$hbox->pack_start ((my $vbox = new Gtk2::VBox), 0, 1, 0);
39
40			$vbox->pack_start ((my $button = new_with_label Gtk2::Button "Close"), 0, 1, 0);
41			$button->signal_connect (clicked => sub { $self->part });
42
43			$vbox->pack_start ((my $button = new_with_label Gtk2::Button "New Game"), 0, 1, 0);
44			$button->signal_connect (clicked => sub { $self->new_game });
45
46			$vbox->pack_start ((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0);
47	pcg	1.1	$sw->set_policy("automatic", "always");
48
49	pcg	1.17	$sw->add ($self->{userlist} = new userlist);
50	pcg	1.1
51			$self;
52			}
53
54	pcg	1.17	sub FINALIZE_INSTANCE { print "FIN room\n" } # never called MEMLEAK #d#TODO#
55	pcg	1.1
56			sub part {
57			my ($self) = @_;
58			$self->SUPER::part;
59
60	pcg	1.17	$self->hide_all;
61	pcg	1.1	}
62
63			sub inject_msg_room {
64			my ($self, $msg) = @_;
65
66	pcg	1.7	# secret typoe ;-)
67	pcg	1.20	$self->{chat}->append_text ("\n<header><user>" . (util::toxml $msg->{name})
68			. "</user>: </header>" . (util::toxml $msg->{message}));
69	pcg	1.1	}
70
71			sub event_update_users {
72	pcg	1.5	my ($self, $add, $update, $remove) = @_;
73	pcg	1.1
74	pcg	1.5	$self->{userlist}->update ($add, $update, $remove);
75	pcg	1.1	}
76
77			sub event_update_games {
78	pcg	1.5	my ($self, $add, $update, $remove) = @_;
79	pcg	1.1
80	pcg	1.14	$self->{app}{gamelist}->update ($self, $add, $update, $remove);
81	pcg	1.20
82			# try to identify any new games assigned to us. stupid protocol
83			# first updates the game, joins you and THEN tells you that
84			# which of the games you asked for this is.
85
86			for (@$add) {
87			if ($_->is_playing ($self->{conn}{name})
88			and my $game = shift @{$self->{new_game}}) {
89			$game->inject_upd_game ({ game => $_ });
90			$game->set_channel ($game->{channel});
91			}
92			}
93	pcg	1.1	}
94
95			sub event_join {
96			my ($self) = @_;
97			$self->SUPER::event_join;
98
99	pcg	1.4	$::config->{rooms}{$self->{channel}} = { channel => $self->{channel}, name => $self->{name} };
100	pcg	1.11
101			# mysteriously enough, we have to request game updates manually
102			$self->{gameupdate} \|\|= add Glib::Timeout INTERVAL_GAMEUPDATES * 1000, sub {
103			$self->req_games;
104			1;
105			};
106	pcg	1.17
107			$self->show_all;
108	pcg	1.11	}
109
110			sub event_part {
111			my ($self) = @_;
112	pcg	1.13
113	pcg	1.11	$self->SUPER::event_part;
114	pcg	1.17	$self->destroy;
115	pcg	1.1	}
116
117			sub event_update_roominfo {
118			my ($self) = @_;
119
120	pcg	1.15	$self->{chat}->append_text("\n<user>" . (util::toxml $self->{owner}) . "</user>\n"
121	pcg	1.10	. "<description>" . (util::toxml $self->{description}) . "</description>\n");
122	pcg	1.11	}
123
124	pcg	1.19	sub new_game {
125			my ($self) = @_;
126
127	pcg	1.20	my $d = $self->{app}{defaults};
128
129			my $game = new game conn => $self->{conn}, app => $self->{app}, roomid => $self->{channel};
130			$game->{challenge}{""} = {
131			type => $d->{type},
132			flags => 0,
133			notes => $d->{stones},
134			rules => {
135			ruleset => $d->{ruleset},
136			size => $d->{size},
137			timesys => $d->{timesys},
138			time => $d->{time},
139			interval => $d->{timesys} == TIMESYS_BYO_YOMI ? $d->{byo_time} : $d->{can_time},
140			count => $d->{timesys} == TIMESYS_BYO_YOMI ? $d->{byo_periods} : $d->{can_stones},
141			},
142
143			inlay => $game->{chat}->new_inlay,
144			};
145			$game->draw_challenge ("");
146			$game->show_all;
147
148			push @{$self->{new_game}}, $game;
149	pcg	1.19	}
150
151	pcg	1.1	1;
152