--- kgsueme/bin/kgsueme	2003/05/29 12:19:10	1.11
+++ kgsueme/bin/kgsueme	2003/05/30 07:19:16	1.16
@@ -1,37 +1,65 @@
 #!/usr/bin/perl -I../lib/
 
-#use PApp::Util qw(dumpval); # debug only
-
 use Gtk;
 use Gtk::Gdk;
-#use Gtk::Gdk::Pixbuf;
-use Gtk::Gdk::ImlibImage;
-
-use Gnome;
+use Gtk::Gdk::Pixbuf;
+#use Gtk::Gdk::ImlibImage;
 
 use KGS::Protocol;
 use KGS::Listener::Debug;
 
+use Audio::Data;
+use Audio::Play;
+
 use IO::Socket::INET;
 
 use Errno;
 
-init Gnome "kgsueme";
+init Gtk;
 
 $HACK = 1; # do NEVER enable. ;)
 
 our $config;
-our $IMGDIR = "images";
+our $LIBDIR = ".";
+our $IMGDIR = "$LIBDIR/images";
+our $SNDDIR = "$LIBDIR/sounds";
 
 sub load_img {
-#   new_from_file Gtk::Gdk::Pixbuf "$IMGDIR/$_[0]"
-   load_image Gtk::Gdk::ImlibImage "$IMGDIR/$_[0]"
+   new_from_file Gtk::Gdk::Pixbuf "$IMGDIR/$_[0]"
+#   load_image Gtk::Gdk::ImlibImage "$IMGDIR/$_[0]"
       or die "$IMGDIR/$_[0]: $!";
 }
 
-our @black_img =       load_img "b-01.png";
-our @white_img = map +(load_img "w-0$_.png"), 1,2,3,4,5;
-our $board_img =       load_img "woodgrain-01.jpg";
+our @black_img    =       load_img "b-01.png";
+our @white_img    = map +(load_img "w-0$_.png"), 1,2,3,4,5;
+our @triangle_img = map +(load_img "triangle-$_.png"), qw(b w);
+our @square_img   = map +(load_img "square-$_.png"), qw(b w);
+our @circle_img   = map +(load_img "circle-$_.png"), qw(b w);
+our $board_img    =       load_img "woodgrain-01.jpg";
+
+{
+   #my $audioserver = new Audio::Play(0);
+   my %sound;
+   $SIG{CHLD} = 'IGNORE';
+
+   for (qw(alarm warning move)) {
+      local $/;
+      open my $snd, "<", "$SNDDIR/$_"
+         or die "$SNDDIR: $!";
+      binmode $snd;
+
+      $sound{$_} = new Audio::Data;
+      $sound{$_}->Load($snd);
+   }
+
+   sub play_sound {
+      if (fork == 0) {
+         my $audioserver = new Audio::Play(1);
+         $audioserver->play ($sound{$_[0]});
+         Gtk->_exit(0);
+      }
+   }
+}
 
 {
    use Storable ();
@@ -49,7 +77,7 @@
       hpane_position  => sub { ($_[0]->children)[0]->allocation->[2] },
       vpane_position  => sub { ($_[0]->children)[0]->allocation->[3] },
       window_size     => sub { [ @{$_[0]->allocation}[2,3] ] },
-      #window_pos     => sub { die PApp::Util::dumpval [ $_[0]->get_root_origin ] },
+      #window_pos     => sub { die KGS::Listener::Debug::dumpval [ $_[0]->get_root_origin ] },
       clist_column_widths => sub {
          $_[0]{column_widths};
       },
@@ -139,6 +167,11 @@
    }
 }
 
+if (0) {
+   my $board = new game size => 5;
+   $board->{window}->show_all;
+}
+
 main Gtk;
 
 #############################################################################
@@ -242,8 +275,6 @@
          $self->{roomlist}->join_room($_);
       }
    }
-
-   warn PApp::Util::dumpval($::config);
 }
 
 sub event_disconnect { }
@@ -448,7 +479,7 @@
 
    delete $::config->{rooms}{$self->{channel}};
    $self->{window}->hide_all;
