#
#  Copyright (c) 1997-2002 The Protein Laboratory, University of Copenhagen
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:
#  1. Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
#  2. Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
#  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
#  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
#  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
#  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
#  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
#  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
#  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
#  SUCH DAMAGE.
#
#  Created by Dmitry Karasik <dk@plab.ku.dk>
#
#  $Id: dock.pl,v 1.8 2002/05/14 13:22:26 dk Exp $
#

=pod 
=item NAME

  Docking widgets

=item FEATURES

 This is the demonstration of Prima::Dock and Prima::DockManager 
 modules. The window created is docking client, and it's able 
 to accept toolbars and panels, and toolbars in turn accept buttons.
 buttons are very samplish; there are two panels, Edit and Banner,
 that are docked in different ways.
 Note the following unevident features:
  - popup on the border of the window ( and the Customize command there)
  - dragging of buttons on the window and the extreior
  - dragging panels and toolbar to the exterior
  - storing of the geometry in the ~/.demo_dock file
  
=cut

use strict;

use Prima;
use Prima::Application;
use Prima::Edit;
use Prima::Buttons;
use Prima::DockManager;

package dmfp;
use constant Edit       => 0x100000;
use constant Vertical   => 0x200000;
use constant Horizontal => 0x400000;

# This is the main window. it's responsible for 
# command handling and bar visiblity; 
# NB - bars are not owned by this window when undocked.

package Prima::Dock::BasicWindow;
use vars qw(@ISA);
@ISA = qw(Prima::Window);

sub profile_default
{
   my $def = $_[0]-> SUPER::profile_default;
   my %prf = ( 
      instance => undef,
   );
   @$def{keys %prf} = values %prf;
   return $def;
}   

sub init
{
   my  $self = shift;
   my %profile = $self-> SUPER::init( @_);
   $self-> $_($profile{$_}) for qw(instance);
   $self-> {toolBarPopup} = $self-> insert( Popup => 
      autoPopup  => 0,  
      items      => $self-> make_popupitems(),
   );
   $self-> {mainDock} = $self-> insert( FourPartDocker => 
      rect        => [ 0, 0, $self-> size],
      fingerprint => dmfp::Tools|dmfp::Toolbar|dmfp::Edit|dmfp::Horizontal|dmfp::Vertical,
      dockup      => $self-> instance,
      dockerCommonProfile => {
         hasPocket => 0,
         onPopup => sub { # all dockers would render this popup
            my ( $me, $btn, $x, $y) = @_;
            ( $x, $y) = $self-> screen_to_client( $me-> client_to_screen($x, $y));
            $self-> {toolBarPopup}-> popup( $x, $y);
            $me-> clear_event;
         }   
      },   
      dockerProfileClient => { # allow docking only to Edit
         fingerprint => dmfp::Edit,
      },   
      dockerProfileLeft   => { fingerprint => dmfp::Vertical|dmfp::Tools|dmfp::Toolbar },   
      dockerProfileRight  => { fingerprint => dmfp::Vertical|dmfp::Tools|dmfp::Toolbar },   
      dockerProfileTop    => { fingerprint => dmfp::Horizontal|dmfp::Tools|dmfp::Toolbar },   
      dockerProfileBottom => { fingerprint => dmfp::Horizontal|dmfp::Tools|dmfp::Toolbar },
   );
   $self-> instance-> add_notification( 'ToolbarChange', \&on_toolbarchange, $self);
   $self-> instance-> add_notification( 'PanelChange',   \&on_toolbarchange, $self);
   $self-> instance-> add_notification( 'Command',   \&on_command, $self);
   return %profile;
}  

sub make_popupitems
{
   my $items = $_[0]-> instance-> toolbar_menuitems( \&Menu_Check_Toolbars);
# actually DockManager doesn't care if panel CLSID and toolbar name intermix.
# this is the demonstration of resolving that clash   
   $$_[0] .= ',toolbar' for @$items;
   push ( @$items, []);
   push ( @$items, @{$_[0]-> instance-> panel_menuitems( \&Menu_Check_Panels)});
   push ( @$items, []);
   push ( @$items, ['customize' => "~Customize..." => q(open_dockmanaging)]);
   return $items;
}   


sub Menu_Check_Toolbars
{
   my ( $self, $var) = @_;
   my $toolname = $var;
   $toolname =~ s/\,toolbar$//;
   $self-> instance-> toolbar_visible( 
      $self-> instance-> toolbar_by_name($toolname), 
      $self-> {toolBarPopup}-> toggle( $var)
   );
}   

sub Menu_Check_Panels
{
   my ( $self, $var) = @_;
   $self-> instance-> panel_visible( $var, $self-> {toolBarPopup}-> toggle( $var));
}   

sub instance
{
   return $_[0]-> {instance} unless $#_;
   $_[0]-> {instance} = $_[1];
}   


sub on_toolbarchange
{
   $_[0]-> {toolBarPopup}-> items( $_[0]-> make_popupitems());
}   

