Deliantra-Client/DC/UI.pm

package Crossfire::Client::Widget;

use strict;

use Scalar::Util;

use SDL::OpenGL;
use SDL::OpenGL::Constants;

use Crossfire::Client;

our $FOCUS;  # the widget with current focus

# class methods for events
sub feed_sdl_key_down_event    { $FOCUS->key_down ($_[0])    if $FOCUS }
sub feed_sdl_key_up_event      { $FOCUS->key_up ($_[0])      if $FOCUS }
sub feed_sdl_button_down_event { }
sub feed_sdl_button_up_event   { }

sub new {
   my $class = shift;

   bless { @_ }, $class
}

sub move {
   my ($self, $x, $y, $z) = @_;
   $self->{x} = $x;
   $self->{y} = $y;
   $self->{z} = $z if defined $z;
}

sub needs_redraw {
   0
}

sub size_request {
   require Carp;
   Carp::confess "size_request is abtract";
}

sub size_allocate {
   my ($self, $w, $h) = @_;

   $self->{w} = $w;
   $self->{h} = $h;
}

sub focus_in {
   my ($widget) = @_;
   $FOCUS = $widget;
}

sub focus_out {
   my ($widget) = @_;
}

sub key_down {
   my ($widget, $sdlev) = @_;
}

sub key_up {
   my ($widget, $sdlev) = @_;
}

sub button_down {
   my ($widget, $sdlev) = @_;
}

sub button_up {
   my ($widget, $sdlev) = @_;
}

sub w { $_[0]->{w} = $_[1] if $_[1]; $_[0]->{w} }
sub h { $_[0]->{h} = $_[1] if $_[1]; $_[0]->{h} }
sub x { $_[0]->{x} = $_[1] if $_[1]; $_[0]->{x} }
sub y { $_[0]->{y} = $_[1] if $_[1]; $_[0]->{y} }
sub z { $_[0]->{z} = $_[1] if $_[1]; $_[0]->{z} }

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

   glPushMatrix;
   glTranslate $self->{x}, $self->{y}, 0;
   $self->_draw;
   glPopMatrix;
}

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

   warn "no draw defined for $self\n";
}

sub bbox {
   my ($self) = @_;
   my ($w, $h) = $self->size_request;
   (
     $self->{x},
     $self->{y},
     $self->{x} = $w,
     $self->{y} = $h
   )
}

sub find_widget {
   my ($self, $x, $y) = @_;

   return $self
      if $x >= $self->{x} && $x < $self->{x} + $self->{w}
          && $y >= $self->{y} && $y < $self->{y} + $self->{h};

   ()
}

sub del_parent { $_[0]->{parent} = undef }

sub set_parent {
   my ($self, $par) = @_;

   $self->{parent} = $par;
   Scalar::Util::weaken $self->{parent};
}

sub get_parent {
   $_[0]->{parent}
}

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

   $self->{parent}->update
      if $self->{parent};
}

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

   #$self->deactivate;
}

#############################################################################

package Crossfire::Client::Widget::Container;

our @ISA = Crossfire::Client::Widget::;

sub new {
   my ($class, @widgets) = @_;

   my $self = $class->SUPER::new (children => []);
   $self->add ($_) for @widgets;

   $self
}

sub add {
   my ($self, $chld, $expand) = @_;

   $chld->{expand} = $expand;
   $chld->set_parent ($self);

   @{$self->{children}} =
      sort { $a->{z} <=> $b->{z} }
         @{$self->{children}}, $chld;

   $self->size_allocate ($self->{w}, $self->{h})
      if $self->{w}; #TODO: check for "realised state"
}

sub remove {
   my ($self, $widget) = @_;

   $self->{children} = [ grep $_ != $widget, @{ $self->{children} } ];

   $self->size_allocate ($self->{w}, $self->{h});
}

sub find_widget {
   my ($self, $x, $y) = @_;

   $x -= $self->{x};
   $y -= $self->{y};

   my $res;

   for (reverse @{ $self->{children} }) {
      $res = $_->find_widget ($x, $y)
         and return $res;
   }

   $self->SUPER::find_widget ($x + $self->{x}, $y + $self->{y})
}

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

   $_->draw for @{$self->{children}};
}

#############################################################################

package Crossfire::Client::Widget::Bin;

our @ISA = Crossfire::Client::Widget::Container::;

sub child { $_[0]->{children}[0] }

sub size_request {
   $_[0]{children}[0]->size_request if $_[0]{children}[0];
}

sub size_allocate {
   my ($self, $w, $h) = @_;

   $self->SUPER::size_allocate ($w, $h);
   $self->{children}[0]->size_allocate ($w, $h)
      if $self->{children}[0]
}

#############################################################################

package Crossfire::Client::Widget::Toplevel;

our @ISA = Crossfire::Client::Widget::Container::;

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

   ::refresh ();
}

sub add {
   my ($self, $widget) = @_;

   $self->SUPER::add ($widget);

   $widget->size_allocate ($widget->size_request);
}

#############################################################################

package Crossfire::Client::Widget::Window;

our @ISA = Crossfire::Client::Widget::Bin::;

use SDL::OpenGL;

sub new {
   my ($class, $x, $y, $z, $w, $h) = @_;

   my $self = $class->SUPER::new;

   @$self{qw(x y z w h)} = ($x, $y, $z, $w, $h);
}

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

   $self->render_chld;
   $self->SUPER::update;
}

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

   $self->{texture} =
      Crossfire::Client::Texture->new_from_opengl (
         $self->{w}, $self->{h}, sub { $self->child->draw }
      );
}

sub size_allocate {
   my ($self, $w, $h) = @_;

   $self->{w} = $w;
   $self->{h} = $h;

   $self->child->size_allocate ($w, $h);

   $self->render_chld;
}

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

   my ($w, $h) = ($self->w, $self->h);

   my $tex = $self->{texture}
      or return;

   glEnable GL_BLEND;
   glEnable GL_TEXTURE_2D;
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
   glBindTexture GL_TEXTURE_2D, $tex->{name};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex  0,  0;
   glTexCoord 0, 1; glVertex  0, $h;
   glTexCoord 1, 1; glVertex $w, $h;
   glTexCoord 1, 0; glVertex $w,  0;
   glEnd;

   glDisable GL_BLEND;
   glDisable GL_TEXTURE_2D;
}