-   $self->event_update;
+   $self->event_update_users;
    $self->event_update_games;
 }
 
@@ -489,7 +520,7 @@
    $self->listen($self->{conn});
 
    $self->{window} = new Gtk::Window 'toplevel';
-   $self->{window}->set_title("KGS Game ".$self->user0." ".$self->user1);
+   $self->{window}->set_title("KGS Game ".$self->user0." ".$self->user1) if $self->{channel};#d#
    ::state $self->{window}, "game::window", undef, window_size => [600, 500];
 
    $self->{window}->signal_connect(delete_event => sub { $self->part; 1 });
@@ -497,121 +528,14 @@
    $self->{window}->add(my $hpane = new Gtk::HPaned);
    ::state $hpane, "game::hpane", undef, hpane_position => 500;
 
-   $::config{aa} = 0;
-   $self->{canvas} = $::config{aa} ? new_aa Gnome::Canvas : new Gnome::Canvas;
-   $hpane->pack1($self->{canvas}, 1, 1);
-
-   {
-      my $line_colour = $::config{line_colour} || "darkbrown";
-      my $border      = 0.1;
-      my $ofs         = 0.5 / $self->{size};
-   
-      $self->{canvas}->set_pixels_per_unit(1000);
-      $self->{canvas}->set_scroll_region(-$border,-$border,1+$border,1+$border);
+   Gtk::Widget->push_visual (Gtk::Gdk::Rgb->get_visual);
+   Gtk::Widget->push_colormap (Gtk::Gdk::Rgb->get_cmap);
+   $hpane->pack1(($self->{canvas} = new Gtk::DrawingArea), 1, 1);
+   Gtk::Widget->pop_colormap;
+   Gtk::Widget->pop_visual;
 
-      $self->{canvas}->signal_connect(size_allocate => sub {
-         my ($w, $h) = @{$_[1]}[2,3];
-
-         $self->{canvas}->set_pixels_per_unit(($w > $h ? $h : $w)/(1+$border*2));
-
-         1;
-      });
-
-      my $croot  = $self->{canvas}->root;
-      my $cgroup = $croot; #->new($croot, "Gnome::CanvasGroup");
-
-      if ($::board_img) {
-         $cgroup->new($cgroup, "Gnome::CanvasImage",
-            x      => -$border,    y      => -$border,
-            width  => 1+$border*2, height => 1+$border*2,
-            image  => $::board_img,
-            anchor => "nw"
-         );
-      } else {
-         $cgroup->new($cgroup, "Gnome::CanvasRect",
-            x1 => -$border, x2 => 1+$border,
-            y1 => -$border, y2 => 1+$border,
-            outline_color => "black",
-            fill_color => "brown",
-            width_pixels => 2,
-         );
-      }
-
-      my $a = "A";
-      for my $i (1 .. $self->{size}) { # one more iteration for the last lines
-        my $k = $i / $self->{size} - $ofs;
-
-        $cgroup->new($cgroup, "Gnome::CanvasLine",
-           points       => [ $k,$ofs, $k,1-$ofs ],
-           fill_color   => $line_colour,
-           width_pixels => 1);
-
-        $cgroup->new($cgroup, "Gnome::CanvasLine",
-           points       => [ $ofs,$k, 1-$ofs,$k ],
-           fill_color   => $line_colour,
-           width_pixels => 1);
-
-        for ( [$k,-$border*0.5,$a], [$k,1+$border*0.5,$a],
-              [-$border*0.5,$k,$self->{size} - $i + 1], [1+$border*0.5,$k,$self->{size} - $i + 1] ) {
-           my ($x, $y, $text) = @$_;
-
-           my $text = $cgroup->new($cgroup, "Gnome::CanvasText",
-              x => 0, y => 0, text => $text,
-              justification => "center",
-              anchor        => "center",
-              font          => $::config{aa} ? "-*-helvetica-medium-r-*--34-*" : "-*-helvetica-bold-r-*--17-*",
-              fill_color    => $line_colour);
-
-           $text->affine_relative($border*0.015,0, 0,$border*0.015, $x,$y);
-        }
-
-        $a++;
-        $a++ if $a eq "I";
-      }
-
-      my $stones = [[]];
-
-      for my $x (1 .. $self->{size}) {
-         my $xk = $x / $self->{size} - $ofs;
-         for my $y (1 .. $self->{size}) {
-            my $yk = $y / $self->{size} - $ofs;
-
-            my $col = $stones->[$x-1][$y-1] = [];
-
-            if (1) {
-               $col->[0] =
-                  $cgroup->new($cgroup, "Gnome::CanvasImage",
-                     x      => $xk,    y      => $yk,
-                     width  => $ofs*2, height => $ofs*2,
-                     image  => $::black_img[int rand @::black_img],
-                     anchor => "center");
-               $col->[1] =
-                  $cgroup->new($cgroup, "Gnome::CanvasImage",
-                     x      => $xk,    y      => $yk,
-                     width  => $ofs*2, height => $ofs*2,
-                     image  => $::white_img[int rand @::white_img],
-                     anchor => "center");
-            } else {
-               die "need pixmaps\n";
-               # too large, scale has NO effect
-               $col->[0] =
-                  $cgroup->new($cgroup, "Gnome::CanvasEllipse",
-                     x1 => $xk, x2 => $xk + 0.001,
-                     y1 => $yk, y2 => $yk + 0.001,
-                     outline_color => "black", width_pixels => 2,
-                     fill_color => "black");
-               $col->[1] =
-                  $cgroup->new($cgroup, "Gnome::CanvasEllipse",
-                     x1 => $xk, x2 => $xk + 0.001,
-                     y1 => $yk, y2 => $yk + 0.001,
-                     outline_color => "black", width_pixels => 2,
-                     fill_color => "white");
-            }
-         }
-      }
-
-      $self->{board_gfx}{stones} = $stones;
-   }
+   $self->{canvas}->signal_connect(configure_event => \&configure_event, $self);
+   $self->{canvas}->signal_connect(expose_event    => \&expose_event,    $self);
 
    $hpane->pack2((my $vpane = new Gtk::VPaned), 0, 0);
    ::state $vpane, "game", $self->{name}, vpane_position => 80;
