1 files changed, 849 insertions, 0 deletions
diff --git a/plugins/!NotAdopted/Chess4Net/GameChessBoardUnit.pas b/plugins/!NotAdopted/Chess4Net/GameChessBoardUnit.pas
new file mode 100644
index 0000000000..779d90f309
--- /dev/null
+++ b/plugins/!NotAdopted/Chess4Net/GameChessBoardUnit.pas
@@ -0,0 +1,849 @@
+////////////////////////////////////////////////////////////////////////////////
+// All code below is exclusively owned by author of Chess4Net - Pavel Perminov
+// (packpaul@mail.ru, packpaul1@gmail.com).
+// Any changes, modifications, borrowing and adaptation are a subject for
+// explicit permition from the owner.
+
+unit GameChessBoardUnit;
+
+interface
+
+uses
+  ExtCtrls, TntStdCtrls, Buttons, Controls, StdCtrls, Classes, Forms, TntForms,
+  Graphics, Messages,
+  // Chess4net
+  ChessBoardHeaderUnit, ChessBoardUnit, ChessRulesEngine,
+  LocalizerUnit, PosBaseChessBoardLayerUnit;
+
+type
+  TGameChessBoardEvent =
+    (cbeMoved, cbeMate, cbeStaleMate, cbeInsuffMaterial, cbeKeyPressed,
+     cbeClockSwitched, cbeTimeOut, cbeExit, cbeMenu, cbeActivate, cbeFormMoving,
+     cbeRefreshAll);
+     // It's possible to add new events. cbeRefreshAll signals that global options had been changed
+
+  TGameChessBoardHandler = procedure(e: TGameChessBoardEvent;
+                                 d1: pointer = nil; d2: pointer = nil) of object;
+
+{$IFDEF THREADED_CHESSCLOCK}
+  TGameChessBoard = class;
+
+  TTimeLabelThread = class(TThread)
+  private
+    ChessBoard: TGameChessBoard;
+    player_time: array[TFigureColor] of TDateTime;
+  protected
+    procedure Execute; override;
+  public
+    WhiteTime, BlackTime: string;
+    constructor Create(ChessBoard: TGameChessBoard);
+  end;
+{$ENDIF}
+
+  TGameChessBoard = class(TTntForm, ILocalizable)
+    TimePanel: TPanel;
+    WhiteLabel: TTntLabel;
+    WhiteTimeLabel: TLabel;
+    BlackLabel: TTntLabel;
+    BlackTimeLabel: TLabel;
+    GameTimer: TTimer;
+    WhiteFlagButton: TSpeedButton;
+    BlackFlagButton: TSpeedButton;
+    WhitePanel: TPanel;
+    BlackPanel: TPanel;
+    ChessBoardPanel: TPanel;
+    procedure FormCreate(Sender: TObject);
+    procedure FormDestroy(Sender: TObject);
+    procedure GameTimerTimer(Sender: TObject);
+    procedure FormClose(Sender: TObject; var Action: TCloseAction);
+    procedure FormKeyDown(Sender: TObject; var Key: Word;
+      Shift: TShiftState);
+    procedure FormActivate(Sender: TObject);
+    procedure FlagButtonClick(Sender: TObject);
+    procedure FormCanResize(Sender: TObject; var NewWidth, NewHeight: Integer;
+      var Resize: Boolean);
+    procedure TimePanelResize(Sender: TObject);
+
+  private
+    m_ChessBoard: TChessBoard;
+    m_PosBaseChessBoardLayer: TPosBaseChessBoardLayer;
+
+    FHandler: TGameChessBoardHandler;
+
+    auto_flag: boolean; // индикатор автофлага
+    player_time: array[TFigureColor] of TDateTime; // время белых и чёрных
+    past_time: TDateTime; // время начала обдумывания хода
+    unlimited_var: array[TFigureColor] of boolean; // партия без временного контроля
+    clock_color: TFigureColor; // цвет анимируемой фигуры
+
+    shuted: boolean; // индикатор внешнего закрытия окна
+
+    // Resizing
+    m_ResizingType: (rtNo, rtHoriz, rtVert);
+//    m_iDeltaWidthHeight: integer;
+
+    m_iTimePanelInitialWidth: integer;
+    m_iWhitePanelInitialLeft, m_iBlackPanelInitialLeft: integer;
+    m_iWhitePanelInitialWidth, m_iBlackPanelInitialWidth: integer;
+    m_TimeFont: TFont;
+
+    m_bFlashOnMove: boolean; // flag for flashing window on icoming move
+
+{$IFDEF THREADED_CHESSCLOCK}
+    TimeLabelThread: TTimeLabelThread; // нить используется для борьбы с лагом в Миранде
+{$ENDIF}
+
+    function FGetMode: TMode;
+    procedure FSetMode(const Value: TMode);
+    procedure ShowTime(const c: TFigureColor);
+    function FGetPlayerColor: TFigureColor;
+    procedure FSetPlayerColor(const Value: TFigureColor);
+    function FGetFlipped: boolean;
+    procedure FSetFlipped(bValue: boolean);
+    function FGetTime(color: TFigureColor): TDateTime;
+    procedure FSetTime(color: TFigureColor; const tm: TDateTime);
+    procedure FSetUnlimited(color: TFigureColor; const unl: boolean);
+    function FGetUnlimited(color: TFigureColor): boolean;
+    function FGetLastMoveHilighted: boolean;
+    procedure FSetLastMoveHilighted(bValue: boolean);
+    function FGetCoordinatesShown: boolean;
+    procedure FSetCoordinatesShown(bValue: boolean);
+    function GetStayOnTop: boolean;
+    procedure FSetStayOnTop(onTop: boolean);
+    procedure FSetAutoFlag(auto_flag: boolean);
+    procedure FFlashWindow;
+    function FGetAnimation: TAnimation;
+    procedure FSetAnimation(const Value: TAnimation);
+    function FGetViewGaming: boolean;
+    procedure FSetViewGaming(bValue: boolean);
+
+    // Localization
+    procedure ILocalizable.Localize = FLocalize;
+    procedure FLocalize;
+
+    procedure WMMoving(var Msg: TWMMoving); message WM_MOVING;
+    procedure WMSizing(var Msg: TMessage); message WM_SIZING;
+
+    function FGetPositionColor: TFigureColor;
+
+    function FGetTrainingMode: boolean;
+    procedure FSetTrainingMode(bValue: boolean);
+
+    function FGetUseUserBase: boolean;
+    procedure FSetUseUserBase(bValue: boolean);
+
+    procedure FChessBoardHandler(e: TChessBoardEvent; d1: pointer = nil;
+      d2: pointer = nil);
+    procedure FDoHandler(e: TGameChessBoardEvent; d1: pointer = nil;
+      d2: pointer = nil);
+
+  public
+    constructor Create(Owner: TComponent; AHandler: TGameChessBoardHandler = nil;
+      const strPosBaseName: string = ''); reintroduce;
+
+    procedure FCreateChessBoard(const strPosBaseName: string);
+    procedure FDestroyChessBoard;
+
+    procedure TakeBack; // взятие хода обратно
+    procedure SwitchClock(clock_color: TFigureColor);
+    procedure InitPosition;
+    procedure PPRandom;
+    procedure StopClock;
+
+    procedure ResetMoveList;
+    function SetPosition(const strPosition: string): boolean;
+    function GetPosition: string;
+    function NMoveDone: integer; // количество сделанных ходов
+    function DoMove(const strMove: string): boolean;
+    procedure Shut;
+
+    procedure WriteGameToBase(vGameResult: TGameResult);
+    procedure SetExternalBase(const strExtPosBaseName: string);
+    procedure UnsetExternalBase;
+
+    property Unlimited[color: TFigureColor]: boolean read FGetUnlimited write FSetUnlimited;
+    property Time[color: TFigureColor]: TDateTime read FGetTime write FSetTime;
+    property PlayerColor: TFigureColor read FGetPlayerColor write FSetPlayerColor;
+    property PositionColor: TFigureColor read FGetPositionColor; // Whos move it is in the current position
+    property ClockColor: TFigureColor read clock_color;
+    property Mode: TMode read FGetMode write FSetMode;
+    property CoordinatesShown: boolean read FGetCoordinatesShown write FSetCoordinatesShown;
+
+    property Flipped: boolean read FGetFlipped write FSetFlipped;
+    property LastMoveHilighted: boolean read FGetLastMoveHilighted write FSetLastMoveHilighted;
+    property FlashOnMove: boolean read m_bFlashOnMove write m_bFlashOnMove;
+    property StayOnTop: boolean read GetStayOnTop write FSetStayOnTop;
+    property AutoFlag: boolean read auto_flag write FSetAutoFlag;
+    property Animation: TAnimation read FGetAnimation write FSetAnimation;
+    property ViewGaming: boolean read FGetViewGaming write FSetViewGaming;
+
+    property pTrainingMode: boolean read FGetTrainingMode write FSetTrainingMode;
+    property pUseUserBase: boolean read FGetUseUserBase write FSetUseUserBase;
+  end;
+
+implementation
+
+{$J+}
+
+{$R *.dfm}
+
+uses
+  SysUtils, Types, Windows,
+  //
+  ChessClockUnit;
+
+const
+  TIME_COLOR = clBlack;
+
+  ZEITNOT_COLOR = clMaroon;
+//  CHEAT_TIME_CONST = 1.5; // > 1
+  WHITE_LONG_LABEL: WideString   =   'White   ';
+  WHITE_MEDIUM_LABEL: WideString = 'White ';
+  WHITE_SHORT_LABEL: WideString  =  'W ';
+  BLACK_LONG_LABEL: WideString   =   'Black   ';
+  BLACK_MEDIUM_LABEL: WideString = 'Black ';
+  BLACK_SHORT_LABEL: WideString  =  'B ';
+
+////////////////////////////////////////////////////////////////////////////////
+// TTimeLabelThread
+
+{$IFDEF THREADED_CHESSCLOCK}
+procedure TTimeLabelThread.Execute;
+begin
+  while ChessBoard.GameTimer.Enabled do
+    begin
+      if self.player_time[fcWhite] <> ChessBoard.player_time[fcWhite] then
+        ChessBoard.ShowTime(fcWhite);
+      if self.player_time[fcBlack] <> ChessBoard.player_time[fcBlack] then
+        ChessBoard.ShowTime(fcBlack);
+      Sleep(ChessBoard.GameTimer.Interval div 2);
+    end;
+  ChessBoard.TimeLabelThread := nil;  
+end;
+
+
+constructor TTimeLabelThread.Create(ChessBoard: TGameChessBoard);
+begin
+  self.ChessBoard := ChessBoard;
+  self.player_time[fcWhite] := ChessBoard.player_time[fcWhite];
+  self.player_time[fcBlack] := ChessBoard.player_time[fcBlack];
+
+  inherited Create(TRUE);
+//Priority := tpNormal;
+  FreeOnTerminate := TRUE;
+  Resume;
+end;
+{$ENDIF}
+
+////////////////////////////////////////////////////////////////////////////////
+// TGameChessBoard
+
+function TGameChessBoard.DoMove(const strMove: string): boolean;
+begin
+  Result := m_ChessBoard.DoMove(strMove);
+  if (Result) then
+  begin
+    if (m_bFlashOnMove and (Mode = mGame)) then
+      FFlashWindow;
+  end;
+end;
+
+
+procedure TGameChessBoard.ShowTime(const c: TFigureColor);
+var
+  time_label: TLabel;
+begin
+  if c = fcWhite then time_label:= WhiteTimeLabel
+    else time_label:= BlackTimeLabel;
+
+  if unlimited_var[c] then
+    begin
+      time_label.Caption:= '';
+      exit;
+    end;
+
+  if (TChessClock.IsZeitnot(player_time[c])) then
+    time_label.Font.Color := ZEITNOT_COLOR
+  else
+    time_label.Font.Color := TIME_COLOR;
+
+  time_label.Caption := TChessClock.ConvertToStr(player_time[c]);
+end;
+
+
+procedure TGameChessBoard.ResetMoveList;
+begin
+  m_ChessBoard.ResetMoveList;
+end;
+
+
+function TGameChessBoard.SetPosition(const strPosition: string): boolean;
+begin
+  Result := m_ChessBoard.SetPosition(strPosition);
+  if (Result) then
+    clock_color := PositionColor;
+end;
+
+
+function TGameChessBoard.GetPosition: string;
+begin
+  Result := m_ChessBoard.GetPosition;
+end;
+
+
+procedure TGameChessBoard.FormCreate(Sender: TObject);
+begin
+  m_iTimePanelInitialWidth := TimePanel.Width;
+  m_iWhitePanelInitialLeft := WhitePanel.Left;
+  m_iWhitePanelInitialWidth := WhitePanel.Width;
+  m_iBlackPanelInitialLeft := BlackPanel.Left;
+  m_iBlackPanelInitialWidth := BlackPanel.Width;
+
+  m_TimeFont := TFont.Create;
+  m_TimeFont.Assign(WhiteTimeLabel.Font);
+
+  BlackFlagButton.Glyph := WhiteFlagButton.Glyph; // For size minimization
+
+  TLocalizer.Instance.AddSubscriber(self);
+  FLocalize;
+
+  // Clock initialization
+  FSetUnlimited(fcWhite, TRUE);
+  FSetUnlimited(fcBlack, TRUE);
+end;
+
+
+constructor TGameChessBoard.Create(Owner: TComponent;
+  AHandler: TGameChessBoardHandler = nil; const strPosBaseName: string = '');
+begin
+  FHandler := AHandler;
+  inherited Create(Owner);
+  FCreateChessBoard(strPosBaseName);
+end;
+
+
+procedure TGameChessBoard.FCreateChessBoard(const strPosBaseName: string);
+begin
+  m_ChessBoard := TChessBoard.Create(self, FChessBoardHandler);
+  m_PosBaseChessBoardLayer := TPosBaseChessBoardLayer.Create(strPosBaseName);
+
+  m_ChessBoard.AddLayer(m_PosBaseChessBoardLayer);
+
+  with ChessBoardPanel do
+    SetBounds(Left, Top, m_ChessBoard.ClientWidth, m_ChessBoard.ClientHeight);
+
+  m_ChessBoard.BorderStyle := bsNone;
+  m_ChessBoard.Align := alClient;
+  m_ChessBoard.Parent := ChessBoardPanel;
+  m_ChessBoard.Visible := TRUE;
+
+  InitPosition;
+end;
+
+
+procedure TGameChessBoard.FDestroyChessBoard;
+begin
+  m_ChessBoard.RemoveLayer(m_PosBaseChessBoardLayer); // m_ChessBoard is destroyed by its parent
+  FreeAndNil(m_PosBaseChessBoardLayer);
+end;
+
+
+procedure TGameChessBoard.FormDestroy(Sender: TObject);
+begin
+  TLocalizer.Instance.DeleteSubscriber(self);
+
+  m_TimeFont.Free;
+
+  FDestroyChessBoard;
+end;
+
+
+procedure TGameChessBoard.InitPosition;
+begin
+  m_ChessBoard.InitPosition;
+end;
+
+
+procedure TGameChessBoard.FSetMode(const Value: TMode);
+begin
+  m_ChessBoard.Mode := Value;
+  if (Value <> mGame) then
+  begin
+    WhiteFlagButton.Visible := FALSE;
+    BlackFlagButton.Visible := FALSE;
+  end;
+end;
+
+
+function TGameChessBoard.FGetMode: TMode;
+begin
+  Result := m_ChessBoard.Mode;
+end;
+
+
+procedure TGameChessBoard.FSetTime(color: TFigureColor; const tm: TDateTime);
+begin
+  if (not Unlimited[color]) then
+  begin
+    if ((not auto_flag) and (not ViewGaming)) then
+    begin
+      case color of
+        fcWhite:
+          WhiteFlagButton.Visible := ((PlayerColor = fcBlack) and (tm = 0.0));
+        fcBlack:
+          BlackFlagButton.Visible := ((PlayerColor = fcWhite) and (tm = 0.0));
+      end;
+    end;
+    player_time[color] := tm;
+    ShowTime(color);
+  end;
+end;
+
+
+function TGameChessBoard.FGetTime(color: TFigureColor): TDateTime;
+begin
+  Result:= player_time[color];
+end;
+
+
+procedure TGameChessBoard.GameTimerTimer(Sender: TObject);
+begin
+  if unlimited_var[clock_color] then
+    begin
+      GameTimer.Enabled := FALSE;
+      exit;
+    end;
+  // TODO: cheating check
+  player_time[clock_color] := player_time[clock_color] - (Now - past_time);
+  if player_time[clock_color] <= 0.0 then
+    begin
+      player_time[clock_color] := 0.0;
+      ShowTime(clock_color);
+      if ((not auto_flag) and (PlayerColor <> clock_color) and (not ViewGaming)) then
+      begin
+        case clock_color of
+          fcWhite:
+            WhiteFlagButton.Visible := TRUE;
+          fcBlack:
+            BlackFlagButton.Visible := TRUE;
+        end;
+      end;
+      if ((PlayerColor <> clock_color) and (Mode = mGame) and (auto_flag)) then
+        FDoHandler(cbeTimeOut, self);
+      GameTimer.Enabled := FALSE;
+    end;
+{$IFNDEF THREADED_CHESSCLOCK}
+  ShowTime(clock_color);
+{$ENDIF}
+
+  past_time:= Now;
+end;
+
+
+procedure TGameChessBoard.FSetUnlimited(color: TFigureColor; const unl: boolean);
+begin
+  unlimited_var[color]:= unl;
+  ShowTime(color);
+end;
+
+
+function TGameChessBoard.FGetUnlimited(color: TFigureColor): boolean;
+begin
+  Result := unlimited_var[color];
+end;
+
+
+procedure TGameChessBoard.SwitchClock(clock_color: TFigureColor);
+begin
+  self.clock_color := clock_color;
+  if (not GameTimer.Enabled) then
+  begin
+    past_time := Now;
+    GameTimer.Enabled := TRUE;
+  end;
+  if (Mode = mGame) then
+    FDoHandler(cbeClockSwitched, self);
+  ShowTime(clock_color);
+
+{$IFDEF THREADED_CHESSCLOCK}
+  if (not Assigned(TimeLabelThread)) then
+    TimeLabelThread := TTimeLabelThread.Create(self);
+{$ENDIF}
+end;
+
+
+procedure TGameChessBoard.FSetPlayerColor(const Value: TFigureColor);
+begin
+  m_ChessBoard.PlayerColor := Value;
+end;
+
+
+function TGameChessBoard.FGetPlayerColor: TFigureColor;
+begin
+  Result := m_ChessBoard.PlayerColor;
+end;
+
+
+procedure TGameChessBoard.StopClock;
+begin
+  GameTimer.Enabled := FALSE;
+  WhiteFlagButton.Visible := FALSE;
+  BlackFlagButton.Visible := FALSE;
+end;
+
+
+procedure TGameChessBoard.FormCanResize(Sender: TObject; var NewWidth,
+  NewHeight: Integer; var Resize: Boolean);
+var
+  iNewChessBoardWidth, iNewChessBoardHeight: integer;
+begin
+  Resize := (m_ResizingType <> rtNo);
+  if (not Resize) then
+    exit;
+
+  iNewChessBoardWidth := m_ChessBoard.Width + (NewWidth - self.Width);
+  iNewChessBoardHeight := m_ChessBoard.Height + (NewHeight - self.Height);
+
+  m_ChessBoard.FormCanResize(self, iNewChessBoardWidth, iNewChessBoardHeight, Resize);
+  if (Resize) then
+  begin
+    NewWidth := self.Width + (iNewChessBoardWidth - m_ChessBoard.Width);
+    NewHeight := self.Height + (iNewChessBoardHeight - m_ChessBoard.Height);
+  end;
+end;
+
+procedure TGameChessBoard.FormClose(Sender: TObject; var Action: TCloseAction);
+begin
+  if (not shuted) then
+  begin
+    FDoHandler(cbeExit, self);
+    Action:= caNone;
+  end
+  else
+    shuted := FALSE;
+end;
+
+
+procedure TGameChessBoard.Shut;
+begin
+  shuted:= TRUE;
+  Close;
+end;
+
+
+procedure TGameChessBoard.PPRandom;
+begin
+  m_ChessBoard.PPRandom;
+end;
+
+
+procedure TGameChessBoard.TakeBack;
+begin
+  m_ChessBoard.TakeBack;
+end;
+
+
+function TGameChessBoard.FGetLastMoveHilighted: boolean;
+begin
+  Result := m_ChessBoard.LastMoveHilighted;
+end;
+
+
+procedure TGameChessBoard.FSetLastMoveHilighted(bValue: boolean);
+begin
+  m_ChessBoard.LastMoveHilighted := bValue;
+end;
+
+
+procedure TGameChessBoard.FSetCoordinatesShown(bValue: boolean);
+begin
+  m_ChessBoard.CoordinatesShown := bValue;
+end;
+
+
+function TGameChessBoard.FGetCoordinatesShown: boolean;
+begin
+  Result := m_ChessBoard.CoordinatesShown;
+end;
+
+
+function TGameChessBoard.NMoveDone: integer;
+begin
+  Result := m_ChessBoard.NMoveDone;
+end;
+
+
+procedure TGameChessBoard.FormKeyDown(Sender: TObject; var Key: Word;
+  Shift: TShiftState);
+begin
+  FDoHandler(cbeKeyPressed, Pointer(Key), self);
+end;
+
+
+function TGameChessBoard.GetStayOnTop: boolean;
+begin
+  Result := (self.FormStyle = fsStayOnTop);
+end;
+
+
+procedure TGameChessBoard.FSetStayOnTop(onTop: boolean);
+begin
+  if (onTop) then
+    self.FormStyle := fsStayOnTop
+  else
+    self.FormStyle := fsNormal;
+end;
+
+
+procedure TGameChessBoard.FormActivate(Sender: TObject);
+begin
+  FDoHandler(cbeActivate, self);
+end;
+
+
+procedure TGameChessBoard.WMMoving(var Msg: TWMMoving);
+begin
+  // TODO: it's possible to handle if form is outside of the screen
+  FDoHandler(cbeFormMoving, Pointer(Msg.DragRect.Left - Left), Pointer(Msg.DragRect.Top - Top));
+  inherited;
+end;
+
+
+procedure TGameChessBoard.WMSizing(var Msg: TMessage);
+begin
+  m_ChessBoard.Perform(Msg.Msg, Msg.WParam, Msg.LParam);
+
+  case Msg.WParam of
+    WMSZ_RIGHT, WMSZ_LEFT, WMSZ_BOTTOMRIGHT, WMSZ_TOPLEFT:
+      m_ResizingType := rtHoriz;
+    WMSZ_BOTTOM, WMSZ_TOP:
+      m_ResizingType := rtVert;
+  else
+    begin
+      m_ResizingType := rtNo;
+      PRect(Msg.LParam).Left := Left;
+      PRect(Msg.LParam).Top := Top;
+    end;
+  end; // case
+end;
+
+
+function TGameChessBoard.FGetPositionColor: TFigureColor;
+begin
+  Result := m_ChessBoard.PositionColor;
+end;
+
+
+procedure TGameChessBoard.FlagButtonClick(Sender: TObject);
+begin
+  if (Mode = mGame) then
+    FDoHandler(cbeTimeOut, self);
+end;
+
+
+procedure TGameChessBoard.FSetAutoFlag(auto_flag: boolean);
+begin
+  self.auto_flag := auto_flag;
+  if (auto_flag) then
+  begin
+    WhiteFlagButton.Visible := FALSE;
+    BlackFlagButton.Visible := FALSE;
+  end;
+end;
+
+
+procedure TGameChessBoard.TimePanelResize(Sender: TObject);
+var
+  rRatio: real;
+begin
+  // Adjust panels on TimePanel
+  rRatio := TimePanel.Width / m_iTimePanelInitialWidth;
+  WhitePanel.Left := Round(rRatio * m_iWhitePanelInitialLeft);
+  WhitePanel.Width := m_iWhitePanelInitialWidth;
+  BlackPanel.Left := Round(rRatio * m_iBlackPanelInitialLeft);
+  BlackPanel.Width := m_iBlackPanelInitialWidth;
+
+
+  WhiteTimeLabel.Font.Assign(m_TimeFont);
+  BlackTimeLabel.Font.Assign(m_TimeFont);
+  
+  if (WhitePanel.Left + WhitePanel.Width < BlackPanel.Left) then
+  begin
+    WhiteLabel.Caption := WHITE_LONG_LABEL;
+    BlackLabel.Caption := BLACK_LONG_LABEL;
+  end
+  else
+  begin
+    WhitePanel.Left := 4;
+    WhitePanel.Width := TimePanel.Width div 2;
+    BlackPanel.Left := TimePanel.Width div 2;
+    BlackPanel.Width := TimePanel.Width div 2 - 4;
+
+    WhiteLabel.Caption := WHITE_MEDIUM_LABEL;
+    BlackLabel.Caption := BLACK_MEDIUM_LABEL;
+  end;
+
+  // Adjust color labels
+  if ((WhiteTimeLabel.Left + WhiteTimeLabel.Width > WhitePanel.Width) or
+      (BlackTimeLabel.Left + BlackTimeLabel.Width > BlackPanel.Width)) then
+  begin
+    WhiteLabel.Caption := WHITE_MEDIUM_LABEL;
+    BlackLabel.Caption := BLACK_MEDIUM_LABEL;
+    if ((WhiteTimeLabel.Left + WhiteTimeLabel.Width <= WhitePanel.Width) and
+      (BlackTimeLabel.Left + BlackTimeLabel.Width <= BlackPanel.Width)) then
+      exit; // TODO: a KLUDGE - make it nice!
+  
+    WhiteTimeLabel.Font.Size := WhiteTimeLabel.Font.Size - 4;
+    BlackTimeLabel.Font.Size := BlackTimeLabel.Font.Size - 4;
+    WhiteLabel.Caption := WHITE_SHORT_LABEL;
+    BlackLabel.Caption := BLACK_SHORT_LABEL;
+  end;
+end;
+
+
+procedure TGameChessBoard.FFlashWindow;
+var
+  flushWindowInfo: TFlashWInfo;
+begin
+ // Flash with taskbar
+ flushWindowInfo.cbSize := SizeOf(flushWindowInfo);
+ flushWindowInfo.hwnd := Application.Handle;
+ flushWindowInfo.dwflags := FLASHW_TRAY; // FLASHW_ALL; //FLASHW_TRAY;
+ flushWindowInfo.ucount := 3; // Flash times
+ flushWindowInfo.dwtimeout := 0; // speed in msec, 0 - frequency of cursor flashing
+ FlashWindowEx(flushWindowInfo);
+
+ if (self.Focused) then
+   exit;
+ // Flash window
+ flushWindowInfo.hwnd := self.Handle; // handle of the flashing window
+ flushWindowInfo.dwflags := FLASHW_CAPTION; // FLASHW_TRAY; // FLASHW_ALL; //FLASHW_TRAY;
+ FlashWindowEx(flushWindowInfo);
+end;
+
+
+procedure TGameChessBoard.FLocalize;
+begin
+  with TLocalizer.Instance do
+  begin
+    WHITE_LONG_LABEL := GetLabel(13);
+    WHITE_MEDIUM_LABEL := GetLabel(14);
+    WHITE_SHORT_LABEL := GetLabel(15);
+    BLACK_LONG_LABEL := GetLabel(16);
+    BLACK_MEDIUM_LABEL := GetLabel(17);
+    BLACK_SHORT_LABEL := GetLabel(18);
+  end;
+
+  TimePanelResize(nil);
+end;
+
+
+procedure TGameChessBoard.WriteGameToBase(vGameResult: TGameResult);
+begin
+  m_PosBaseChessBoardLayer.WriteGameToBase(vGameResult);
+end;
+
+
+procedure TGameChessBoard.SetExternalBase(const strExtPosBaseName: string);
+begin
+  m_PosBaseChessBoardLayer.SetExternalBase(strExtPosBaseName);
+end;
+
+
+procedure TGameChessBoard.UnsetExternalBase;
+begin
+  m_PosBaseChessBoardLayer.UnsetExternalBase;
+end;
+
+
+function TGameChessBoard.FGetTrainingMode: boolean;
+begin
+  Result := m_PosBaseChessBoardLayer.TrainingMode;
+end;
+
+
+procedure TGameChessBoard.FSetTrainingMode(bValue: boolean);
+begin
+  m_PosBaseChessBoardLayer.TrainingMode := bValue;
+end;
+
+
+function TGameChessBoard.FGetUseUserBase: boolean;
+begin
+  Result := m_PosBaseChessBoardLayer.UseUserBase;
+end;
+
+
+procedure TGameChessBoard.FSetUseUserBase(bValue: boolean);
+begin
+  m_PosBaseChessBoardLayer.UseUserBase := bValue;
+end;
+
+
+function TGameChessBoard.FGetFlipped: boolean;
+begin
+  Result := m_ChessBoard.Flipped;
+end;
+
+
+procedure TGameChessBoard.FSetFlipped(bValue: boolean);
+begin
+  m_ChessBoard.Flipped := bValue;
+end;
+
+
+function TGameChessBoard.FGetAnimation: TAnimation;
+begin
+  Result := m_ChessBoard.Animation;
+end;
+
+
+procedure TGameChessBoard.FSetAnimation(const Value: TAnimation);
+begin
+  m_ChessBoard.Animation := Value;
+end;
+
+
+function TGameChessBoard.FGetViewGaming: boolean;
+begin
+  Result := m_ChessBoard.ViewGaming;
+end;
+
+
+procedure TGameChessBoard.FSetViewGaming(bValue: boolean);
+begin
+  m_ChessBoard.ViewGaming := bValue;
+end;
+
+
+procedure TGameChessBoard.FChessBoardHandler(e: TChessBoardEvent; d1: pointer = nil;
+  d2: pointer = nil);
+begin
+  case e of
+    ChessBoardUnit.cbeMate:
+      FDoHandler(cbeMate, self);
+
+    ChessBoardUnit.cbeStaleMate:
+      FDoHandler(cbeStaleMate, self);
+
+    ChessBoardUnit.cbeMoved:
+    begin
+      if ((Mode = mGame) and (PositionColor <> PlayerColor)) then
+        FDoHandler(cbeMoved, d1, self);
+      SwitchClock(PositionColor);      
+    end;
+
+    ChessBoardUnit.cbeMenu:
+      FDoHandler(cbeMenu, self);
+  end;
+end;
+
+
+procedure TGameChessBoard.FDoHandler(e: TGameChessBoardEvent; d1: pointer = nil;
+  d2: pointer = nil);
+begin
+  if (Assigned(FHandler)) then
+    FHandler(e, d1, d2);
+end;
+
+end.