sub on_command
{
   my ( $self, $instance, $command) = @_;
   $command =~ s/\://g;
   my $x = $self-> can( $command);
   return unless $x;
   $x-> ( $self);
}   

# we'll take our actions we need to reflect the state.
sub open_dockmanaging
{
   my $self = $_[0];
   my $i = $self-> instance;
   return if $i-> interactiveDrag;
   my $wpanel = Prima::Window-> create(
      name => 'Customize tools',
      size => [ 400, 100],
      onClose => sub {
         $self-> {toolBarPopup}-> customize-> enabled(1); 
         $i-> interactiveDrag(0);
      },   
   );
   $i-> create_manager( $wpanel,  dockerProfile => {
       hint => 'Drag here unneeded buttons',
    });
   $i-> interactiveDrag(1);
   $self-> {toolBarPopup}-> customize-> enabled(0);
}  

sub get_docks
{
   my $self = $_[0];
   my @docks = ( $self-> {mainDock});
   my $sid = $self-> {mainDock}-> open_session({
      self => $self-> {mainDock},
      sizes => [[0,0]],
      sizeable => [1,1],
   });
   if ( $sid) {
      while ( 1) {
         my $x = $self-> {mainDock}-> next_docker( $sid);
         last unless $x;
         next if $x-> isa(q(Prima::DockManager::LaunchPad));
         push ( @docks, $x);
      }   
      $self-> {mainDock}-> close_session( $sid);
   }
   return @docks;   
}   