@@ -660,27 +584,246 @@
    $self->{window}->hide;
 }
 
-sub event_update_tree {
+sub configure_event {
+   my ($widget, $self, $event) = @_;
+   delete $self->{stack};
+   $self->repaint_board;
+   1;
+}
+
+sub expose_event {
+   my ($widget, $self, $event) = @_;
+
+   $self->{pixmap} or return;
+
+   my ($ox, $oy, $s) = @{$self->{offsets}};
+
+   my ($x, $y, $w, $h) =
+      @{Gtk::Gdk::Rectangle->intersect(
+          $event->{area},
+          [$ox, $oy, $s, $s]
+      )};
+
+   $self->{canvas}->window->draw_pixmap (
+      $self->{canvas}->style->white_gc,
+      $self->{pixmap},
+      $x - $ox, $y - $oy, $x, $y, $w, $h,
+   );
+   1;
+}
+
+# create new, _transparent_ pixbuf
+sub new_pixbuf {
+   my ($w, $h) = @_;
+
+   $pixbuf;
+}
+
+sub INTERP_TILES    (){ 1 }
+sub INTERP_BILINEAR (){ 2 }
+sub INTERP_HYPER    (){ 3 }
+
+sub new_pixbuf {
+   my ($w, $h, $clear) = @_;
+
+   my $pixbuf = new Gtk::Gdk::Pixbuf 'rgb', 1, 8, $w, $h;
+
+   if ($clear) { # damn, need to clear it ourselves
+      my $row = "\x00\x00\x00\x00" x $w;
+      $pixbuf->put_pixels ($row, $_, 0) for 0 .. $h - 1;
+   }
+
+   $pixbuf;
+}
+
+sub scale_pixbuf {
+   my ($src, $w, $h, $mode) = @_;
+
+   my $dst = new_pixbuf $w, $h;
+
+   $src->scale(
+      $dst, 0, 0, $w, $h, 0, 0,
+      $w / $src->get_width, $h / $src->get_height,
+      $mode,
+   );
+
+   $dst;
+}
+
+sub label_font {
+   my ($size) = @_;
+
+   $size = int $size;
+   $size = 34 if $size > 34;
+
+   # I am soo incapable
+   for (8, 10, 11, 12, 14, 17, 18, 20, 24, 25, 34) {
+      next unless $size <= $_;
+      my $font = Gtk::Gdk::Font->fontset_load ("-*-helvetica-bold-r-*--$_-*");
+      return $font if $font;
+   }
+   
+   return Gtk::Gdk::Font->fontset_load ("-*-helvetica-bold-r-*--8-*");
+}
+
+sub center_text {
+   my ($drawable, $font, $gc, $x, $y, $t) = @_;
+   my $w = $font->string_width ($t);
+   my $h = $font->string_height($t) - $font->descent;
+   $drawable->draw_text ($font, $gc, $x - $w*0.5, $y + $h * 0.5, $t, length $t);
+}
+
+# create a stack of stones
+sub create_stack {
+   my ($self, $gc, $mark, $size, $rand) = @_;
+
+   my $c = \$self->{stack}{$mark};
+   unless ($$c) {
+      for my $stone ($mark & (MARK_W | MARK_GRAY_W) ? @::white_img : @::black_img) {
+         my $base =
+            $mark & (MARK_B | MARK_GRAY_B | MARK_W | MARK_GRAY_W)
+               ? scale_pixbuf $stone, $size, $size, INTERP_HYPER
+               : new_pixbuf $size, $size, 1;
+
+         if ($mark & (MARK_GRAY_B | MARK_GRAY_W)) {
+            # make transparent by stippling :(
+            # fix this to use compositing if/when we have full compositing support
+            # in kgsueme
+            my @row = (
+                         "\xff\xff\xff\xff\x00\x00\x00\x00" x ($size / 2 + 1),
+                         "\x00\x00\x00\x00\xff\xff\xff\xff" x ($size / 2 + 1),
+                      );
+            $base->put_pixels ($base->get_pixels ($_) & $row[$_ & 1], $_, 0)
+               for 0 .. $size - 1;
+         }
+
+         for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]],
+              [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) {
+            my ($mask, $img) = @$_;
+            if ($mark & $mask) {
+               $img->composite (
+                  $base, ($size / 4) x2, (int ($size / 2 + 0.5)) x2, ($size / 4) x 2,
+                  $size / $img->get_width / 2, $size / $img->get_height / 2,
+                  INTERP_HYPER, 192
+               );
+            }
+         }
+
+         my $dark_bg = ! ! ($mark & (MARK_B | MARK_GRAY_B));
+
+         for ([MARK_CIRCLE,   $::circle_img[$dark_bg]],
+              [MARK_TRIANGLE, $::triangle_img[$dark_bg]],
+              [MARK_SQUARE,   $::square_img[$dark_bg]]) {
+           my ($mask, $img) = @$_;
+           if ($mark & $mask) {
+              $img->composite (
+                 $base, 0, 0, $size, $size, 0, 0,
+                 ($size - 1) / ($img->get_width - 1), ($size - 1) / ($img->get_height - 1),
+                 INTERP_HYPER, 255
+              );
+           }
+         }
+
+         push @$$c, [$base->render_pixmap_and_mask (128)];
+      }
+   }
+
+   @{$$c->[$rand % @$$c]};
+}
+
+sub repaint_board {
    my ($self) = @_;
+   my $canvas = $self->{canvas};
+
+   return unless $self->{board};
 
-   my $board = new KGS::Game::Board $self->{size};
-   $board->interpret_path ($self->get_path);
+   %cache = ();
+
+   my ($w, $h) = @{$canvas->allocation}[2,3];
+   
+   my $s = $w > $h ? $h : $w;
+   
+   $self->{offsets} = [int (($w - $s) / 2), int (($h - $s) / 2), $s];
 
-   for my $x (0 .. $self->{size} - 1) {
-      for my $y (0 .. $self->{size} - 1) {
-         my $v = $board->{board}[$x][$y];
-
-         $v & MARK_B
-            ? $self->{board_gfx}->{stones}->[$x][$y][0]->show
-            : $self->{board_gfx}->{stones}->[$x][$y][0]->hide;
-         $v & MARK_W
-            ? $self->{board_gfx}->{stones}->[$x][$y][1]->show
-            : $self->{board_gfx}->{stones}->[$x][$y][1]->hide;
+   my $pixmap = $self->{pixmap} = new Gtk::Gdk::Pixmap $self->{canvas}->window, $s, $s;
+
+   {
+      my ($bw, $bh) = ($::board_img->get_width, $::board_img->get_height);
+
+      my $bg = $s < $bw && $s < $bh ? $::board_img : scale_pixbuf $::board_img, $s, $s, INTERP_TILES;
+      $bg->render_to_drawable(
+         $pixmap, $self->{canvas}->style->white_gc,
+         0, 0, 0, 0, $s, $s,
+         0, 0, 0
+      );
+   }
+
+   my $gc = Gtk::Gdk::GC->new ($pixmap);
+
+   $gc->rgb_gc_set_foreground($line_colour);
+   $gc->set_line_attributes (int ($s / 300) + 1, 'solid', 'projecting', 'miter');
+
+   my $size   = $self->{size};
+   my $border = int ($s / $size);
+   my $s2     = $s - $border * 2;
+   my $edge   = int ($s2 / $size) | 1;
+   my $ofs    = int ($edge / 2);
+
+   my $font   = label_font $ofs;
+
+   my @k = map int ($s2 * $_ / $size - $ofs + $border + 0.5), 0 .. $size;
+
+   my $a = "A";
+   for my $i (1 .. $size) {
+      $pixmap->draw_line ($gc, $k[$i], $k[1], $k[$i], $k[$size]);
+      $pixmap->draw_line ($gc, $k[1], $k[$i], $k[$size], $k[$i]);
+
+      center_text $pixmap, $font, $gc, $k[$i], ($ofs +$border) / 2, $a;
+      center_text $pixmap, $font, $gc, $k[$i], $s2 + $border + $ofs / 2, $a;
+      center_text $pixmap, $font, $gc, ($ofs + $border) / 2, $k[$i], $size - $i + 1;
+      center_text $pixmap, $font, $gc, $s2 + $border + $ofs / 2, $k[$i], $size - $i + 1;
+
+      $a++;
+      $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK...
+   }
+
+   # hoshi-points(!)#d#
+   # caching of empty board gfx(!)#d#
+
+   for my $x (1 .. $size) {
+      for my $y (1 .. $size) {
+         my $yk = $s2 * $x / $size - $ofs + $border;
+         my $mark = $self->{board}{board}[$x-1][$y-1];
+
+         if ($mark) {
+            my ($dx, $dy) = ($k[$x] - $ofs, $k[$y] - $ofs);
+            my ($pm, $bm) = $self->create_stack($gc, $mark, $edge, $x * 17 + $y * 11 );
+
+            $gc->set_clip_mask ($bm);
+            $gc->set_clip_origin ($dx, $dy);
+            $pixmap->draw_pixmap ($gc, $pm, 0, 0, $dx, $dy, $edge, $edge);
+         }
       }
    }
+}
+
+sub event_update_tree {
+   my ($self) = @_;
+
+   $self->{board} = new KGS::Game::Board $self->{size};
+   $self->{board}->interpret_path ($self->get_path);
+
+   $self->repaint_board;
+
+   # force a redraw (not perfect(?))
+   expose_event $self->{canvas}, $self, { area => $self->{canvas}->allocation };
 
    $self->{text}->backward_delete($self->{text}->get_length);
-   $self->{text}->insert(undef, undef, undef, $board->{comment}.PApp::Util::dumpval([$board->{time},$board->{captures}]));
+   $self->{text}->insert(undef, undef, undef, KGS::Listener::Debug::dumpval([$self->{board}{time},$self->{board}{captures}]). $self->{board}{comment});
+}
+
+sub event_move {
+   ::play_sound "move";
 }
 
 1;