#############################################################################

package Crossfire::Client::Widget::Frame;

our @ISA = Crossfire::Client::Widget::Bin::;

use SDL::OpenGL;

sub size_request {
   my ($self) = @_;
   my $chld = $self->child
      or return (0, 0);

   $chld->move (2, 2);

   map { $_ + 4 } $chld->size_request;
}

sub size_allocate {
   my ($self, $w, $h) = @_;
   
   $self->{w} = $w;
   $self->{h} = $h;

   $self->child->size_allocate ($w - 4, $h - 4);
   $self->child->move (2, 2);
}

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

   my $chld = $self->child;

   my ($w, $h) = $chld->size_request;

   glBegin GL_QUADS;
   glColor 0, 0, 0;
   glTexCoord 0, 0; glVertex 0      , 0;
   glTexCoord 0, 1; glVertex 0      , $h + 4;
   glTexCoord 1, 1; glVertex $w + 4 , $h + 4;
   glTexCoord 1, 0; glVertex $w + 4 , 0;
   glEnd;

   $chld->draw;
}

#############################################################################

package Crossfire::Client::Widget::FancyFrame;

our @ISA = Crossfire::Client::Widget::Bin::;

use SDL::OpenGL;

my @tex = 
      map { new_from_file Crossfire::Client::Texture Crossfire::Client::find_rcfile $_ }
         qw(d1_bg.png d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png);

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

   my ($w, $h) = $self->SUPER::size_request;

   $h += $tex[1]->{height};
   $h += $tex[4]->{height};
   $w += $tex[2]->{width};
   $w += $tex[3]->{width};

   ($w, $h)
}

sub size_allocate {
   my ($self, $w, $h) = @_;

   $self->SUPER::size_allocate ($w, $h);

   $h -= $tex[1]->{height};
   $h -= $tex[4]->{height};
   $w -= $tex[2]->{width};
   $w -= $tex[3]->{width};

   $h = $h < 0 ? 0 : $h;
   $w = $w < 0 ? 0 : $w;

   $self->child->size_allocate ($w, $h);
   $self->child->move ($tex[3]->{width}, $tex[1]->{height});
}

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

   my ($w, $h) = ($self->{w}, $self->{h});
   my ($cw, $ch) = ($self->child->{w}, $self->child->{h});

   glEnable GL_BLEND;
   glEnable GL_TEXTURE_2D;
   glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;

   my $top = $tex[1];
   glBindTexture GL_TEXTURE_2D, $top->{name};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex 0            , 0;
   glTexCoord 0, 1; glVertex 0            , $top->{height};
   glTexCoord 1, 1; glVertex $w           , $top->{height};
   glTexCoord 1, 0; glVertex $w           , 0;
   glEnd;

   my $left = $tex[3];
   glBindTexture GL_TEXTURE_2D, $left->{name};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex 0            ,  $top->{height};
   glTexCoord 0, 1; glVertex 0            ,  $top->{height} + $ch;
   glTexCoord 1, 1; glVertex $left->{width}, $top->{height} + $ch;
   glTexCoord 1, 0; glVertex $left->{width}, $top->{height};
   glEnd;

   my $right = $tex[2];
   glBindTexture GL_TEXTURE_2D, $right->{name};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex $w - $right->{width}, $top->{height};
   glTexCoord 0, 1; glVertex $w - $right->{width}, $top->{height} + $ch;
   glTexCoord 1, 1; glVertex $w                  , $top->{height} + $ch;
   glTexCoord 1, 0; glVertex $w                  , $top->{height};
   glEnd;

   my $bottom = $tex[4];
   glBindTexture GL_TEXTURE_2D, $bottom->{name};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex 0            , $h - $bottom->{height};
   glTexCoord 0, 1; glVertex 0            , $h;
   glTexCoord 1, 1; glVertex $w           , $h;
   glTexCoord 1, 0; glVertex $w           , $h - $bottom->{height};
   glEnd;

   my $bg = $tex[0];
   glBindTexture GL_TEXTURE_2D, $bg->{name};
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
   glTexParameter  GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT;
   glTexParameter  GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT;

   my $rep_x = $cw / $bg->{width};
   my $rep_y = $ch / $bg->{height};

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex $left->{width}, $top->{height};
   glTexCoord 0, $rep_y; glVertex $left->{width}, $top->{height} + $ch;
   glTexCoord $rep_x, $rep_y; glVertex $left->{width} + $cw , $top->{height} + $ch;
   glTexCoord $rep_x, 0; glVertex $left->{width} + $cw , $top->{height};
   glEnd;

   glDisable GL_BLEND;
   glDisable GL_TEXTURE_2D;

   $self->child->draw;

}

#############################################################################

package Crossfire::Client::Widget::Table;

our @ISA = Crossfire::Client::Widget::Bin::;

use SDL::OpenGL;

sub add {
   my ($self, $x, $y, $chld) = @_;
   my $old_chld = $self->{children}[$y][$x];

   $self->{children}[$y][$x] = $chld;
   $chld->set_parent ($self);
   $self->update;
}

sub max_row_height {
   my ($self, $row) = @_;

   my $hs = 0;
   for (my $xi = 0; $xi <= $#{$self->{children}->[$row] || []}; $xi++) {
      my $c = $self->{children}->[$row]->[$xi];
      if ($c) {
         my ($w, $h) = $c->size_request;
         if ($hs < $h) { $hs = $h }
      }
   }
   return $hs;
}

sub max_col_width {
   my ($self, $col) = @_;

   my $ws = 0;
   for (my $yi = 0; $yi <= $#{$self->{children} || []}; $yi++) {
      my $c = ($self->{children}->[$yi] || [])->[$col];
      if ($c) {
         my ($w, $h) = $c->size_request;
         if ($ws < $w) { $ws = $w }
      }
   }
   return $ws;
}

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

   my ($hs, $ws) = (0, 0);

   for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
      $hs += $self->max_row_height ($yi);
   }

   for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
      my $wm = 0;
      for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {
         $wm += $self->max_col_width ($xi)
      }
      if ($ws < $wm) { $ws = $wm }
   }

   return ($ws, $hs);
}

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

   my $y = 0;
   for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
      my $x = 0;

      for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {

         my $c = $self->{children}->[$yi]->[$xi];
         if ($c) {
            $c->move ($x, $y, 0); #TODO: Move to size_request
            $c->draw if $c;
         }

         $x += $self->max_col_width ($xi);
      }

      $y += $self->max_row_height ($yi);
   }
}