sub init_read
{
   my ( $self, $fd) = @_;
   my $last = undef;
   my @docks = $self-> get_docks;
   my $state;
   my %docks = map { my $x = $_-> name; $x =~ s/(\W)/\%sprintf("%02x",$1)/; $x => $_} @docks;

   while ( <$fd>) {
      $state = 1, last if m/^DOCK_STMT_START/;
   }    
   return unless $state;
   my $i = $self-> instance;
   my %audocks;
   tie %audocks, 'Tie::RefHash';


   while ( <$fd>) {
      chomp;
      last if m/^DOCK_STMT_END/;
      if ( m/^MYSELF\[(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\]/) {
         $self-> rect( $1,$2,$3,$4);
         next;
      }   
      if ( m/^TOOLBAR\:(\w*)\:(\d)\:(\d)\:\[(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\]\:(.*)$/) {
         my ( $dockID, $vertical, $visible, $x1, $y1, $x2, $y2, $name) = ($1,$2,$3,$4,$5,$6,$7,$8);
         my $auto = $name =~ /^ToolBar/;
         
         my ( $x, $xcl) = $i-> create_toolbar(
            visible   => $visible,
            vertical  => $vertical,
            dock      => $docks{$dockID},
            rect      => [ $x1, $y1, $x2, $y2],
            name      => $name,
            autoClose => $auto,
         );
         $last = $xcl;
         $name =~ s/(\W)/\%sprintf("%02x",$1)/;
         $docks{$name} = $xcl;
         next;
      } elsif ( m/^TOOL\:([^\s]+)\s\[(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\]/) {
         my ( $CLSID, $x1, $y1, $x2, $y2) = ($1,$2,$3,$4,$5);
         next unless $last;
         my $ctrl = $i-> create_tool( $last, $CLSID, $x1, $y1, $x2, $y2);
         next unless $ctrl;
         push @{$audocks{$last}}, $ctrl;
         next;
      } elsif ( m/^PANEL\:(\w*)\:([^\s]+)\s\[(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\]/) {
         my ( $dockID, $CLSID, $x1, $y1, $x2, $y2) = ($1,$2,$3,$4,$5,$6);
         my ( $x, $xcl) = $i-> create_panel( $CLSID, dockerProfile => { 
             dock => $docks{$dockID},
             origin => [$x1, $y1], # because original profile uses size 
             size   => [$x2 - $x1, $y2 - $y1], # this is hack to override it
             rect   => [ $x1, $y1, $x2, $y2],
         });
         next;
      }
   }
   $_-> dock_bunch( @{$audocks{$_}}) for keys %audocks;
   $i-> notify(q(ToolbarChange));
}   

sub init_write
{
   my ( $self, $fd) = @_;
   print $fd "DOCK_STMT_START\n";
   my @rc = $self-> rect;
   print $fd "MYSELF[@rc]\n";
   for ( $self-> instance-> toolbars) {
      my $p = $_;
      my $x = $_-> childDocker;
      my ( $e, $n);
      my @rect = $x-> rect;
      if ( $p-> dock) {
         $e = $p;
         $n = $p-> dock-> name;
         $n =~ s/(\W)/\%sprintf("%02x",$1)/g; 
         @rect = $p-> dock-> screen_to_client( $p-> client_to_screen( @rect));
      } else {
         $n = '';
         $e = $p-> externalDocker;
         @rect = $x-> client_to_screen( @rect);
      }   
      my $vis  = $e-> visible ? 1 : 0;
      my $ver  = $x-> vertical ? 1 : 0;
      print $fd "TOOLBAR:$n:$ver:$vis:[@rect]:".$p-> text."\n";
      for ( $x-> docklings) {
         @rect = $_-> rect;
         my $ena = $_-> enabled;
         my $CLSID = $_-> {CLSID};
         next unless defined $CLSID;
         print $fd "TOOL:$CLSID [@rect]:$ena\n";
      }   
   }   
   for ( $self-> instance-> panels) {
      my @r = $_-> dock() ? $_-> rect : $_-> externalDocker-> rect;
      my $n = '';
      if ( $_-> dock) {
         $n = $_-> dock-> name;
         $n =~ s/(\W)/\%sprintf("%02x",$1)/g; 
      }
      my $CLSID = $_-> {CLSID};
      print $fd "PANEL:$n:$CLSID [@r]\n";
   }   
   print $fd "DOCK_STMT_END\n";
}   

sub FileOpen
{
   $_[0]-> open_dockmanaging;
}   

sub FileClose
{
   $_[0]-> close;
}   

package Banner;
use vars qw(@ISA);
@ISA = qw(Prima::Widget);

sub on_create
{
   my $self = $_[0];
   $self-> {offset} = 0;
   $self-> text( "Visit www.prima.eu.org");
   $self-> font-> size( 18);
   $self-> {maxOffset} = $self-> width;
   $self-> {textLen} = $self-> get_text_width( $self-> text);
   $self-> insert( Timer => timeout => 100 => onTick => sub {
      $self-> {offset} = $self-> {maxOffset} if ( $self-> {offset} -= 5) < -$self-> {textLen};
      $self-> repaint;
   })-> start;   
}   

sub on_size
{
   my ( $self, $ox, $oy, $x, $y) = @_;
   $self-> {maxOffset} = $x;
}   

sub on_paint
{
   my ( $self, $canvas) = @_;
   $canvas-> clear;
   my @sz = $self-> size;
   $canvas-> text_out( $self-> text, $self-> {offset}, ( $sz[1] - $canvas-> font-> height) / 2);
}   

package X;

# createing the docking instance with predefined command state
my $i = Prima::DockManager-> create(
    commands  => {
       'Edit::OK' => 0,
       'Edit::Cancel' => 0,
    },   
);

# registering buttons
sub reg
{
   my ( $id, $name, $hint, %profile) = @_;
   $i-> register_tool( Prima::DockManager::S::SpeedButton::class( "sysimage.gif:$id", 
     $name, hint => $hint, %profile));
}   

reg( sbmp::SFolderOpened, 'File::Open',  'Rearrange buttons');
reg( sbmp::SFolderClosed, 'File::Close', 'Close document');
reg( sbmp::GlyphOK,       'Edit::OK',    'OK', glyphs => 2);
reg( sbmp::GlyphCancel,   'Edit::Cancel','Cancel', glyphs => 2);
reg( sbmp::DriveFloppy,   'Drive::Floppy', 'Floppy disk');
reg( sbmp::DriveHDD,      'Drive::HDD'   , 'Hard disk');
reg( sbmp::DriveNetwork,  'Drive::Network','Network connection');
reg( sbmp::DriveCDROM,    'Drive::CDROM',  'CD-ROM device');
reg( sbmp::DriveMemory,   'Drive::Memory', 'Memory-mapped drive');
reg( sbmp::DriveUnknown,  'Drive::Unknown','FAT-64');

# registering panels
$i-> register_panel( 'Edit' => {
   class => 'Prima::Edit',
   text  => 'Edit window',
   dockerProfile => {
      fingerprint => dmfp::Edit,
      growMode    => gm::Client,
   },   
   profile => {
      vScroll => 1,
      text    => '',
   },   
});
$i-> register_panel( 'Banner' => {
   class => 'Banner',
   text  => 'Banner window',
   dockerProfile => { 
     fingerprint => dmfp::Horizontal,
     size => [ 200, 30]
   },
});   


my $resFile = Prima::path('demo_dock');

# after all that, creating window ( the window itself is of small importance...)

my $ww = Prima::Dock::BasicWindow -> create(
    instance => $i,
    onClose => sub {
       if ( open F, "> $resFile") {
         $_[0]-> init_write( *F);
         close F;
       } else {
          warn "Cannot open $resFile:$!\n";
       };
       $::application-> destroy;
    },
    size      => [ 400, 400],
    text       => 'Docking example',
    onActivate    => sub { $i-> activate; },
    onWindowState => sub { $i-> windowState( $_[1]); },
);


# opening predefined bars
if ( open F, $resFile) {
   $ww-> init_read(*F);
   close F;
} else {
   $i-> predefined_panels( "Edit" => $ww-> {mainDock}-> ClientDocker);
}   

$i-> predefined_toolbars( {
   name => "File",
   list => ["File::Open", "File::Close"],
   dock => $ww-> {mainDock}-> TopDocker,
   origin => [ 0, 0],
}, {
   name => "Edit",
   list => [ "Edit::OK", "Edit::Cancel", ],
   dock => $ww-> {mainDock}-> TopDocker, 
   origin => [ 0, 0],
});

#$ww-> open_dockmanaging; # uncomment this for Customize window popup immediately

run Prima;



1;
