Plugin is not adapted until someone can compile it and tell others how to do the same

git-svn-id: http://svn.miranda-ng.org/main/trunk@1809 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

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.