#############################################################################

package Crossfire::Client::Widget::VBox;

our @ISA = Crossfire::Client::Widget::Container::;

use SDL::OpenGL;

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

   my @alloc = map [$_->size_request], @{$self->{children}};

   (
      (List::Util::max map $_->[0], @alloc),
      (List::Util::sum map $_->[1], @alloc),
   )
}

sub size_allocate {
   my ($self, $w, $h) = @_;

   $self->w ($w);
   $self->h ($h);

   my $exp;
   my @oth;
   # find expand widget
   for (@{$self->{children}}) {
      if ($_->{expand}) {
         $exp = $_;
         last;
      }
      push @oth, $_;
   }

   my ($ow, $oh);

   # get sizes of other widgets
   for (@oth) {
      my ($w, $h) = $_->size_request;
      $oh += $h;
      if ($ow < $w) { $ow = $w }
   }

   my $y = 0;
   for (@{$self->{children}}) {
      $_->move (0, $y);

      if ($_ == $exp) {
         $_->size_allocate ($w, $h - $oh);
         $y += $h - $oh;
      } else {
         my ($cw, $h) = $_->size_request;
         $_->size_allocate ($w, $h);
         $y += $h;
      }
   }
}

#############################################################################

package Crossfire::Client::Widget::Label;

our @ISA = Crossfire::Client::Widget::;

use SDL::OpenGL;

sub new {
   my ($class, $x, $y, $z, $height, $text) = @_;

   # TODO: color, and make height, xyz etc. optional
   my $self = $class->SUPER::new (x => $x, y => $y, z => $z, height => $height);

   $self->set_text ($text);

   $self
}

sub set_text {
   my ($self, $text) = @_;

   $self->{text} = $text;
   $self->{texture} = new_from_text Crossfire::Client::Texture $text, $self->{height};

   $self->update;
}

sub get_text {
   my ($self, $text) = @_;

   $self->{text}
}

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

   (
      $self->{texture}{width},
      $self->{texture}{height},
   )
}

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

   my $tex = $self->{texture};

   glEnable GL_BLEND;
   glEnable GL_TEXTURE_2D;
   glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
   glBindTexture GL_TEXTURE_2D, $tex->{name};

   glColor 1, 0, 0, 1; # TODO color

   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex 0            , 0;
   glTexCoord 0, 1; glVertex 0            , $tex->{height};
   glTexCoord 1, 1; glVertex $tex->{width}, $tex->{height};
   glTexCoord 1, 0; glVertex $tex->{width}, 0;
   glEnd;

   glDisable GL_BLEND;
   glDisable GL_TEXTURE_2D;
}

#############################################################################

package Crossfire::Client::Widget::TextEntry;

our @ISA = Crossfire::Client::Widget::Label::;

use SDL;
use SDL::OpenGL;

sub key_down {
   my ($self, $ev) = @_;

   my $mod = $ev->key_mod;
   my $sym = $ev->key_sym;

   $ev->set_unicode (1);
   my $uni = $ev->key_unicode;

   my $text = $self->get_text;

   if ($sym == SDLK_BACKSPACE) {
      substr $text, -1, 1, '';

   } elsif ($uni) {
      $text .= chr $uni;
   }
   $self->set_text ($text);
}

#############################################################################

package Crossfire::Client::Widget::MapWidget;

use strict;

use List::Util qw(min max);

use SDL;
use SDL::OpenGL;
use SDL::OpenGL::Constants;

our @ISA = Crossfire::Client::Widget::;

sub key_down {
   print "MAPKEYDOWN\n";
}

sub key_up {
}

sub size_request {

}

sub size_allocate {
}

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

   my $mx = $::CONN->{mapx};
   my $my = $::CONN->{mapy};

   my $map = $::CONN->{map};

   my ($xofs, $yofs);

   my $sw = 1 + int $::WIDTH  / 32;
   my $sh = 1 + int $::HEIGHT / 32;

   if ($::CONN->{mapw} > $sw) {
      $xofs = $mx + ($::CONN->{mapw} - $sw) * 0.5;
   } else {
      $xofs = $self->{xofs} = min $mx, max $mx + $::CONN->{mapw} - $sw + 1, $self->{xofs};
   }

   if ($::CONN->{maph} > $sh) {
      $yofs = $my + ($::CONN->{maph} - $sh) * 0.5;
   } else {
      $yofs = $self->{yofs} = min $my, max $my + $::CONN->{maph} - $sh + 1, $self->{yofs};
   }

   glEnable GL_TEXTURE_2D;
   glEnable GL_BLEND;
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;

   my $sw4 = ($sw + 3) & ~3;
   my $lighting = "\x00" x ($sw4 * $sh);

   for my $x (0 .. $sw - 1) {
      for my $y (0 .. $sh - 1) {

         my $cell = $map->[$x + $xofs][$y + $yofs]
            or next;

         my $darkness = $cell->[0] * (1 / 255);
         if ($darkness < 0) {
            $darkness = 0.15;
         }
         substr $lighting, $y * $sw4 + $x, 1, chr 255 - $darkness * 255;

         for my $num (grep $_, @$cell[1,2,3]) {
            my $tex = $::CONN->{face}[$num]{texture} || next;

            glBindTexture GL_TEXTURE_2D, $tex->{name};

            my $w = $tex->{width};
            my $h = $tex->{height};

            my $px = ($x + 1) * 32 - $w;
            my $py = ($y + 1) * 32 - $h;

            glBegin GL_QUADS;
            glTexCoord 0, 0; glVertex $px     , $py;
            glTexCoord 0, 1; glVertex $px     , $py + $h;
            glTexCoord 1, 1; glVertex $px + $w, $py + $h;
            glTexCoord 1, 0; glVertex $px + $w, $py;
            glEnd;
         }
      }
   }

#   if (1) { # higher quality darkness
#      $lighting =~ s/(.)/$1$1$1/gs;
#      my $pb = new_from_data Gtk2::Gdk::Pixbuf $lighting, "rgb", 0, 8, $sw4, $sh, $sw4 * 3;
#
#      $pb = $pb->scale_simple ($sw4 * 0.5, $sh * 0.5, "bilinear");
#
#      $lighting = $pb->get_pixels;
#      $lighting =~ s/(.)../$1/gs;
#   }

   $lighting = new Crossfire::Client::Texture
      width          => $sw4,
      height         => $sh,
      data           => $lighting,
      internalformat => GL_ALPHA4,
      format         => GL_ALPHA;

   glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
   glColor 0, 0, 0, 0.75;
   glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
   glBindTexture GL_TEXTURE_2D, $lighting->{name};
   glTexParameter GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR;
   glBegin GL_QUADS;
   glTexCoord 0, 0; glVertex 0        , 0;
   glTexCoord 0, 1; glVertex 0        , $sh * 32;
   glTexCoord 1, 1; glVertex $sw4 * 32, $sh * 32;
   glTexCoord 1, 0; glVertex $sw4 * 32, 0;
   glEnd;

   glDisable GL_TEXTURE_2D;
   glDisable GL_BLEND;
}

my %DIR = (
   SDLK_KP8, [1, "north"],
   SDLK_KP9, [2, "northeast"],
   SDLK_KP6, [3, "east"],
   SDLK_KP3, [4, "southeast"],
   SDLK_KP2, [5, "south"],
   SDLK_KP1, [6, "southwest"],
   SDLK_KP4, [7, "west"],
   SDLK_KP7, [8, "northwest"],

   SDLK_UP,    [1, "north"],
   SDLK_RIGHT, [3, "east"],
   SDLK_DOWN,  [5, "south"],
   SDLK_LEFT,  [7, "west"],
);

sub key_down {
   my ($self, $ev) = @_;

   my $mod = $ev->key_mod;
   my $sym = $ev->key_sym;

   if ($sym == SDLK_KP5) {
      $::CONN->send ("command stay fire");
   } elsif (exists $DIR{$sym}) {
      if ($mod & KMOD_SHIFT) {
         $self->{shft}++;
         $::CONN->send ("command fire $DIR{$sym}[0]");
      } elsif ($mod & KMOD_CTRL) {
         $self->{ctrl}++;
         $::CONN->send ("command run $DIR{$sym}[0]");
      } else {
         $::CONN->send ("command $DIR{$sym}[1]");
      }
   }
}

sub key_up {
   my ($self, $ev) = @_;

   my $mod = $ev->key_mod;
   my $sym = $ev->key_sym;

   if (!($mod & KMOD_SHIFT) && delete $self->{shft}) {
      $::CONN->send ("command fire_stop");
   }
   if (!($mod & KMOD_CTRL ) && delete $self->{ctrl}) {
      $::CONN->send ("command run_stop");
   }
}

#############################################################################

package Crossfire::Client::Widget::Animator;

use SDL::OpenGL;

our @ISA = Crossfire::Client::Widget::Bin::;

sub moveto {
   my ($self, $x, $y) = @_;

   $self->{moveto} = [$self->{x}, $self->{y}, $x, $y];
   $self->{speed}  = 0.2;
   $self->{time}   = 1;
   
   ::animation_start $self;
}

sub animate {
   my ($self, $interval) = @_;

   $self->{time} -= $interval * $self->{speed};
   if ($self->{time} <= 0) {
      $self->{time} = 0;
      ::animation_stop $self;
   }

   my ($x0, $y0, $x1, $y1) = @{$self->{moveto}};
      
   $self->{x} = $x0 * $self->{time} + $x1 * (1 - $self->{time});
   $self->{y} = $y0 * $self->{time} + $y1 * (1 - $self->{time});
}

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

   glPushMatrix;
   glRotate $self->{time} * 10000, 0, 1, 0;
   $self->{children}[0]->draw;
   glPopMatrix;
}

1;

Revision:	1.46
Committed:	Sun Apr 9 22:21:02 2006 UTC (18 years, 2 months ago) by root
Branch:	MAIN
Changes since 1.45:	+2 -2 lines
Log Message:	* empty log message *
#	Content
1	package Crossfire::Client::Widget;
2
3	use strict;
4
5	use Scalar::Util;
6
7	use SDL::OpenGL;
8	use SDL::OpenGL::Constants;
9
10	use Crossfire::Client;
11
12	our $FOCUS; # the widget with current focus
13
14	# class methods for events
15	sub feed_sdl_key_down_event { $FOCUS->key_down ($_[0]) if $FOCUS }
16	sub feed_sdl_key_up_event { $FOCUS->key_up ($_[0]) if $FOCUS }
17	sub feed_sdl_button_down_event { }
18	sub feed_sdl_button_up_event { }
19
20	sub new {
21	my $class = shift;
22
23	bless { @_ }, $class
24	}
25
26	sub move {
27	my ($self, $x, $y, $z) = @_;
28	$self->{x} = $x;
29	$self->{y} = $y;
30	$self->{z} = $z if defined $z;
31	}
32
33	sub needs_redraw {
34	0
35	}
36
37	sub size_request {
38	require Carp;
39	Carp::confess "size_request is abtract";
40	}
41
42	sub size_allocate {
43	my ($self, $w, $h) = @_;
44
45	$self->{w} = $w;
46	$self->{h} = $h;
47	}
48
49	sub focus_in {
50	my ($widget) = @_;
51	$FOCUS = $widget;
52	}
53
54	sub focus_out {
55	my ($widget) = @_;
56	}
57
58	sub key_down {
59	my ($widget, $sdlev) = @_;
60	}
61
62	sub key_up {
63	my ($widget, $sdlev) = @_;
64	}
65
66	sub button_down {
67	my ($widget, $sdlev) = @_;
68	}
69
70	sub button_up {
71	my ($widget, $sdlev) = @_;
72	}
73
74	sub w { $_[0]->{w} = $_[1] if $_[1]; $_[0]->{w} }
75	sub h { $_[0]->{h} = $_[1] if $_[1]; $_[0]->{h} }
76	sub x { $_[0]->{x} = $_[1] if $_[1]; $_[0]->{x} }
77	sub y { $_[0]->{y} = $_[1] if $_[1]; $_[0]->{y} }
78	sub z { $_[0]->{z} = $_[1] if $_[1]; $_[0]->{z} }
79
80	sub draw {
81	my ($self) = @_;
82
83	glPushMatrix;
84	glTranslate $self->{x}, $self->{y}, 0;
85	$self->_draw;
86	glPopMatrix;
87	}
88
89	sub _draw {
90	my ($self) = @_;
91
92	warn "no draw defined for $self\n";
93	}
94
95	sub bbox {
96	my ($self) = @_;
97	my ($w, $h) = $self->size_request;
98	(
99	$self->{x},
100	$self->{y},
101	$self->{x} = $w,
102	$self->{y} = $h
103	)
104	}
105
106	sub find_widget {
107	my ($self, $x, $y) = @_;
108
109	return $self
110	if $x >= $self->{x} && $x < $self->{x} + $self->{w}
111	&& $y >= $self->{y} && $y < $self->{y} + $self->{h};
112
113	()
114	}
115
116	sub del_parent { $_[0]->{parent} = undef }
117
118	sub set_parent {
119	my ($self, $par) = @_;
120
121	$self->{parent} = $par;
122	Scalar::Util::weaken $self->{parent};
123	}
124
125	sub get_parent {
126	$_[0]->{parent}
127	}
128
129	sub update {
130	my ($self) = @_;
131
132	$self->{parent}->update
133	if $self->{parent};
134	}
135
136	sub DESTROY {
137	my ($self) = @_;
138
139	#$self->deactivate;
140	}
141
142	#############################################################################
143
144	package Crossfire::Client::Widget::Container;
145
146	our @ISA = Crossfire::Client::Widget::;
147
148	sub new {
149	my ($class, @widgets) = @_;
150
151	my $self = $class->SUPER::new (children => []);
152	$self->add ($_) for @widgets;
153
154	$self
155	}
156
157	sub add {
158	my ($self, $chld, $expand) = @_;
159
160	$chld->{expand} = $expand;
161	$chld->set_parent ($self);
162
163	@{$self->{children}} =
164	sort { $a->{z} <=> $b->{z} }
165	@{$self->{children}}, $chld;
166
167	$self->size_allocate ($self->{w}, $self->{h})
168	if $self->{w}; #TODO: check for "realised state"
169	}
170
171	sub remove {
172	my ($self, $widget) = @_;
173
174	$self->{children} = [ grep $_ != $widget, @{ $self->{children} } ];
175
176	$self->size_allocate ($self->{w}, $self->{h});
177	}
178
179	sub find_widget {
180	my ($self, $x, $y) = @_;
181
182	$x -= $self->{x};
183	$y -= $self->{y};
184
185	my $res;
186
187	for (reverse @{ $self->{children} }) {
188	$res = $_->find_widget ($x, $y)
189	and return $res;
190	}
191
192	$self->SUPER::find_widget ($x + $self->{x}, $y + $self->{y})
193	}
194
195	sub _draw {
196	my ($self) = @_;
197
198	$_->draw for @{$self->{children}};
199	}
200
201	#############################################################################
202
203	package Crossfire::Client::Widget::Bin;
204
205	our @ISA = Crossfire::Client::Widget::Container::;
206
207	sub child { $_[0]->{children}[0] }
208
209	sub size_request {
210	$_[0]{children}[0]->size_request if $_[0]{children}[0];
211	}
212
213	sub size_allocate {
214	my ($self, $w, $h) = @_;
215
216	$self->SUPER::size_allocate ($w, $h);
217	$self->{children}[0]->size_allocate ($w, $h)
218	if $self->{children}[0]
219	}
220
221	#############################################################################
222
223	package Crossfire::Client::Widget::Toplevel;
224
225	our @ISA = Crossfire::Client::Widget::Container::;
226
227	sub update {
228	my ($self) = @_;
229
230	::refresh ();
231	}
232
233	sub add {
234	my ($self, $widget) = @_;
235
236	$self->SUPER::add ($widget);
237
238	$widget->size_allocate ($widget->size_request);
239	}
240
241	#############################################################################
242
243	package Crossfire::Client::Widget::Window;
244
245	our @ISA = Crossfire::Client::Widget::Bin::;
246
247	use SDL::OpenGL;
248
249	sub new {
250	my ($class, $x, $y, $z, $w, $h) = @_;
251
252	my $self = $class->SUPER::new;
253
254	@$self{qw(x y z w h)} = ($x, $y, $z, $w, $h);
255	}
256
257	sub update {
258	my ($self) = @_;
259
260	$self->render_chld;
261	$self->SUPER::update;
262	}
263
264	sub render_chld {
265	my ($self) = @_;
266
267	$self->{texture} =
268	Crossfire::Client::Texture->new_from_opengl (
269	$self->{w}, $self->{h}, sub { $self->child->draw }
270	);
271	}
272
273	sub size_allocate {
274	my ($self, $w, $h) = @_;
275
276	$self->{w} = $w;
277	$self->{h} = $h;
278
279	$self->child->size_allocate ($w, $h);
280
281	$self->render_chld;
282	}
283
284	sub _draw {
285	my ($self) = @_;
286
287	my ($w, $h) = ($self->w, $self->h);
288
289	my $tex = $self->{texture}
290	or return;
291
292	glEnable GL_BLEND;
293	glEnable GL_TEXTURE_2D;
294	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
295	glBindTexture GL_TEXTURE_2D, $tex->{name};
296
297	glBegin GL_QUADS;
298	glTexCoord 0, 0; glVertex 0, 0;
299	glTexCoord 0, 1; glVertex 0, $h;
300	glTexCoord 1, 1; glVertex $w, $h;
301	glTexCoord 1, 0; glVertex $w, 0;
302	glEnd;
303
304	glDisable GL_BLEND;
305	glDisable GL_TEXTURE_2D;
306	}
307
308	#############################################################################
309
310	package Crossfire::Client::Widget::Frame;
311
312	our @ISA = Crossfire::Client::Widget::Bin::;
313
314	use SDL::OpenGL;
315
316	sub size_request {
317	my ($self) = @_;
318	my $chld = $self->child
319	or return (0, 0);
320
321	$chld->move (2, 2);
322
323	map { $_ + 4 } $chld->size_request;
324	}
325
326	sub size_allocate {
327	my ($self, $w, $h) = @_;
328
329	$self->{w} = $w;
330	$self->{h} = $h;
331
332	$self->child->size_allocate ($w - 4, $h - 4);
333	$self->child->move (2, 2);
334	}
335
336	sub _draw {
337	my ($self) = @_;
338
339	my $chld = $self->child;
340
341	my ($w, $h) = $chld->size_request;
342
343	glBegin GL_QUADS;
344	glColor 0, 0, 0;
345	glTexCoord 0, 0; glVertex 0 , 0;
346	glTexCoord 0, 1; glVertex 0 , $h + 4;
347	glTexCoord 1, 1; glVertex $w + 4 , $h + 4;
348	glTexCoord 1, 0; glVertex $w + 4 , 0;
349	glEnd;
350
351	$chld->draw;
352	}
353
354	#############################################################################
355
356	package Crossfire::Client::Widget::FancyFrame;
357
358	our @ISA = Crossfire::Client::Widget::Bin::;
359
360	use SDL::OpenGL;
361
362	my @tex =
363	map { new_from_file Crossfire::Client::Texture Crossfire::Client::find_rcfile $_ }
364	qw(d1_bg.png d1_border_top.png d1_border_right.png d1_border_left.png d1_border_bottom.png);
365
366	sub size_request {
367	my ($self) = @_;
368
369	my ($w, $h) = $self->SUPER::size_request;
370
371	$h += $tex[1]->{height};
372	$h += $tex[4]->{height};
373	$w += $tex[2]->{width};
374	$w += $tex[3]->{width};
375
376	($w, $h)
377	}
378
379	sub size_allocate {
380	my ($self, $w, $h) = @_;
381
382	$self->SUPER::size_allocate ($w, $h);
383
384	$h -= $tex[1]->{height};
385	$h -= $tex[4]->{height};
386	$w -= $tex[2]->{width};
387	$w -= $tex[3]->{width};
388
389	$h = $h < 0 ? 0 : $h;
390	$w = $w < 0 ? 0 : $w;
391
392	$self->child->size_allocate ($w, $h);
393	$self->child->move ($tex[3]->{width}, $tex[1]->{height});
394	}
395
396	sub _draw {
397	my ($self) = @_;
398
399	my ($w, $h) = ($self->{w}, $self->{h});
400	my ($cw, $ch) = ($self->child->{w}, $self->child->{h});
401
402	glEnable GL_BLEND;
403	glEnable GL_TEXTURE_2D;
404	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
405	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
406
407	my $top = $tex[1];
408	glBindTexture GL_TEXTURE_2D, $top->{name};
409
410	glBegin GL_QUADS;
411	glTexCoord 0, 0; glVertex 0 , 0;
412	glTexCoord 0, 1; glVertex 0 , $top->{height};
413	glTexCoord 1, 1; glVertex $w , $top->{height};
414	glTexCoord 1, 0; glVertex $w , 0;
415	glEnd;
416
417	my $left = $tex[3];
418	glBindTexture GL_TEXTURE_2D, $left->{name};
419
420	glBegin GL_QUADS;
421	glTexCoord 0, 0; glVertex 0 , $top->{height};
422	glTexCoord 0, 1; glVertex 0 , $top->{height} + $ch;
423	glTexCoord 1, 1; glVertex $left->{width}, $top->{height} + $ch;
424	glTexCoord 1, 0; glVertex $left->{width}, $top->{height};
425	glEnd;
426
427	my $right = $tex[2];
428	glBindTexture GL_TEXTURE_2D, $right->{name};
429
430	glBegin GL_QUADS;
431	glTexCoord 0, 0; glVertex $w - $right->{width}, $top->{height};
432	glTexCoord 0, 1; glVertex $w - $right->{width}, $top->{height} + $ch;
433	glTexCoord 1, 1; glVertex $w , $top->{height} + $ch;
434	glTexCoord 1, 0; glVertex $w , $top->{height};
435	glEnd;
436
437	my $bottom = $tex[4];
438	glBindTexture GL_TEXTURE_2D, $bottom->{name};
439
440	glBegin GL_QUADS;
441	glTexCoord 0, 0; glVertex 0 , $h - $bottom->{height};
442	glTexCoord 0, 1; glVertex 0 , $h;
443	glTexCoord 1, 1; glVertex $w , $h;
444	glTexCoord 1, 0; glVertex $w , $h - $bottom->{height};
445	glEnd;
446
447	my $bg = $tex[0];
448	glBindTexture GL_TEXTURE_2D, $bg->{name};
449	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
450	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT;
451	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT;
452
453	my $rep_x = $cw / $bg->{width};
454	my $rep_y = $ch / $bg->{height};
455
456	glBegin GL_QUADS;
457	glTexCoord 0, 0; glVertex $left->{width}, $top->{height};
458	glTexCoord 0, $rep_y; glVertex $left->{width}, $top->{height} + $ch;
459	glTexCoord $rep_x, $rep_y; glVertex $left->{width} + $cw , $top->{height} + $ch;
460	glTexCoord $rep_x, 0; glVertex $left->{width} + $cw , $top->{height};
461	glEnd;
462
463	glDisable GL_BLEND;
464	glDisable GL_TEXTURE_2D;
465
466	$self->child->draw;
467
468	}
469
470	#############################################################################
471
472	package Crossfire::Client::Widget::Table;
473
474	our @ISA = Crossfire::Client::Widget::Bin::;
475
476	use SDL::OpenGL;
477
478	sub add {
479	my ($self, $x, $y, $chld) = @_;
480	my $old_chld = $self->{children}[$y][$x];
481
482	$self->{children}[$y][$x] = $chld;
483	$chld->set_parent ($self);
484	$self->update;
485	}
486
487	sub max_row_height {
488	my ($self, $row) = @_;
489
490	my $hs = 0;
491	for (my $xi = 0; $xi <= $#{$self->{children}->[$row] \|\| []}; $xi++) {
492	my $c = $self->{children}->[$row]->[$xi];
493	if ($c) {
494	my ($w, $h) = $c->size_request;
495	if ($hs < $h) { $hs = $h }
496	}
497	}
498	return $hs;
499	}
500
501	sub max_col_width {
502	my ($self, $col) = @_;
503
504	my $ws = 0;
505	for (my $yi = 0; $yi <= $#{$self->{children} \|\| []}; $yi++) {
506	my $c = ($self->{children}->[$yi] \|\| [])->[$col];
507	if ($c) {
508	my ($w, $h) = $c->size_request;
509	if ($ws < $w) { $ws = $w }
510	}
511	}
512	return $ws;
513	}
514
515	sub size_request {
516	my ($self) = @_;
517
518	my ($hs, $ws) = (0, 0);
519
520	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
521	$hs += $self->max_row_height ($yi);
522	}
523
524	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
525	my $wm = 0;
526	for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {
527	$wm += $self->max_col_width ($xi)
528	}
529	if ($ws < $wm) { $ws = $wm }
530	}
531
532	return ($ws, $hs);
533	}
534
535	sub _draw {
536	my ($self) = @_;
537
538	my $y = 0;
539	for (my $yi = 0; $yi <= $#{$self->{children}}; $yi++) {
540	my $x = 0;
541
542	for (my $xi = 0; $xi <= $#{$self->{children}->[$yi]}; $xi++) {
543
544	my $c = $self->{children}->[$yi]->[$xi];
545	if ($c) {
546	$c->move ($x, $y, 0); #TODO: Move to size_request
547	$c->draw if $c;
548	}
549
550	$x += $self->max_col_width ($xi);
551	}
552
553	$y += $self->max_row_height ($yi);
554	}
555	}
556
557	#############################################################################
558
559	package Crossfire::Client::Widget::VBox;
560
561	our @ISA = Crossfire::Client::Widget::Container::;
562
563	use SDL::OpenGL;
564
565	sub size_request {
566	my ($self) = @_;
567
568	my @alloc = map [$_->size_request], @{$self->{children}};
569
570	(
571	(List::Util::max map $_->[0], @alloc),
572	(List::Util::sum map $_->[1], @alloc),
573	)
574	}
575
576	sub size_allocate {
577	my ($self, $w, $h) = @_;
578
579	$self->w ($w);
580	$self->h ($h);
581
582	my $exp;
583	my @oth;
584	# find expand widget
585	for (@{$self->{children}}) {
586	if ($_->{expand}) {
587	$exp = $_;
588	last;
589	}
590	push @oth, $_;
591	}
592
593	my ($ow, $oh);
594
595	# get sizes of other widgets
596	for (@oth) {
597	my ($w, $h) = $_->size_request;
598	$oh += $h;
599	if ($ow < $w) { $ow = $w }
600	}
601
602	my $y = 0;
603	for (@{$self->{children}}) {
604	$_->move (0, $y);
605
606	if ($_ == $exp) {
607	$_->size_allocate ($w, $h - $oh);
608	$y += $h - $oh;
609	} else {
610	my ($cw, $h) = $_->size_request;
611	$_->size_allocate ($w, $h);
612	$y += $h;
613	}
614	}
615	}
616
617	#############################################################################
618
619	package Crossfire::Client::Widget::Label;
620
621	our @ISA = Crossfire::Client::Widget::;
622
623	use SDL::OpenGL;
624
625	sub new {
626	my ($class, $x, $y, $z, $height, $text) = @_;
627
628	# TODO: color, and make height, xyz etc. optional
629	my $self = $class->SUPER::new (x => $x, y => $y, z => $z, height => $height);
630
631	$self->set_text ($text);
632
633	$self
634	}
635
636	sub set_text {
637	my ($self, $text) = @_;
638
639	$self->{text} = $text;
640	$self->{texture} = new_from_text Crossfire::Client::Texture $text, $self->{height};
641
642	$self->update;
643	}
644
645	sub get_text {
646	my ($self, $text) = @_;
647
648	$self->{text}
649	}
650
651	sub size_request {
652	my ($self) = @_;
653
654	(
655	$self->{texture}{width},
656	$self->{texture}{height},
657	)
658	}
659
660	sub _draw {
661	my ($self) = @_;
662
663	my $tex = $self->{texture};
664
665	glEnable GL_BLEND;
666	glEnable GL_TEXTURE_2D;
667	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
668	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
669	glBindTexture GL_TEXTURE_2D, $tex->{name};
670
671	glColor 1, 0, 0, 1; # TODO color
672
673	glBegin GL_QUADS;
674	glTexCoord 0, 0; glVertex 0 , 0;
675	glTexCoord 0, 1; glVertex 0 , $tex->{height};
676	glTexCoord 1, 1; glVertex $tex->{width}, $tex->{height};
677	glTexCoord 1, 0; glVertex $tex->{width}, 0;
678	glEnd;
679
680	glDisable GL_BLEND;
681	glDisable GL_TEXTURE_2D;
682	}
683
684	#############################################################################
685
686	package Crossfire::Client::Widget::TextEntry;
687
688	our @ISA = Crossfire::Client::Widget::Label::;
689
690	use SDL;
691	use SDL::OpenGL;
692
693	sub key_down {
694	my ($self, $ev) = @_;
695
696	my $mod = $ev->key_mod;
697	my $sym = $ev->key_sym;
698
699	$ev->set_unicode (1);
700	my $uni = $ev->key_unicode;
701
702	my $text = $self->get_text;
703
704	if ($sym == SDLK_BACKSPACE) {
705	substr $text, -1, 1, '';
706
707	} elsif ($uni) {
708	$text .= chr $uni;
709	}
710	$self->set_text ($text);
711	}
712
713	#############################################################################
714
715	package Crossfire::Client::Widget::MapWidget;
716
717	use strict;
718
719	use List::Util qw(min max);
720
721	use SDL;
722	use SDL::OpenGL;
723	use SDL::OpenGL::Constants;
724
725	our @ISA = Crossfire::Client::Widget::;
726
727	sub key_down {
728	print "MAPKEYDOWN\n";
729	}
730
731	sub key_up {
732	}
733
734	sub size_request {
735
736	}
737
738	sub size_allocate {
739	}
740
741	sub _draw {
742	my ($self) = @_;
743
744	my $mx = $::CONN->{mapx};
745	my $my = $::CONN->{mapy};
746
747	my $map = $::CONN->{map};
748
749	my ($xofs, $yofs);
750
751	my $sw = 1 + int $::WIDTH / 32;
752	my $sh = 1 + int $::HEIGHT / 32;
753
754	if ($::CONN->{mapw} > $sw) {
755	$xofs = $mx + ($::CONN->{mapw} - $sw) * 0.5;
756	} else {
757	$xofs = $self->{xofs} = min $mx, max $mx + $::CONN->{mapw} - $sw + 1, $self->{xofs};
758	}
759
760	if ($::CONN->{maph} > $sh) {
761	$yofs = $my + ($::CONN->{maph} - $sh) * 0.5;
762	} else {
763	$yofs = $self->{yofs} = min $my, max $my + $::CONN->{maph} - $sh + 1, $self->{yofs};
764	}
765
766	glEnable GL_TEXTURE_2D;
767	glEnable GL_BLEND;
768	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE;
769
770	my $sw4 = ($sw + 3) & ~3;
771	my $lighting = "\x00" x ($sw4 * $sh);
772
773	for my $x (0 .. $sw - 1) {
774	for my $y (0 .. $sh - 1) {
775
776	my $cell = $map->[$x + $xofs][$y + $yofs]
777	or next;
778
779	my $darkness = $cell->[0] * (1 / 255);
780	if ($darkness < 0) {
781	$darkness = 0.15;
782	}
783	substr $lighting, $y * $sw4 + $x, 1, chr 255 - $darkness * 255;
784
785	for my $num (grep $_, @$cell[1,2,3]) {
786	my $tex = $::CONN->{face}[$num]{texture} \|\| next;
787
788	glBindTexture GL_TEXTURE_2D, $tex->{name};
789
790	my $w = $tex->{width};
791	my $h = $tex->{height};
792
793	my $px = ($x + 1) * 32 - $w;
794	my $py = ($y + 1) * 32 - $h;
795
796	glBegin GL_QUADS;
797	glTexCoord 0, 0; glVertex $px , $py;
798	glTexCoord 0, 1; glVertex $px , $py + $h;
799	glTexCoord 1, 1; glVertex $px + $w, $py + $h;
800	glTexCoord 1, 0; glVertex $px + $w, $py;
801	glEnd;
802	}
803	}
804	}
805
806	# if (1) { # higher quality darkness
807	# $lighting =~ s/(.)/$1$1$1/gs;
808	# my $pb = new_from_data Gtk2::Gdk::Pixbuf $lighting, "rgb", 0, 8, $sw4, $sh, $sw4 * 3;
809	#
810	# $pb = $pb->scale_simple ($sw4 * 0.5, $sh * 0.5, "bilinear");
811	#
812	# $lighting = $pb->get_pixels;
813	# $lighting =~ s/(.)../$1/gs;
814	# }
815
816	$lighting = new Crossfire::Client::Texture
817	width => $sw4,
818	height => $sh,
819	data => $lighting,
820	internalformat => GL_ALPHA4,
821	format => GL_ALPHA;
822
823	glBlendFunc GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA;
824	glColor 0, 0, 0, 0.75;
825	glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;
826	glBindTexture GL_TEXTURE_2D, $lighting->{name};
827	glTexParameter GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR;
828	glBegin GL_QUADS;
829	glTexCoord 0, 0; glVertex 0 , 0;
830	glTexCoord 0, 1; glVertex 0 , $sh * 32;
831	glTexCoord 1, 1; glVertex $sw4 * 32, $sh * 32;
832	glTexCoord 1, 0; glVertex $sw4 * 32, 0;
833	glEnd;
834
835	glDisable GL_TEXTURE_2D;
836	glDisable GL_BLEND;
837	}
838
839	my %DIR = (
840	SDLK_KP8, [1, "north"],
841	SDLK_KP9, [2, "northeast"],
842	SDLK_KP6, [3, "east"],
843	SDLK_KP3, [4, "southeast"],
844	SDLK_KP2, [5, "south"],
845	SDLK_KP1, [6, "southwest"],
846	SDLK_KP4, [7, "west"],
847	SDLK_KP7, [8, "northwest"],
848
849	SDLK_UP, [1, "north"],
850	SDLK_RIGHT, [3, "east"],
851	SDLK_DOWN, [5, "south"],
852	SDLK_LEFT, [7, "west"],
853	);
854
855	sub key_down {
856	my ($self, $ev) = @_;
857
858	my $mod = $ev->key_mod;
859	my $sym = $ev->key_sym;
860
861	if ($sym == SDLK_KP5) {
862	$::CONN->send ("command stay fire");
863	} elsif (exists $DIR{$sym}) {
864	if ($mod & KMOD_SHIFT) {
865	$self->{shft}++;
866	$::CONN->send ("command fire $DIR{$sym}[0]");
867	} elsif ($mod & KMOD_CTRL) {
868	$self->{ctrl}++;
869	$::CONN->send ("command run $DIR{$sym}[0]");
870	} else {
871	$::CONN->send ("command $DIR{$sym}[1]");
872	}
873	}
874	}
875
876	sub key_up {
877	my ($self, $ev) = @_;
878
879	my $mod = $ev->key_mod;
880	my $sym = $ev->key_sym;
881
882	if (!($mod & KMOD_SHIFT) && delete $self->{shft}) {
883	$::CONN->send ("command fire_stop");
884	}
885	if (!($mod & KMOD_CTRL ) && delete $self->{ctrl}) {
886	$::CONN->send ("command run_stop");
887	}
888	}
889
890	#############################################################################
891
892	package Crossfire::Client::Widget::Animator;
893
894	use SDL::OpenGL;
895
896	our @ISA = Crossfire::Client::Widget::Bin::;
897
898	sub moveto {
899	my ($self, $x, $y) = @_;
900
901	$self->{moveto} = [$self->{x}, $self->{y}, $x, $y];
902	$self->{speed} = 0.2;
903	$self->{time} = 1;
904
905	::animation_start $self;
906	}
907
908	sub animate {
909	my ($self, $interval) = @_;
910
911	$self->{time} -= $interval * $self->{speed};
912	if ($self->{time} <= 0) {
913	$self->{time} = 0;
914	::animation_stop $self;
915	}
916
917	my ($x0, $y0, $x1, $y1) = @{$self->{moveto}};
918
919	$self->{x} = $x0 * $self->{time} + $x1 * (1 - $self->{time});
920	$self->{y} = $y0 * $self->{time} + $y1 * (1 - $self->{time});
921	}
922
923	sub _draw {
924	my ($self) = @_;
925
926	glPushMatrix;
927	glRotate $self->{time} * 10000, 0, 1, 0;
928	$self->{children}[0]->draw;
929	glPopMatrix;
930	}
931
932	1;
933