#include <sys/stat.h>
#include <pwd.h>
#include <math.h>
+#include <cairo/cairo.h>
+#include <cairo/cairo-xlib.h>
#if !OMIT_SOCKETS
# if HAVE_SYS_SOCKET_H
#include "childio.h"
#include "xgamelist.h"
#include "xhistory.h"
+#include "xevalgraph.h"
#include "xedittags.h"
#include "menus.h"
#include "board.h"
#include "dialogs.h"
+#include "engineoutput.h"
#include "usystem.h"
#include "gettext.h"
static void CreateAnyPieces P((void));
void CreateXIMPieces P((void));
void CreateXPMPieces P((void));
+void CreatePNGPieces P((void));
void CreateXPMBoard P((char *s, int n));
void CreatePieces P((void));
-void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb, int boardWidth));
-Widget CreateButtonBar P ((MenuItem *mi));
#if ENABLE_NLS
char *InsertPxlSize P((char *pattern, int targetPxlSize));
XFontSet CreateFontSet P((char *base_fnt_lst));
#else
char *FindFont P((char *pattern, int targetPxlSize));
#endif
-void PieceMenuPopup P((Widget w, XEvent *event,
- String *params, Cardinal *num_params));
-static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
-static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
u_int wreq, u_int hreq));
void CreateGrid P((void));
void EventProc P((Widget widget, caddr_t unused, XEvent *event));
void DelayedDrag P((void));
static void MoveTypeInProc P((Widget widget, caddr_t unused, XEvent *event));
-void HandleUserMove P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void AnimateUserMove P((Widget w, XEvent * event,
- String * params, Cardinal * nParams));
void HandlePV P((Widget w, XEvent * event,
String * params, Cardinal * nParams));
-void SelectPV P((Widget w, XEvent * event,
- String * params, Cardinal * nParams));
-void StopPV P((Widget w, XEvent * event,
- String * params, Cardinal * nParams));
-void WhiteClock P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void BlackClock P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void DrawPositionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void CommentClick P((Widget w, XEvent * event,
String * params, Cardinal * nParams));
void ICSInputBoxPopUp P((void));
-void FileNamePopUp P((char *label, char *def, char *filter,
- FileProc proc, char *openMode));
-void PromotionPopDown P((void));
-void PromotionCallback P((Widget w, XtPointer client_data,
- XtPointer call_data));
void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
void KeyBindingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void QuitWrapper P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ICSInitScript P((void));
void SelectMove P((Widget w, XEvent * event, String * params, Cardinal * nParams));
void update_ics_width P(());
-int get_term_width P(());
int CopyMemoProc P(());
/*
Display *xDisplay;
Window xBoardWindow;
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
- highlightSquareColor, premoveHighlightColor;
+ highlightSquareColor, premoveHighlightColor, dialogColor, buttonColor;
Pixel lowTimeWarningColor;
GC lightSquareGC, darkSquareGC, lineGC, wdPieceGC, wlPieceGC,
bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
prelineGC, countGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
- whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
- commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
- menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
- ICSInputShell, fileNameShell;
-Widget historyShell, evalGraphShell, gameListShell;
-XSegment secondSegments[BOARD_RANKS + BOARD_FILES + 2];
+Widget shellWidget, formWidget, boardWidget, titleWidget, dropMenu, menuBarWidget;
+Option *optList; // contains all widgets of main window
XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
#if ENABLE_NLS
XFontSet fontSet, clockFontSet;
XtAppContext appContext;
char *layoutName;
-FileProc fileProc;
-char *fileOpenMode;
char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
Position commentX = -1, commentY = -1;
int minX, minY; // [HGM] placement: volatile limits on upper-left corner
int smallLayout = 0, tinyLayout = 0,
marginW, marginH, // [HGM] for run-time resizing
- fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
- ICSInputBoxUp = False,
- filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
- errorUp = False, errorExitStatus = -1, defaultLineGap;
+ fromX = -1, fromY = -1, toX, toY, commentUp = False,
+ errorExitStatus = -1, defaultLineGap;
Dimension textHeight;
Pixel timerForegroundPixel, timerBackgroundPixel;
Pixel buttonForegroundPixel, buttonBackgroundPixel;
#define SOLID 0
#define OUTLINE 1
+Boolean cairoAnimate;
+static cairo_surface_t *csBoardWindow, *csBoardBackup, *csDualBoard;
+static cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn]; // scaled pieces as used
+static cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
+static cairo_surface_t *pngBoardBitmap[2];
Pixmap pieceBitmap[2][(int)BlackPawn];
Pixmap pieceBitmap2[2][(int)BlackPawn+4]; /* [HGM] pieces */
Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
-#define PAUSE_BUTTON "P"
-MenuItem buttonBar[] = {
- {"<<", "<<", ToStartEvent},
- {"<", "<", BackwardEvent},
- {N_(PAUSE_BUTTON), PAUSE_BUTTON, PauseEvent},
- {">", ">", ForwardEvent},
- {">>", ">>", ToEndEvent},
- {NULL, NULL, NULL}
-};
-
-#define PIECE_MENU_SIZE 18
-String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
- { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
- N_("Empty square"), N_("Clear board") },
- { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
- N_("Empty square"), N_("Clear board") }
-};
-/* must be in same order as pieceMenuStrings! */
-ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
- { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
- WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
- WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
- PromotePiece, DemotePiece, EmptySquare, ClearBoard },
- { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
- BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
- BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
- PromotePiece, DemotePiece, EmptySquare, ClearBoard },
-};
-
-#define DROP_MENU_SIZE 6
-String dropMenuStrings[DROP_MENU_SIZE] = {
- "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
- };
-/* must be in same order as dropMenuStrings! */
-ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
- (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
- WhiteRook, WhiteQueen
-};
-
typedef struct {
char piece;
char* widget;
{ XtNmaxHeight, 0 }
};
-Arg layoutArgs[] = {
- { XtNborderWidth, 0 },
- { XtNdefaultDistance, 0 },
-};
-
-Arg formArgs[] = {
- { XtNborderWidth, 0 },
- { XtNresizable, (XtArgVal) True },
-};
-
-Arg boardArgs[] = {
- { XtNborderWidth, 0 },
- { XtNwidth, 0 },
- { XtNheight, 0 }
-};
-
-Arg titleArgs[] = {
- { XtNjustify, (XtArgVal) XtJustifyRight },
- { XtNlabel, (XtArgVal) "..." },
- { XtNresizable, (XtArgVal) True },
- { XtNresize, (XtArgVal) False }
-};
-
-Arg messageArgs[] = {
- { XtNjustify, (XtArgVal) XtJustifyLeft },
- { XtNlabel, (XtArgVal) "..." },
- { XtNresizable, (XtArgVal) True },
- { XtNresize, (XtArgVal) False }
-};
-
-Arg timerArgs[] = {
- { XtNborderWidth, 0 },
- { XtNjustify, (XtArgVal) XtJustifyLeft }
-};
-
XtResource clientResources[] = {
{ "flashCount", "flashCount", XtRInt, sizeof(int),
XtOffset(AppDataPtr, flashCount), XtRImmediate,
XtActionsRec boardActions[] = {
{ "DrawPosition", DrawPositionProc },
- { "HandleUserMove", HandleUserMove },
- { "AnimateUserMove", AnimateUserMove },
{ "HandlePV", HandlePV },
{ "SelectPV", SelectPV },
{ "StopPV", StopPV },
- { "PieceMenuPopup", PieceMenuPopup },
- { "WhiteClock", WhiteClock },
- { "BlackClock", BlackClock },
{ "MenuItem", KeyBindingProc }, // [HGM] generic handler for key bindings
{ "QuitProc", QuitWrapper },
{ "ManProc", ManInner },
{ "TempBackwardProc", TempBackwardProc },
{ "TempForwardProc", TempForwardProc },
{ "CommentClick", (XtActionProc) CommentClick },
- { "ErrorPopDown", (XtActionProc) ErrorPopDown },
- { "GameListPopDown", (XtActionProc) GameListPopDown },
- { "GameListOptionsPopDown", (XtActionProc) GameListOptionsPopDown },
- { "PromotionPopDown", (XtActionProc) PromotionPopDown },
- { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
- { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
{ "GenericPopDown", (XtActionProc) GenericPopDown },
+ { "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "CopyMemoProc", (XtActionProc) CopyMemoProc },
{ "SelectMove", (XtActionProc) SelectMove },
{ "LoadSelectedProc", LoadSelectedProc },
};
char globalTranslations[] =
- ":<Key>F9: MenuItem(ResignProc) \n \
- :Ctrl<Key>n: MenuItem(NewGame) \n \
- :Meta<Key>V: MenuItem(NewVariant) \n \
- :Ctrl<Key>o: MenuItem(LoadGame) \n \
+ ":<Key>F9: MenuItem(Actions.Resign) \n \
+ :Ctrl<Key>n: MenuItem(File.NewGame) \n \
+ :Meta<Key>V: MenuItem(File.NewVariant) \n \
+ :Ctrl<Key>o: MenuItem(File.LoadGame) \n \
:Meta<Key>Next: MenuItem(LoadNextGameProc) \n \
:Meta<Key>Prior: MenuItem(LoadPrevGameProc) \n \
:Ctrl<Key>Down: LoadSelectedProc(3) \n \
:Ctrl<Key>Up: LoadSelectedProc(-3) \n \
- :Ctrl<Key>s: MenuItem(SaveGame) \n \
- :Ctrl<Key>c: MenuItem(CopyGame) \n \
- :Ctrl<Key>v: MenuItem(PasteGame) \n \
- :Ctrl<Key>O: MenuItem(LoadPosition) \n \
+ :Ctrl<Key>s: MenuItem(File.SaveGame) \n \
+ :Ctrl<Key>c: MenuItem(Edit.CopyGame) \n \
+ :Ctrl<Key>v: MenuItem(Edit.PasteGame) \n \
+ :Ctrl<Key>O: MenuItem(File.LoadPosition) \n \
:Shift<Key>Next: MenuItem(LoadNextPositionProc) \n \
:Shift<Key>Prior: MenuItem(LoadPrevPositionProc) \n \
- :Ctrl<Key>S: MenuItem(SavePosition) \n \
- :Ctrl<Key>C: MenuItem(CopyPosition) \n \
- :Ctrl<Key>V: MenuItem(PastePosition) \n \
- :Ctrl<Key>q: MenuItem(Exit) \n \
- :Ctrl<Key>w: MenuItem(MachineWhite) \n \
- :Ctrl<Key>b: MenuItem(MachineBlack) \n \
- :Ctrl<Key>t: MenuItem(TwoMachines) \n \
- :Ctrl<Key>a: MenuItem(AnalysisMode) \n \
- :Ctrl<Key>g: MenuItem(AnalyzeFile) \n \
- :Ctrl<Key>e: MenuItem(EditGame) \n \
- :Ctrl<Key>E: MenuItem(EditPosition) \n \
- :Meta<Key>O: MenuItem(ShowEngineOutput) \n \
- :Meta<Key>E: MenuItem(ShowEvaluationGraph) \n \
- :Meta<Key>G: MenuItem(ShowGameList) \n \
- :Meta<Key>H: MenuItem(ShowMoveHistory) \n \
- :<Key>Pause: MenuItem(Pause) \n \
- :<Key>F3: MenuItem(Accept) \n \
- :<Key>F4: MenuItem(Decline) \n \
- :<Key>F12: MenuItem(Rematch) \n \
- :<Key>F5: MenuItem(CallFlag) \n \
- :<Key>F6: MenuItem(Draw) \n \
- :<Key>F7: MenuItem(Adjourn) \n \
- :<Key>F8: MenuItem(Abort) \n \
- :<Key>F10: MenuItem(StopObserving) \n \
- :<Key>F11: MenuItem(StopExamining) \n \
+ :Ctrl<Key>S: MenuItem(File.SavePosition) \n \
+ :Ctrl<Key>C: MenuItem(Edit.CopyPosition) \n \
+ :Ctrl<Key>V: MenuItem(Edit.PastePosition) \n \
+ :Ctrl<Key>q: MenuItem(File.Quit) \n \
+ :Ctrl<Key>w: MenuItem(Mode.MachineWhite) \n \
+ :Ctrl<Key>b: MenuItem(Mode.MachineBlack) \n \
+ :Ctrl<Key>t: MenuItem(Mode.TwoMachines) \n \
+ :Ctrl<Key>a: MenuItem(Mode.AnalysisMode) \n \
+ :Ctrl<Key>g: MenuItem(Mode.AnalyzeFile) \n \
+ :Ctrl<Key>e: MenuItem(Mode.EditGame) \n \
+ :Ctrl<Key>E: MenuItem(Mode.EditPosition) \n \
+ :Meta<Key>O: MenuItem(View.EngineOutput) \n \
+ :Meta<Key>E: MenuItem(View.EvaluationGraph) \n \
+ :Meta<Key>G: MenuItem(View.GameList) \n \
+ :Meta<Key>H: MenuItem(View.MoveHistory) \n \
+ :<Key>Pause: MenuItem(Mode.Pause) \n \
+ :<Key>F3: MenuItem(Action.Accept) \n \
+ :<Key>F4: MenuItem(Action.Decline) \n \
+ :<Key>F12: MenuItem(Action.Rematch) \n \
+ :<Key>F5: MenuItem(Action.CallFlag) \n \
+ :<Key>F6: MenuItem(Action.Draw) \n \
+ :<Key>F7: MenuItem(Action.Adjourn) \n \
+ :<Key>F8: MenuItem(Action.Abort) \n \
+ :<Key>F10: MenuItem(Action.StopObserving) \n \
+ :<Key>F11: MenuItem(Action.StopExamining) \n \
:Ctrl<Key>d: MenuItem(DebugProc) \n \
:Meta Ctrl<Key>F12: MenuItem(DebugProc) \n \
- :Meta<Key>End: MenuItem(ToEnd) \n \
- :Meta<Key>Right: MenuItem(Forward) \n \
- :Meta<Key>Home: MenuItem(ToStart) \n \
- :Meta<Key>Left: MenuItem(Backward) \n \
- :<Key>Left: MenuItem(Backward) \n \
- :<Key>Right: MenuItem(Forward) \n \
- :<Key>Home: MenuItem(Revert) \n \
- :<Key>End: MenuItem(TruncateGame) \n \
- :Ctrl<Key>m: MenuItem(MoveNow) \n \
- :Ctrl<Key>x: MenuItem(RetractMove) \n \
- :Meta<Key>J: MenuItem(Adjudications) \n \
- :Meta<Key>U: MenuItem(CommonEngine) \n \
- :Meta<Key>T: MenuItem(TimeControl) \n \
+ :Meta<Key>End: MenuItem(Edit.ForwardtoEnd) \n \
+ :Meta<Key>Right: MenuItem(Edit.Forward) \n \
+ :Meta<Key>Home: MenuItem(Edit.BacktoStart) \n \
+ :Meta<Key>Left: MenuItem(Edit.Backward) \n \
+ :<Key>Left: MenuItem(Edit.Backward) \n \
+ :<Key>Right: MenuItem(Edit.Forward) \n \
+ :<Key>Home: MenuItem(Edit.Revert) \n \
+ :<Key>End: MenuItem(Edit.TruncateGame) \n \
+ :Ctrl<Key>m: MenuItem(Engine.MoveNow) \n \
+ :Ctrl<Key>x: MenuItem(Engine.RetractMove) \n \
+ :Meta<Key>J: MenuItem(Options.Adjudications) \n \
+ :Meta<Key>U: MenuItem(Options.CommonEngine) \n \
+ :Meta<Key>T: MenuItem(Options.TimeControl) \n \
:Ctrl<Key>P: MenuItem(PonderNextMove) \n "
#ifndef OPTIONSDIALOG
"\
:Ctrl<Key>H: MenuItem(HideThinkingProc) \n "
#endif
"\
- :<Key>F1: MenuItem(Manual) \n \
- :<Key>F2: MenuItem(FlipView) \n \
+ :<Key>F1: MenuItem(Help.ManXBoard) \n \
+ :<Key>F2: MenuItem(View.FlipView) \n \
:<KeyDown>Return: TempBackwardProc() \n \
:<KeyUp>Return: TempForwardProc() \n";
-char boardTranslations[] =
- "<Btn1Down>: HandleUserMove(0) \n \
- Shift<Btn1Up>: HandleUserMove(1) \n \
- <Btn1Up>: HandleUserMove(0) \n \
- <Btn1Motion>: AnimateUserMove() \n \
- <Btn3Motion>: HandlePV() \n \
- <Btn2Motion>: HandlePV() \n \
- <Btn3Up>: PieceMenuPopup(menuB) \n \
- <Btn2Up>: PieceMenuPopup(menuB) \n \
- Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
- PieceMenuPopup(menuB) \n \
- Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
- PieceMenuPopup(menuW) \n \
- Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
- PieceMenuPopup(menuW) \n \
- Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
- PieceMenuPopup(menuB) \n";
-
-char whiteTranslations[] =
- "Shift<BtnDown>: WhiteClock(1)\n \
- <BtnDown>: WhiteClock(0)\n";
-char blackTranslations[] =
- "Shift<BtnDown>: BlackClock(1)\n \
- <BtnDown>: BlackClock(0)\n";
-
char ICSInputTranslations[] =
"<Key>Up: UpKeyProc() \n "
"<Key>Down: DownKeyProc() \n "
char commentTranslations[] = "<Btn3Down>: extend-end() select-start() CommentClick() \n";
String xboardResources[] = {
- "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
+ "*Error*translations: #override\\n <Key>Return: ErrorPopDown()",
NULL
};
#define OPTCHAR "-"
#define SEPCHAR " "
-// these two must some day move to frontend.h, when they are implemented
-Boolean GameListIsUp();
-
// The option definition and parsing code common to XBoard and WinBoard is collected in this file
#include "args.h"
{ // no such option in XBoard (yet)
}
-extern Widget engineOutputShell;
int frameX, frameY;
void
GetActualPlacement (Widget wg, WindowPlacement *wp)
{
- Arg args[16];
- Dimension w, h;
- Position x, y;
XWindowAttributes winAt;
Window win, dummy;
- int i, rx, ry;
+ int rx, ry;
if(!wg) return;
- win = XtWindow(wg);
- XGetWindowAttributes(xDisplay, win, &winAt); // this works, where XtGetValues on XtNx, XtNy does not!
- XTranslateCoordinates (xDisplay, win, winAt.root, -winAt.border_width, -winAt.border_width, &rx, &ry, &dummy);
- wp->x = rx - winAt.x;
- wp->y = ry - winAt.y;
- wp->height = winAt.height;
- wp->width = winAt.width;
- frameX = winAt.x; frameY = winAt.y; // remember to decide if windows touch
+ win = XtWindow(wg);
+ XGetWindowAttributes(xDisplay, win, &winAt); // this works, where XtGetValues on XtNx, XtNy does not!
+ XTranslateCoordinates (xDisplay, win, winAt.root, -winAt.border_width, -winAt.border_width, &rx, &ry, &dummy);
+ wp->x = rx - winAt.x;
+ wp->y = ry - winAt.y;
+ wp->height = winAt.height;
+ wp->width = winAt.width;
+ frameX = winAt.x; frameY = winAt.y; // remember to decide if windows touch
}
void
{ // wrapper to shield use of window handles from back-end (make addressible by number?)
// In XBoard this will have to wait until awareness of window parameters is implemented
GetActualPlacement(shellWidget, &wpMain);
- if(EngineOutputIsUp()) GetActualPlacement(engineOutputShell, &wpEngineOutput);
- if(MoveHistoryIsUp()) GetActualPlacement(shells[HistoryDlg], &wpMoveHistory);
- if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
- if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
+ if(shellUp[EngOutDlg]) GetActualPlacement(shells[EngOutDlg], &wpEngineOutput);
+ if(shellUp[HistoryDlg]) GetActualPlacement(shells[HistoryDlg], &wpMoveHistory);
+ if(shellUp[EvalGraphDlg]) GetActualPlacement(shells[EvalGraphDlg], &wpEvalGraph);
+ if(shellUp[GameListDlg]) GetActualPlacement(shells[GameListDlg], &wpGameList);
if(shellUp[CommentDlg]) GetActualPlacement(shells[CommentDlg], &wpComment);
if(shellUp[TagsDlg]) GetActualPlacement(shells[TagsDlg], &wpTags);
}
}
void
+SwitchWindow ()
+{
+ extern Option dualOptions[];
+ static Window dual;
+ Window tmp = xBoardWindow;
+ cairo_surface_t *cstmp = csBoardWindow;
+ if(!dual) dual = XtWindow(dualOptions[3].handle); // must be first call
+ xBoardWindow = dual; // swap them
+ dual = tmp;
+ csBoardWindow = csDualBoard;
+ if(!csDualBoard && cstmp) {
+ int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+ }
+}
+
+void
PopUpStartupDialog ()
{ // start menu not implemented in XBoard
}
//--------------------------------------------------------------------------------------------
-#ifdef IDSIZES
- // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
-#else
+void
+NewSurfaces ()
+{
+ // delete surfaces after size becomes invalid, so they will be recreated
+ if(csBoardWindow) cairo_surface_destroy(csBoardWindow);
+ if(csBoardBackup) cairo_surface_destroy(csBoardBackup);
+ if(csDualBoard) cairo_surface_destroy(csDualBoard);
+ csBoardWindow = csBoardBackup = csDualBoard = NULL;
+}
+
#define BoardSize int
void
InitDrawingSizes (BoardSize boardSize, int flags)
{ // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
- Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
- Arg args[16];
- XtGeometryResult gres;
+ Dimension boardWidth, boardHeight, w, h;
int i;
static Dimension oldWidth, oldHeight;
static VariantClass oldVariant;
- static int oldDual = -1, oldMono = -1;
+ static int oldMono = -1, oldTwoBoards = 0;
if(!formWidget) return;
+ if(oldTwoBoards && !twoBoards) PopDown(DummyDlg);
+ oldTwoBoards = twoBoards;
+
if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- if(boardWidth != oldWidth || boardHeight != oldHeight || oldDual != twoBoards) { // do resizing stuff only if size actually changed
- /*
- * Enable shell resizing.
- */
- shellArgs[0].value = (XtArgVal) &w;
- shellArgs[1].value = (XtArgVal) &h;
- XtGetValues(shellWidget, shellArgs, 2);
-
- shellArgs[4].value = 3*w; shellArgs[2].value = 10;
- shellArgs[5].value = 2*h; shellArgs[3].value = 10;
- XtSetValues(shellWidget, &shellArgs[2], 4);
-
- XtSetArg(args[0], XtNdefaultDistance, &sep);
- XtGetValues(formWidget, args, 1);
+ if(boardWidth != oldWidth || boardHeight != oldHeight) { // do resizing stuff only if size actually changed
- oldWidth = boardWidth; oldHeight = boardHeight; oldDual = twoBoards;
+ oldWidth = boardWidth; oldHeight = boardHeight;
CreateGrid();
- hOffset = boardWidth + 10;
- for(i=0; i<BOARD_WIDTH+BOARD_HEIGHT+2; i++) { // [HGM] dual: grid for second board
- secondSegments[i] = gridSegments[i];
- secondSegments[i].x1 += hOffset;
- secondSegments[i].x2 += hOffset;
- }
-
- XtSetArg(args[0], XtNwidth, boardWidth);
- XtSetArg(args[1], XtNheight, boardHeight);
- XtSetValues(boardWidget, args, 2);
-
- timerWidth = (boardWidth - sep) / 2;
- XtSetArg(args[0], XtNwidth, timerWidth);
- XtSetValues(whiteTimerWidget, args, 1);
- XtSetValues(blackTimerWidget, args, 1);
-
- XawFormDoLayout(formWidget, False);
-
- if (appData.titleInWindow) {
- i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(titleWidget, args, i);
- if (smallLayout) {
- w = boardWidth - 2*bor;
- } else {
- XtSetArg(args[0], XtNwidth, &w);
- XtGetValues(menuBarWidget, args, 1);
- w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
- }
-
- gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr,
- _("%s: titleWidget geometry error %d %d %d %d %d\n"),
- programName, gres, w, h, wr, hr);
- }
- }
-
- XawFormDoLayout(formWidget, True);
+ NewSurfaces();
/*
* Inhibit shell resizing.
*/
- shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + twoBoards*hOffset; // [HGM] dual
+ shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + 1; // [HGM] not sure why the +1 is (sometimes) needed...
shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
shellArgs[4].value = shellArgs[2].value = w;
shellArgs[5].value = shellArgs[3].value = h;
- XtSetValues(shellWidget, &shellArgs[0], 6);
+ XtSetValues(shellWidget, &shellArgs[0], cairoAnimate ? 2 : 6);
XSync(xDisplay, False);
DelayedDrag();
}
}
}
+ for(i=0; i<2; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
+ }
oldMono = -10; // kludge to force recreation of animation masks
oldVariant = gameInfo.variant;
}
#if HAVE_LIBXPM
- if(appData.monoMode != oldMono)
+ if(appData.monoMode != oldMono || cairoAnimate)
CreateAnimVars();
#endif
oldMono = appData.monoMode;
}
-#endif
static int
MakeOneColor (char *name, Pixel *color)
forceMono |= MakeOneColor(appData.blackPieceColor, &blackPieceColor);
forceMono |= MakeOneColor(appData.highlightSquareColor, &highlightSquareColor);
forceMono |= MakeOneColor(appData.premoveHighlightColor, &premoveHighlightColor);
+ if (appData.lowTimeWarning)
+ forceMono |= MakeOneColor(appData.lowTimeWarningColor, &lowTimeWarningColor);
+ if(appData.dialogColor[0]) MakeOneColor(appData.dialogColor, &dialogColor);
+ if(appData.buttonColor[0]) MakeOneColor(appData.buttonColor, &buttonColor);
return forceMono;
}
CreateXPMBoard(appData.liteBackTextureFile, 1);
CreateXPMBoard(appData.darkBackTextureFile, 0);
}
+ if (appData.pngDirectory[0] != NULLCHAR) { // for now do in parallel
+ CreatePNGPieces();
+ }
#else
CreateXIMPieces();
/* Create regular pieces */
CreateAnyPieces();
}
+void
+InitializeFonts (int clockFontPxlSize, int coordFontPxlSize, int fontPxlSize)
+{ // detervtomine what fonts to use, and create them
+ XrmValue vTo;
+ XrmDatabase xdb;
+
+ if(!fontIsSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
+ appData.clockFont = fontTable[CLOCK_FONT][squareSize];
+ if(!fontIsSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
+ appData.font = fontTable[MESSAGE_FONT][squareSize];
+ if(!fontIsSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
+ appData.coordFont = fontTable[COORD_FONT][squareSize];
+
+#if ENABLE_NLS
+ appData.font = InsertPxlSize(appData.font, fontPxlSize);
+ appData.clockFont = InsertPxlSize(appData.clockFont, clockFontPxlSize);
+ appData.coordFont = InsertPxlSize(appData.coordFont, coordFontPxlSize);
+ fontSet = CreateFontSet(appData.font);
+ clockFontSet = CreateFontSet(appData.clockFont);
+ {
+ /* For the coordFont, use the 0th font of the fontset. */
+ XFontSet coordFontSet = CreateFontSet(appData.coordFont);
+ XFontStruct **font_struct_list;
+ XFontSetExtents *fontSize;
+ char **font_name_list;
+ XFontsOfFontSet(coordFontSet, &font_struct_list, &font_name_list);
+ coordFontID = XLoadFont(xDisplay, font_name_list[0]);
+ coordFontStruct = XQueryFont(xDisplay, coordFontID);
+ fontSize = XExtentsOfFontSet(fontSet); // [HGM] figure out how much vertical space font takes
+ textHeight = fontSize->max_logical_extent.height + 5; // add borderWidth
+ }
+#else
+ appData.font = FindFont(appData.font, fontPxlSize);
+ appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
+ appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
+ clockFontID = XLoadFont(xDisplay, appData.clockFont);
+ clockFontStruct = XQueryFont(xDisplay, clockFontID);
+ coordFontID = XLoadFont(xDisplay, appData.coordFont);
+ coordFontStruct = XQueryFont(xDisplay, coordFontID);
+ // textHeight in !NLS mode!
+#endif
+ countFontID = coordFontID; // [HGM] holdings
+ countFontStruct = coordFontStruct;
+
+ xdb = XtDatabase(xDisplay);
+#if ENABLE_NLS
+ XrmPutLineResource(&xdb, "*international: True");
+ vTo.size = sizeof(XFontSet);
+ vTo.addr = (XtPointer) &fontSet;
+ XrmPutResource(&xdb, "*fontSet", XtRFontSet, &vTo);
+#else
+ XrmPutStringResource(&xdb, "*font", appData.font);
+#endif
+}
+
+char *
+PrintArg (ArgType t)
+{
+ char *p="";
+ switch(t) {
+ case ArgZ:
+ case ArgInt: p = " N"; break;
+ case ArgString: p = " STR"; break;
+ case ArgBoolean: p = " TF"; break;
+ case ArgSettingsFilename:
+ case ArgFilename: p = " FILE"; break;
+ case ArgX: p = " Nx"; break;
+ case ArgY: p = " Ny"; break;
+ case ArgAttribs: p = " TEXTCOL"; break;
+ case ArgColor: p = " COL"; break;
+ case ArgFont: p = " FONT"; break;
+ case ArgBoardSize: p = " SIZE"; break;
+ case ArgFloat: p = " FLOAT"; break;
+ case ArgTrue:
+ case ArgFalse:
+ case ArgTwo:
+ case ArgNone:
+ case ArgCommSettings:
+ break;
+ }
+ return p;
+}
+
+void
+PrintOptions ()
+{
+ char buf[MSG_SIZ];
+ int len=0;
+ ArgDescriptor *q, *p = argDescriptors+5;
+ printf("\nXBoard accepts the following options:\n"
+ "(N = integer, TF = true or false, STR = text string, FILE = filename,\n"
+ " Nx, Ny = relative coordinates, COL = color, FONT = X-font spec,\n"
+ " SIZE = board-size spec(s)\n"
+ " Within parentheses are short forms, or options to set to true or false.\n"
+ " Persistent options (saved in the settings file) are marked with *)\n\n");
+ while(p->argName) {
+ if(p->argType == ArgCommSettings) { p++; continue; } // XBoard has no comm port
+ snprintf(buf+len, MSG_SIZ, "-%s%s", p->argName, PrintArg(p->argType));
+ if(p->save) strcat(buf+len, "*");
+ for(q=p+1; q->argLoc == p->argLoc; q++) {
+ if(q->argName[0] == '-') continue;
+ strcat(buf+len, q == p+1 ? " (" : " ");
+ sprintf(buf+strlen(buf), "-%s%s", q->argName, PrintArg(q->argType));
+ }
+ if(q != p+1) strcat(buf+len, ")");
+ len = strlen(buf);
+ if(len > 39) len = 0, printf("%s\n", buf); else while(len < 39) buf[len++] = ' ';
+ p = q;
+ }
+ if(len) buf[len] = NULLCHAR, printf("%s\n", buf);
+}
+
int
main (int argc, char **argv)
{
- int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
+ int i, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
XSetWindowAttributes window_attributes;
Arg args[16];
- Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
- XrmValue vFrom, vTo;
- XtGeometryResult gres;
+ Dimension boardWidth, boardHeight, w, h;
char *p;
- XrmDatabase xdb;
int forceMono = False;
srandom(time(0)); // [HGM] book: make random truly random
exit(0);
}
+ if(argc > 1 && !strcmp(argv[1], "--help" )) {
+ PrintOptions();
+ exit(0);
+ }
+
programName = strrchr(argv[0], '/');
if (programName == NULL)
programName = argv[0];
#ifdef ENABLE_NLS
XtSetLanguageProc(NULL, NULL, NULL);
+ if (appData.debugMode) {
+ fprintf(debugFP, "locale = %s\n", setlocale(LC_ALL, NULL));
+ }
+
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
- shellWidget =
- XtAppInitialize(&appContext, "XBoard", shellOptions,
- XtNumber(shellOptions),
- &argc, argv, xboardResources, NULL, 0);
appData.boardSize = "";
InitAppData(ConvertToLine(argc, argv));
p = getenv("HOME");
snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
- XtGetApplicationResources(shellWidget, (XtPointer) &appData,
- clientResources, XtNumber(clientResources),
- NULL, 0);
-
{ // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
static char buf[MSG_SIZ];
EscapeExpand(buf, appData.firstInitString);
setbuf(debugFP, NULL);
}
-#if ENABLE_NLS
- if (appData.debugMode) {
- fprintf(debugFP, "locale = %s\n", setlocale(LC_ALL, NULL));
- }
-#endif
-
/* [HGM,HR] make sure board size is acceptable */
if(appData.NrFiles > BOARD_FILES ||
appData.NrRanks > BOARD_RANKS )
#endif
InitBackEnd1();
+ gameInfo.variant = StringToVariant(appData.variant);
+ InitPosition(FALSE);
+
+ shellWidget =
+ XtAppInitialize(&appContext, "XBoard", shellOptions,
+ XtNumber(shellOptions),
+ &argc, argv, xboardResources, NULL, 0);
+
+ XtGetApplicationResources(shellWidget, (XtPointer) &appData,
+ clientResources, XtNumber(clientResources),
+ NULL, 0);
+
xDisplay = XtDisplay(shellWidget);
xScreen = DefaultScreen(xDisplay);
wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
- gameInfo.variant = StringToVariant(appData.variant);
- InitPosition(FALSE);
-
-#ifdef IDSIZE
- InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
-#else
+ /*
+ * determine size, based on supplied or remembered -size, or screen size
+ */
if (isdigit(appData.boardSize[0])) {
i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
&lineGap, &clockFontPxlSize, &coordFontPxlSize,
tinyLayout = szd->tinyLayout;
// [HGM] font: use defaults from settings file if available and not overruled
}
- if(!fontIsSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
- appData.clockFont = fontTable[CLOCK_FONT][squareSize];
- if(!fontIsSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
- appData.font = fontTable[MESSAGE_FONT][squareSize];
- if(!fontIsSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
- appData.coordFont = fontTable[COORD_FONT][squareSize];
/* Now, using squareSize as a hint, find a good XPM/XIM set size */
if (strlen(appData.pixmapDirectory) > 0) {
/* [HR] height treated separately (hacked) */
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight, boardHeight);
/*
* Determine what fonts to use.
*/
-#if ENABLE_NLS
- appData.font = InsertPxlSize(appData.font, fontPxlSize);
- appData.clockFont = InsertPxlSize(appData.clockFont, clockFontPxlSize);
- appData.coordFont = InsertPxlSize(appData.coordFont, coordFontPxlSize);
- fontSet = CreateFontSet(appData.font);
- clockFontSet = CreateFontSet(appData.clockFont);
- {
- /* For the coordFont, use the 0th font of the fontset. */
- XFontSet coordFontSet = CreateFontSet(appData.coordFont);
- XFontStruct **font_struct_list;
- XFontSetExtents *fontSize;
- char **font_name_list;
- XFontsOfFontSet(coordFontSet, &font_struct_list, &font_name_list);
- coordFontID = XLoadFont(xDisplay, font_name_list[0]);
- coordFontStruct = XQueryFont(xDisplay, coordFontID);
- fontSize = XExtentsOfFontSet(fontSet); // [HGM] figure out how much vertical space font takes
- textHeight = fontSize->max_logical_extent.height + 5; // add borderWidth
- }
-#else
- appData.font = FindFont(appData.font, fontPxlSize);
- appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
- appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
- clockFontID = XLoadFont(xDisplay, appData.clockFont);
- clockFontStruct = XQueryFont(xDisplay, clockFontID);
- coordFontID = XLoadFont(xDisplay, appData.coordFont);
- coordFontStruct = XQueryFont(xDisplay, coordFontID);
-#endif
- countFontID = coordFontID; // [HGM] holdings
- countFontStruct = coordFontStruct;
-
- xdb = XtDatabase(xDisplay);
-#if ENABLE_NLS
- XrmPutLineResource(&xdb, "*international: True");
- vTo.size = sizeof(XFontSet);
- vTo.addr = (XtPointer) &fontSet;
- XrmPutResource(&xdb, "*fontSet", XtRFontSet, &vTo);
-#else
- XrmPutStringResource(&xdb, "*font", appData.font);
-#endif
+ InitializeFonts(clockFontPxlSize, coordFontPxlSize, fontPxlSize);
/*
* Detect if there are not enough colors available and adapt.
appData.monoMode = True;
}
- if (appData.lowTimeWarning && !appData.monoMode) {
- vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
- vFrom.size = strlen(appData.lowTimeWarningColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
- if (vTo.addr == NULL)
- appData.monoMode = True;
- else
- lowTimeWarningColor = *(Pixel *) vTo.addr;
- }
-
if (appData.monoMode && appData.debugMode) {
fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
(unsigned long) XWhitePixel(xDisplay, xScreen),
} else {
layoutName = "normalLayout";
}
- /* Outer layoutWidget is there only to provide a name for use in
- resources that depend on the layout style */
- layoutWidget =
- XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
- layoutArgs, XtNumber(layoutArgs));
- formWidget =
- XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
- formArgs, XtNumber(formArgs));
- XtSetArg(args[0], XtNdefaultDistance, &sep);
- XtGetValues(formWidget, args, 1);
-
- j = 0;
- widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar, boardWidth);
- XtSetArg(args[0], XtNtop, XtChainTop);
- XtSetArg(args[1], XtNbottom, XtChainTop);
- XtSetArg(args[2], XtNright, XtChainLeft);
- XtSetValues(menuBarWidget, args, 3);
-
- widgetList[j++] = whiteTimerWidget =
- XtCreateWidget("whiteTime", labelWidgetClass,
- formWidget, timerArgs, XtNumber(timerArgs));
-#if ENABLE_NLS
- XtSetArg(args[0], XtNfontSet, clockFontSet);
-#else
- XtSetArg(args[0], XtNfont, clockFontStruct);
-#endif
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainTop);
- XtSetValues(whiteTimerWidget, args, 3);
- widgetList[j++] = blackTimerWidget =
- XtCreateWidget("blackTime", labelWidgetClass,
- formWidget, timerArgs, XtNumber(timerArgs));
+ optList = BoardPopUp(squareSize, lineGap, (void*)
#if ENABLE_NLS
- XtSetArg(args[0], XtNfontSet, clockFontSet);
+ &clockFontSet);
#else
- XtSetArg(args[0], XtNfont, clockFontStruct);
+ clockFontStruct);
#endif
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainTop);
- XtSetValues(blackTimerWidget, args, 3);
-
- if (appData.titleInWindow) {
- widgetList[j++] = titleWidget =
- XtCreateWidget("title", labelWidgetClass, formWidget,
- titleArgs, XtNumber(titleArgs));
- XtSetArg(args[0], XtNtop, XtChainTop);
- XtSetArg(args[1], XtNbottom, XtChainTop);
- XtSetValues(titleWidget, args, 2);
- }
-
- if (appData.showButtonBar) {
- widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
- XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
- XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
- XtSetArg(args[2], XtNtop, XtChainTop);
- XtSetArg(args[3], XtNbottom, XtChainTop);
- XtSetValues(buttonBarWidget, args, 4);
- }
-
- widgetList[j++] = messageWidget =
- XtCreateWidget("message", labelWidgetClass, formWidget,
- messageArgs, XtNumber(messageArgs));
- XtSetArg(args[0], XtNtop, XtChainTop);
- XtSetArg(args[1], XtNbottom, XtChainTop);
- XtSetValues(messageWidget, args, 2);
-
- widgetList[j++] = boardWidget =
- XtCreateWidget("board", widgetClass, formWidget, boardArgs,
- XtNumber(boardArgs));
-
- XtManageChildren(widgetList, j);
-
- timerWidth = (boardWidth - sep) / 2;
- XtSetArg(args[0], XtNwidth, timerWidth);
- XtSetValues(whiteTimerWidget, args, 1);
- XtSetValues(blackTimerWidget, args, 1);
-
+ boardWidget = optList[W_BOARD].handle;
+ menuBarWidget = optList[W_MENU].handle;
+ dropMenu = optList[W_DROP].handle;
+ titleWidget = optList[optList[W_TITLE].type != -1 ? W_TITLE : W_SMALL].handle;
+ formWidget = XtParent(boardWidget);
XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
- XtGetValues(whiteTimerWidget, args, 2);
-
- if (appData.showButtonBar) {
+ XtGetValues(optList[W_WHITE].handle, args, 2);
+ if (appData.showButtonBar) { // can't we use timer pixels for this? (Or better yet, just black & white?)
XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
- }
-
- /*
- * formWidget uses these constraints but they are stored
- * in the children.
- */
- i = 0;
- XtSetArg(args[i], XtNfromHoriz, 0); i++;
- XtSetValues(menuBarWidget, args, i);
- if (appData.titleInWindow) {
- if (smallLayout) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
- XtSetValues(titleWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- } else {
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
- XtSetValues(titleWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- }
- } else {
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- }
- i = 0;
- XtSetArg(args[0], XtNfromVert, messageWidget);
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainBottom);
- XtSetArg(args[3], XtNleft, XtChainLeft);
- XtSetArg(args[4], XtNright, XtChainRight);
- XtSetValues(boardWidget, args, 5);
-
- XtRealizeWidget(shellWidget);
-
- if(wpMain.x > 0) {
- XtSetArg(args[0], XtNx, wpMain.x);
- XtSetArg(args[1], XtNy, wpMain.y);
- XtSetValues(shellWidget, args, 2);
- }
-
- /*
- * Correct the width of the message and title widgets.
- * It is not known why some systems need the extra fudge term.
- * The value "2" is probably larger than needed.
- */
- XawFormDoLayout(formWidget, False);
-
-#define WIDTH_FUDGE 2
- i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNwidth, &w); i++;
- XtGetValues(buttonBarWidget, args, i);
- w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
- } else {
- w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
- }
-
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
- programName, gres, w, h, wr, hr);
- }
-
- /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
- /* The size used for the child widget in layout lags one resize behind
- its true size, so we resize a second time, 1 pixel smaller. Yeech! */
- w--;
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
- programName, gres, w, h, wr, hr);
- }
- /* !! end hack */
- if(!textHeight) textHeight = hr; // [HGM] if !NLS textHeight is still undefined, and we grab it from here
- XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
- XtSetArg(args[1], XtNright, XtChainRight);
- XtSetValues(messageWidget, args, 2);
-
- if (appData.titleInWindow) {
- i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(titleWidget, args, i);
- if (smallLayout) {
- w = boardWidth - 2*bor;
- } else {
- XtSetArg(args[0], XtNwidth, &w);
- XtGetValues(menuBarWidget, args, 1);
- w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
- }
-
- gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr,
- _("%s: titleWidget geometry error %d %d %d %d %d\n"),
- programName, gres, w, h, wr, hr);
- }
+ XtGetValues(optList[W_PAUSE].handle, args, 2);
}
- XawFormDoLayout(formWidget, True);
+ AppendEnginesToMenu(appData.recentEngineList);
xBoardWindow = XtWindow(boardWidget);
// [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
// not need to go into InitDrawingSizes().
-#endif
/*
* Create X checkmark bitmap and initialize option menu checks.
/*
* Inhibit shell resizing.
*/
+
+ CreateAnyPieces();
+ cairoAnimate = *appData.pngDirectory && useTexture == 3
+ && strstr(appData.liteBackTextureFile, ".png") && strstr(appData.darkBackTextureFile, ".png");
+
shellArgs[0].value = (XtArgVal) &w;
shellArgs[1].value = (XtArgVal) &h;
XtGetValues(shellWidget, shellArgs, 2);
shellArgs[4].value = shellArgs[2].value = w;
shellArgs[5].value = shellArgs[3].value = h;
- XtSetValues(shellWidget, &shellArgs[2], 4);
+ if(!cairoAnimate) XtSetValues(shellWidget, &shellArgs[2], 4);
marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
marginH = h - boardHeight;
CreateGCs(False);
CreateGrid();
- CreateAnyPieces();
- CreatePieceMenus();
+ if(appData.logoSize)
+ { // locate and read user logo
+ char buf[MSG_SIZ];
+ snprintf(buf, MSG_SIZ, "%s/%s.png", appData.logoDir, UserName());
+ ASSIGN(userLogo, buf);
+ }
if (appData.animate || appData.animateDragging)
CreateAnimVars();
XtAugmentTranslations(formWidget,
XtParseTranslationTable(globalTranslations));
- XtAugmentTranslations(boardWidget,
- XtParseTranslationTable(boardTranslations));
- XtAugmentTranslations(whiteTimerWidget,
- XtParseTranslationTable(whiteTranslations));
- XtAugmentTranslations(blackTimerWidget,
- XtParseTranslationTable(blackTranslations));
-
- /* Why is the following needed on some versions of X instead
- * of a translation? */
- XtAddEventHandler(boardWidget, ExposureMask|PointerMotionMask, False,
- (XtEventHandler) EventProc, NULL);
- /* end why */
+
XtAddEventHandler(formWidget, KeyPressMask, False,
(XtEventHandler) MoveTypeInProc, NULL);
XtAddEventHandler(shellWidget, StructureNotifyMask, False,
gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
InitPosition(TRUE);
+ UpdateLogos(TRUE);
// XtSetKeyboardFocus(shellWidget, formWidget);
XSetInputFocus(xDisplay, XtWindow(formWidget), RevertToPointerRoot, CurrentTime);
static void
CreateGCs (int redo)
{
- XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
- | GCBackground | GCFunction | GCPlaneMask;
XGCValues gc_values;
GC copyInvertedGC;
Pixel white = XWhitePixel(xDisplay, xScreen);
XpmAttributes attr;
attr.valuemask = 0;
if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
+ if(strstr(s, ".png")) {
+ cairo_surface_t *img = cairo_image_surface_create_from_png (s);
+ if(img) {
+ useTexture |= kind + 1; pngBoardBitmap[kind] = img;
+ textureW[kind] = cairo_image_surface_get_width (img);
+ textureH[kind] = cairo_image_surface_get_height (img);
+ }
+ } else
if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
}
}
#endif /* HAVE_LIBXPM */
+char *pngPieceNames[] = // must be in same order as internal piece encoding
+{ "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner",
+ "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "King",
+ "GoldKnight", "GoldLance", "GoldPawn", "GoldSilver", NULL
+};
+
+void
+ScaleOnePiece (char *name, int color, int piece)
+{
+ int w, h;
+ char buf[MSG_SIZ];
+ cairo_surface_t *img, *cs;
+ cairo_t *cr;
+ static cairo_surface_t *pngPieceImages[2][(int)BlackPawn+4]; // png 256 x 256 images
+
+ if((img = pngPieceImages[color][piece]) == NULL) { // if PNG file for this piece was not yet read, read it now and store it
+ snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pngDirectory, color ? "Black" : "White", pngPieceNames[piece]);
+ pngPieceImages[color][piece] = img = cairo_image_surface_create_from_png (buf);
+ w = cairo_image_surface_get_width (img);
+ h = cairo_image_surface_get_height (img);
+ if(w != 64 || h != 64) { printf("Bad png size %dx%d in %s\n", w, h, buf); exit(1); }
+ }
+ // create new bitmap to hold scaled piece image (and remove any old)
+ if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
+ pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ if(piece <= WhiteKing) pngPieceBitmaps[color][piece] = cs;
+ // scaled copying of the raw png image
+ cr = cairo_create(cs);
+ cairo_scale(cr, squareSize/64., squareSize/64.);
+ cairo_set_source_surface (cr, img, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+}
+
+void
+CreatePNGPieces ()
+{
+ int p;
+
+ for(p=0; pngPieceNames[p]; p++) {
+ ScaleOnePiece(pngPieceNames[p], 0, p);
+ ScaleOnePiece(pngPieceNames[p], 1, p);
+ }
+}
+
#if HAVE_LIBXPM
/* No built-in bitmaps */
void CreatePieces()
}
}
-int nrOfMenuItems = 7;
-Widget menuWidget[150];
-MenuListItem menuItemList[150] = {
- { "LoadNextGameProc", LoadNextGameProc },
- { "LoadPrevGameProc", LoadPrevGameProc },
- { "ReloadGameProc", ReloadGameProc },
- { "ReloadPositionProc", ReloadPositionProc },
-#ifndef OPTIONSDIALOG
- { "AlwaysQueenProc", AlwaysQueenProc },
- { "AnimateDraggingProc", AnimateDraggingProc },
- { "AnimateMovingProc", AnimateMovingProc },
- { "AutoflagProc", AutoflagProc },
- { "AutoflipProc", AutoflipProc },
- { "BlindfoldProc", BlindfoldProc },
- { "FlashMovesProc", FlashMovesProc },
-#if HIGHDRAG
- { "HighlightDraggingProc", HighlightDraggingProc },
-#endif
- { "HighlightLastMoveProc", HighlightLastMoveProc },
-// { "IcsAlarmProc", IcsAlarmProc },
- { "MoveSoundProc", MoveSoundProc },
- { "PeriodicUpdatesProc", PeriodicUpdatesProc },
- { "PopupExitMessageProc", PopupExitMessageProc },
- { "PopupMoveErrorsProc", PopupMoveErrorsProc },
-// { "PremoveProc", PremoveProc },
- { "ShowCoordsProc", ShowCoordsProc },
- { "ShowThinkingProc", ShowThinkingProc },
- { "HideThinkingProc", HideThinkingProc },
- { "TestLegalityProc", TestLegalityProc },
-#endif
- { "AboutGameProc", AboutGameEvent },
- { "DebugProc", DebugProc },
- { "NothingProc", NothingProc },
- {NULL, NothingProc}
-};
-
void
MarkMenuItem (char *menuRef, int state)
{
- int nr = MenuToNumber(menuRef);
- if(nr >= 0) {
+ MenuItem *item = MenuNameToItem(menuRef);
+
+ if(item) {
Arg args[2];
XtSetArg(args[0], XtNleftBitmap, state ? xMarkPixmap : None);
- XtSetValues(menuWidget[nr], args, 1);
+ XtSetValues(item->handle, args, 1);
}
}
void
-EnableMenuItem (char *menuRef, int state)
+EnableNamedMenuItem (char *menuRef, int state)
{
- int nr = MenuToNumber(menuRef);
- if(nr >= 0) XtSetSensitive(menuWidget[nr], state);
+ MenuItem *item = MenuNameToItem(menuRef);
+
+ if(item) XtSetSensitive(item->handle, state);
}
void
EnableButtonBar (int state)
{
- XtSetSensitive(buttonBarWidget, state);
+ XtSetSensitive(optList[W_BUTTON].handle, state);
}
SetMenuEnables (Enables *enab)
{
while (enab->name != NULL) {
- EnableMenuItem(enab->name, enab->value);
+ EnableNamedMenuItem(enab->name, enab->value);
enab++;
}
}
-int
-Equal(char *p, char *s)
-{ // compare strings skipping spaces in second
- while(*s) {
- if(*s == ' ') { s++; continue; }
- if(*s++ != *p++) return 0;
- }
- return !*p;
-}
-
void
KeyBindingProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
{ // [HGM] new method of key binding: specify MenuItem(FlipView) in stead of FlipViewProc in translation string
- int i;
+ MenuItem *item;
if(*nprms == 0) return;
- for(i=0; menuItemList[i].name; i++) {
- if(Equal(prms[0], menuItemList[i].name)) {
- (menuItemList[i].proc) ();
- return;
- }
- }
-}
-
-static void
-MenuBarSelect (Widget w, caddr_t addr, caddr_t index)
-{
- MenuProc *proc = (MenuProc *) addr;
-
- (proc)();
+ item = MenuNameToItem(prms[0]);
+ if(item) ((MenuProc *) item->proc) ();
}
static void
RecentEngineEvent((int) (intptr_t) addr);
}
-// some stuff that must remain in front-end
-static Widget mainBar, currentMenu;
-static int wtot, nr = 0, widths[10];
-
-void
-AppendMenuItem (char *text, char *name, MenuProc *action)
-{
- int j;
- Widget entry;
- Arg args[16];
-
- j = 0;
- XtSetArg(args[j], XtNleftMargin, 20); j++;
- XtSetArg(args[j], XtNrightMargin, 20); j++;
-
- if (strcmp(text, "----") == 0) {
- entry = XtCreateManagedWidget(text, smeLineObjectClass,
- currentMenu, args, j);
- } else {
- XtSetArg(args[j], XtNlabel, XtNewString(_(text)));
- entry = XtCreateManagedWidget(name, smeBSBObjectClass,
- currentMenu, args, j+1);
- XtAddCallback(entry, XtNcallback,
- (XtCallbackProc) (strcmp(name, "recent") ? MenuBarSelect : MenuEngineSelect),
- (caddr_t) action);
- menuWidget[nrOfMenuItems] = entry;
- }
-}
-
-void
-CreateMenuButton (char *name, Menu *mb)
-{ // create menu button on main bar, and shell for pull-down list
- int i, j;
- Arg args[16];
- Dimension w;
-
- j = 0;
- XtSetArg(args[j], XtNmenuName, XtNewString(name)); j++;
- XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name))); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- mb->subMenu = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,
- mainBar, args, j);
- currentMenu = XtCreatePopupShell(name, simpleMenuWidgetClass,
- mainBar, NULL, 0);
- j = 0;
- XtSetArg(args[j], XtNwidth, &w); j++;
- XtGetValues(mb->subMenu, args, j);
- wtot += mb->textWidth = widths[nr++] = w;
-}
-
-Widget
-CreateMenuBar (Menu *mb, int boardWidth)
-{
- int i, j;
- Arg args[16];
- char menuName[MSG_SIZ];
- Dimension w;
- Menu *ma = mb;
-
- // create bar itself
- j = 0;
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
- XtSetArg(args[j], XtNvSpace, 0); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- mainBar = XtCreateWidget("menuBar", boxWidgetClass,
- formWidget, args, j);
-
- CreateMainMenus(mb); // put menus in bar according to description in back-end
-
- // size buttons to make menu bar fit, clipping menu names where necessary
- while(wtot > boardWidth - 40) {
- int wmax=0, imax=0;
- for(i=0; i<nr; i++) if(widths[i] > wmax) wmax = widths[imax=i];
- widths[imax]--;
- wtot--;
- }
- for(i=0; i<nr; i++) if(widths[i] != ma[i].textWidth) {
- j = 0;
- XtSetArg(args[j], XtNwidth, widths[i]); j++;
- XtSetValues(ma[i].subMenu, args, j);
- }
-
- return mainBar;
-}
-
-Widget
-CreateButtonBar (MenuItem *mi)
-{
- int j;
- Widget button, buttonBar;
- Arg args[16];
-
- j = 0;
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
- if (tinyLayout) {
- XtSetArg(args[j], XtNhSpace, 0); j++;
- }
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- XtSetArg(args[j], XtNvSpace, 0); j++;
- buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,
- formWidget, args, j);
-
- while (mi->string != NULL) {
- j = 0;
- if (tinyLayout) {
- XtSetArg(args[j], XtNinternalWidth, 2); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- }
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
- button = XtCreateManagedWidget(mi->string, commandWidgetClass,
- buttonBar, args, j);
- XtAddCallback(button, XtNcallback,
- (XtCallbackProc) MenuBarSelect,
- (caddr_t) mi->proc);
- mi++;
- }
- return buttonBar;
-}
-
-Widget
-CreatePieceMenu (char *name, int color)
-{
- int i;
- Widget entry, menu;
- Arg args[16];
- ChessSquare selection;
-
- menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
- boardWidget, args, 0);
-
- for (i = 0; i < PIECE_MENU_SIZE; i++) {
- String item = pieceMenuStrings[color][i];
-
- if (strcmp(item, "----") == 0) {
- entry = XtCreateManagedWidget(item, smeLineObjectClass,
- menu, NULL, 0);
- } else {
- XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
- entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- menu, args, 1);
- selection = pieceMenuTranslation[color][i];
- XtAddCallback(entry, XtNcallback,
- (XtCallbackProc) PieceMenuSelect,
- (caddr_t) selection);
- if (selection == WhitePawn || selection == BlackPawn) {
- XtSetArg(args[0], XtNpopupOnEntry, entry);
- XtSetValues(menu, args, 1);
- }
- }
- }
- return menu;
-}
-
void
-CreatePieceMenus ()
+AppendMenuItem (char *msg, int n)
{
- int i;
- Widget entry;
- Arg args[16];
- ChessSquare selection;
-
- whitePieceMenu = CreatePieceMenu("menuW", 0);
- blackPieceMenu = CreatePieceMenu("menuB", 1);
-
- if(appData.pieceMenu) // [HGM] sweep: no idea what this was good for, but it stopped reporting button events outside the window
- XtRegisterGrabAction(PieceMenuPopup, True,
- (unsigned)(ButtonPressMask|ButtonReleaseMask),
- GrabModeAsync, GrabModeAsync);
-
- XtSetArg(args[0], XtNlabel, _("Drop"));
- dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,
- boardWidget, args, 1);
- for (i = 0; i < DROP_MENU_SIZE; i++) {
- String item = dropMenuStrings[i];
-
- if (strcmp(item, "----") == 0) {
- entry = XtCreateManagedWidget(item, smeLineObjectClass,
- dropMenu, NULL, 0);
- } else {
- XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
- entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- dropMenu, args, 1);
- selection = dropMenuTranslation[i];
- XtAddCallback(entry, XtNcallback,
- (XtCallbackProc) DropMenuSelect,
- (caddr_t) selection);
- }
- }
+ CreateMenuItem((Widget) optList[W_ENGIN].textValue, msg, (XtCallbackProc) MenuEngineSelect, n);
}
void
}
}
-void
-PieceMenuPopup (Widget w, XEvent *event, String *params, Cardinal *num_params)
-{
- String whichMenu; int menuNr = -2;
- shiftKey = strcmp(params[0], "menuW"); // used to indicate black
- if (event->type == ButtonRelease)
- menuNr = RightClick(Release, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
- else if (event->type == ButtonPress)
- menuNr = RightClick(Press, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
- switch(menuNr) {
- case 0: whichMenu = params[0]; break;
- case 1: SetupDropMenu(); whichMenu = "menuD"; break;
- case 2:
- case -1: if (errorUp) ErrorPopDown();
- default: return;
- }
- XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
-}
-
-static void
-PieceMenuSelect (Widget w, ChessSquare piece, caddr_t junk)
-{
- if (pmFromX < 0 || pmFromY < 0) return;
- EditPositionMenuEvent(piece, pmFromX, pmFromY);
-}
static void
-DropMenuSelect (Widget w, ChessSquare piece, caddr_t junk)
-{
- if (pmFromX < 0 || pmFromY < 0) return;
- DropMenuEvent(piece, pmFromX, pmFromY);
-}
-
-void
-WhiteClock (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+do_flash_delay (unsigned long msec)
{
- shiftKey = prms[0][0] & 1;
- ClockClick(0);
+ TimeDelay(msec);
}
void
-BlackClock (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+DoDrawBorder (cairo_surface_t *cs, int x, int y, int type)
{
- shiftKey = prms[0][0] & 1;
- ClockClick(1);
-}
-
+ cairo_t *cr;
+ DrawSeekOpen();
-static void
-do_flash_delay (unsigned long msec)
-{
- TimeDelay(msec);
+ cr = cairo_create(cs);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
+ SetPen(cr, lineGap, type == 1 ? appData.highlightSquareColor : appData.premoveHighlightColor, 0);
+ cairo_stroke(cr);
}
void
DrawBorder (int x, int y, int type)
{
- GC gc = lineGC;
-
- if(type == 1) gc = highlineGC; else if(type == 2) gc = prelineGC;
-
- XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
- squareSize+lineGap, squareSize+lineGap);
+ DoDrawBorder(csBoardWindow, x, y, type);
+ DoDrawBorder(csBoardBackup, x, y, type);
}
static int
return 1;
}
+void
+DrawLogo (void *handle, void *logo)
+{
+ cairo_surface_t *img, *cs;
+ cairo_t *cr;
+ int w, h;
+
+ if(!logo || !handle) return;
+ cs = cairo_xlib_surface_create(xDisplay, XtWindow(handle), DefaultVisual(xDisplay, 0), appData.logoSize, appData.logoSize/2);
+ img = cairo_image_surface_create_from_png (logo);
+ w = cairo_image_surface_get_width (img);
+ h = cairo_image_surface_get_height (img);
+ cr = cairo_create(cs);
+ cairo_scale(cr, (float)appData.logoSize/w, appData.logoSize/(2.*h));
+ cairo_set_source_surface (cr, img, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+ cairo_surface_destroy (img);
+ cairo_surface_destroy (cs);
+}
+
static void
BlankSquare (int x, int y, int color, ChessSquare piece, Drawable dest, int fac)
{ // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
int x0, y0;
if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
+ if(pngBoardBitmap[color]) {
+ cairo_t *cr;
+ if(!fac && !cairoAnimate) return;
+ DrawSeekOpen();
+ cr = cairo_create (fac ? csBoardWindow : (cairo_surface_t *) dest);
+ cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ if(fac) {
+ cr = cairo_create (csBoardBackup);
+ cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ }
+ } else
XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
squareSize, squareSize, x*fac, y*fac);
} else
+ if(csBoardWindow) {
+ cairo_t *cr = cairo_create (csBoardWindow);
+ char *col;
+ switch (color) {
+ case 0: col = appData.darkSquareColor; break;
+ case 1: col = appData.lightSquareColor; break;
+ case 2: col = "#000000"; break;
+ }
+ SetPen(cr, 2.0, col, 0);
+ cairo_rectangle (cr, x, y, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ SetPen(cr, 2.0, col, 0);
+ cairo_rectangle (cr, x, y, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ } else
if (useImages && useImageSqs) {
Pixmap pm;
switch (color) {
squareSize, squareSize, x, y);
}
+static void
+pngDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ int kind, p = piece;
+ cairo_t *cr;
+
+ if ((int)piece < (int) BlackPawn) {
+ kind = 0;
+ } else {
+ kind = 1;
+ piece -= BlackPawn;
+ }
+ if(appData.upsideDown && flipView) { p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
+ BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+ DrawSeekOpen();
+ cr = cairo_create (csBoardWindow);
+ cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+ cairo_paint(cr);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+ cairo_paint(cr);
+ cairo_destroy (cr);
+}
+
typedef void (*DrawFunc)();
DrawFunc
} else {
return monoDrawPiece;
}
+ } else if(appData.pngDirectory[0]) {
+ return pngDrawPiece;
} else {
if (useImages)
return colorDrawPieceImage;
}
void
-DrawDot (int marker, int x, int y, int r)
+DoDrawDot (int marker, int x, int y, int r, cairo_surface_t *cs)
{
+ cairo_t *cr;
+ DrawSeekOpen();
+ cr = cairo_create(cs);
+ cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
if(appData.monoMode) {
- XFillArc(xDisplay, xBoardWindow, marker == 2 ? darkSquareGC : lightSquareGC,
- x, y, r, r, 0, 64*360);
- XDrawArc(xDisplay, xBoardWindow, marker == 2 ? lightSquareGC : darkSquareGC,
- x, y, r, r, 0, 64*360);
- } else
- XFillArc(xDisplay, xBoardWindow, marker == 2 ? prelineGC : highlineGC,
- x, y, r, r, 0, 64*360);
+ SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
+ cairo_stroke_preserve(cr);
+ SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
+ } else {
+ SetPen(cr, 2, marker == 2 ? "#FF0000" : "#FFFF00", 0);
+ }
+ cairo_fill(cr);
+ cairo_stroke(cr);
+
+ cairo_destroy(cr);
+}
+
+void
+DrawDot (int marker, int x, int y, int r)
+{
+ DoDrawDot(marker, x, y, r, csBoardWindow);
+ DoDrawDot(marker, x, y, r, csBoardBackup);
}
void
if (appData.monoMode) {
XDrawImageString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
} else {
+ if(*appData.pngDirectory) {
+ cairo_t *cr = cairo_create (csBoardWindow);
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_BOLD);
+
+ cairo_set_font_size (cr, squareSize/4);
+
+ cairo_move_to (cr, xx-1, yy);
+ if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ else cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+ cairo_show_text (cr, string);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_BOLD);
+
+ cairo_set_font_size (cr, squareSize/4);
+
+ cairo_move_to (cr, xx-1, yy);
+ if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ else cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+ cairo_show_text (cr, string);
+ cairo_destroy (cr);
+ } else
XDrawString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
}
}
XtSetValues(sh, args, j);
}
+void
+ReSize (WindowPlacement *wp)
+{
+ int sqx, sqy;
+ if(wp->width == wpMain.width && wp->height == wpMain.height) return; // not sized
+ sqx = (wp->width - lineGap - marginW) / BOARD_WIDTH - lineGap;
+ sqy = (wp->height - lineGap - marginH) / BOARD_HEIGHT - lineGap;
+ if(sqy < sqx) sqx = sqy;
+ if(sqx != squareSize) {
+ squareSize = sqx; // adopt new square size
+ NewSurfaces();
+ CreatePNGPieces(); // make newly scaled pieces
+ InitDrawingSizes(0, 0); // creates grid etc.
+ }
+}
+
static XtIntervalId delayedDragID = 0;
void
DragProc ()
{
+ static int busy;
+ if(busy) return;
+
+ busy = 1;
GetActualPlacement(shellWidget, &wpNew);
if(wpNew.x == wpMain.x && wpNew.y == wpMain.y && // not moved
- wpNew.width == wpMain.width && wpNew.height == wpMain.height) // not sized
- return; // false alarm
- if(EngineOutputIsUp()) CoDrag(engineOutputShell, &wpEngineOutput);
- if(MoveHistoryIsUp()) CoDrag(shells[HistoryDlg], &wpMoveHistory);
- if(EvalGraphIsUp()) CoDrag(evalGraphShell, &wpEvalGraph);
- if(GameListIsUp()) CoDrag(gameListShell, &wpGameList);
+ wpNew.width == wpMain.width && wpNew.height == wpMain.height) { // not sized
+ busy = 0; return; // false alarm
+ }
+ ReSize(&wpNew);
+ if(shellUp[EngOutDlg]) CoDrag(shells[EngOutDlg], &wpEngineOutput);
+ if(shellUp[HistoryDlg]) CoDrag(shells[HistoryDlg], &wpMoveHistory);
+ if(shellUp[EvalGraphDlg]) CoDrag(shells[EvalGraphDlg], &wpEvalGraph);
+ if(shellUp[GameListDlg]) CoDrag(shells[GameListDlg], &wpGameList);
wpMain = wpNew;
DrawPosition(True, NULL);
delayedDragID = 0; // now drag executed, make sure next DelayedDrag will not cancel timer event (which could now be used by other)
+ busy = 0;
}
{
if(delayedDragID) XtRemoveTimeOut(delayedDragID); // cancel pending
delayedDragID =
- XtAppAddTimeOut(appContext, 50, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
+ XtAppAddTimeOut(appContext, 100, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
}
-/* Why is this needed on some versions of X? */
void
EventProc (Widget widget, caddr_t unused, XEvent *event)
{
- if (!XtIsRealized(widget))
- return;
- switch (event->type) {
- case ConfigureNotify: // main window is being dragged: drag attached windows with it
- if(appData.useStickyWindows)
- DelayedDrag(); // as long as events keep coming in faster than 50 msec, they destroy each other
- break;
- case Expose:
- if (event->xexpose.count > 0) return; /* no clipping is done */
- DrawPosition(True, NULL);
- if(twoBoards) { // [HGM] dual: draw other board in other orientation
- flipView = !flipView; partnerUp = !partnerUp;
- DrawPosition(True, NULL);
- flipView = !flipView; partnerUp = !partnerUp;
- }
- break;
- case MotionNotify:
- if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;
- default:
- return;
- }
+ if(XtIsRealized(widget) && event->type == ConfigureNotify || appData.useStickyWindows)
+ DelayedDrag(); // as long as events keep coming in faster than 50 msec, they destroy each other
}
-/* end why */
-// [HGM] seekgraph: some low-level drawing routines cloned from xevalgraph
-void
-DrawSeekAxis (int x, int y, int xTo, int yTo)
+// [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
+
+float
+Color (char *col, int n)
{
- XDrawLine(xDisplay, xBoardWindow, lineGC, x, y, xTo, yTo);
+ int c;
+ sscanf(col, "#%x", &c);
+ c = c >> 4*n & 255;
+ return c/255.;
}
void
-DrawSeekBackground (int left, int top, int right, int bottom)
+SetPen (cairo_t *cr, float w, char *col, int dash)
{
- XFillRectangle(xDisplay, xBoardWindow, lightSquareGC, left, top, right-left, bottom-top);
+ static const double dotted[] = {4.0, 4.0};
+ static int len = sizeof(dotted) / sizeof(dotted[0]);
+ cairo_set_line_width (cr, w);
+ cairo_set_source_rgba (cr, Color(col, 4), Color(col, 2), Color(col, 0), 1.0);
+ if(dash) cairo_set_dash (cr, dotted, len, 0.0);
}
-void
-DrawSeekText (char *buf, int x, int y)
+void DrawSeekAxis( int x, int y, int xTo, int yTo )
{
- XDrawString(xDisplay, xBoardWindow, coordGC, x, y+4, buf, strlen(buf));
+ cairo_t *cr;
+
+ /* get a cairo_t */
+ cr = cairo_create (csBoardWindow);
+
+ cairo_move_to (cr, x, y);
+ cairo_line_to(cr, xTo, yTo );
+
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
}
-void
-DrawSeekDot (int x, int y, int colorNr)
+void DrawSeekBackground( int left, int top, int right, int bottom )
{
+ cairo_t *cr = cairo_create (csBoardWindow);
+
+ cairo_rectangle (cr, left, top, right-left, bottom-top);
+
+ cairo_set_source_rgba(cr, 0.8, 0.8, 0.4,1.0);
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void DrawSeekText(char *buf, int x, int y)
+{
+ cairo_t *cr = cairo_create (csBoardWindow);
+
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
+
+ cairo_set_font_size (cr, 12.0);
+
+ cairo_move_to (cr, x, y+4);
+ cairo_set_source_rgba(cr, 0, 0, 0,1.0);
+ cairo_show_text( cr, buf);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void DrawSeekDot(int x, int y, int colorNr)
+{
+ cairo_t *cr = cairo_create (csBoardWindow);
int square = colorNr & 0x80;
- GC color;
colorNr &= 0x7F;
- color = colorNr == 0 ? prelineGC : colorNr == 1 ? darkSquareGC : highlineGC;
+
if(square)
- XFillRectangle(xDisplay, xBoardWindow, color,
- x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
+ cairo_rectangle (cr, x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
else
- XFillArc(xDisplay, xBoardWindow, color,
- x-squareSize/8, y-squareSize/8, squareSize/4, squareSize/4, 0, 64*360);
+ cairo_arc(cr, x, y, squareSize/8, 0.0, 2*M_PI);
+
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke_preserve(cr);
+ switch (colorNr) {
+ case 0: cairo_set_source_rgba(cr, 1.0, 0, 0,1.0); break;
+ case 1: cairo_set_source_rgba (cr, 0.0, 0.7, 0.2, 1.0); break;
+ default: cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 1.0); break;
+ }
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
}
void
-DrawGrid (int second)
+DrawSeekOpen ()
{
- XDrawSegments(xDisplay, xBoardWindow, lineGC,
- second ? secondSegments : // [HGM] dual
- gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
+ int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ if(!csBoardWindow) {
+ csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+ csBoardBackup = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, boardWidth, boardHeight);
+ }
}
-
-/*
- * event handler for redrawing the board
- */
void
-DrawPositionProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+DrawSeekClose ()
{
- DrawPosition(True, NULL);
}
-
-/*
- * event handler for parsing user moves
- */
-// [HGM] This routine will need quite some reworking. Although the backend still supports the old
-// way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform
-// it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it
-// should be made to use the new way, of calling UserMoveTest early to determine the legality of the
-// move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),
-// and at the end FinishMove() to perform the move after optional promotion popups.
-// For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.
void
-HandleUserMove (Widget w, XEvent *event, String *prms, Cardinal *nprms)
-{
- if (w != boardWidget || errorExitStatus != -1) return;
- if(nprms) shiftKey = !strcmp(prms[0], "1");
-
- if (promotionUp) {
- if (event->type == ButtonPress) {
- XtPopdown(promotionShell);
- XtDestroyWidget(promotionShell);
- promotionUp = False;
- ClearHighlights();
- fromX = fromY = -1;
- } else {
- return;
- }
+DoDrawGrid(cairo_surface_t *cs)
+{
+ /* draws a grid starting around Nx, Ny squares starting at x,y */
+ int i;
+ cairo_t *cr;
+
+ DrawSeekOpen();
+ /* get a cairo_t */
+ cr = cairo_create (cs);
+
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ SetPen(cr, lineGap, "#000000", 0);
+
+ /* lines in X */
+ for (i = 0; i < BOARD_WIDTH + BOARD_HEIGHT + 2; i++)
+ {
+ cairo_move_to (cr, gridSegments[i].x1, gridSegments[i].y1);
+ cairo_line_to (cr, gridSegments[i].x2, gridSegments[i].y2);
+ cairo_stroke (cr);
}
- // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
- if(event->type == ButtonPress) LeftClick(Press, event->xbutton.x, event->xbutton.y);
- if(event->type == ButtonRelease) LeftClick(Release, event->xbutton.x, event->xbutton.y);
+ /* free memory */
+ cairo_destroy (cr);
+
+ return;
}
void
-AnimateUserMove (Widget w, XEvent *event, String *params, Cardinal *nParams)
+DrawGrid()
{
- if(!PromoScroll(event->xmotion.x, event->xmotion.y))
- DragPieceMove(event->xmotion.x, event->xmotion.y);
+ DoDrawGrid(csBoardWindow);
+ DoDrawGrid(csBoardBackup);
}
+/*
+ * event handler for redrawing the board
+ */
+void
+DrawPositionProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ DrawPosition(True, NULL);
+}
+
+
void
HandlePV (Widget w, XEvent * event, String * params, Cardinal * nParams)
{ // [HGM] pv: walk PV
PopDown(CommentDlg);
}
-static char *openName;
-FILE *openFP;
-
-void
-DelayedLoad ()
-{
- (void) (*fileProc)(openFP, 0, openName);
-}
-
-void
-FileNamePopUp (char *label, char *def, char *filter, FileProc proc, char *openMode)
-{
- fileProc = proc; /* I can't see a way not */
- fileOpenMode = openMode; /* to use globals here */
- { // [HGM] use file-selector dialog stolen from Ghostview
- int index; // this is not supported yet
- if(openFP = XsraSelFile(shellWidget, label, NULL, NULL, _("could not open: "),
- (def[0] ? def : NULL), filter, openMode, NULL, &openName))
- // [HGM] delay to give expose event opportunity to redraw board after browser-dialog popdown before lengthy load starts
- ScheduleDelayedEvent(&DelayedLoad, 50);
- }
-}
-
-void
-PromotionPopUp ()
-{
- Arg args[16];
- Widget dialog, layout;
- Position x, y;
- Dimension bw_width, pw_width;
- int j;
- char *PromoChars = "wglcqrbnkac+=\0";
-
- j = 0;
- XtSetArg(args[j], XtNwidth, &bw_width); j++;
- XtGetValues(boardWidget, args, j);
-
- j = 0;
- XtSetArg(args[j], XtNresizable, True); j++;
- XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
- promotionShell =
- XtCreatePopupShell("Promotion", transientShellWidgetClass,
- shellWidget, args, j);
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
- layoutArgs, XtNumber(layoutArgs));
-
- j = 0;
- XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
- layout, args, j);
-
- if(gameInfo.variant != VariantShogi) {
- if(gameInfo.variant == VariantSpartan && !WhiteOnMove(currentMove)) {
- XawDialogAddButton(dialog, _("Warlord"), PromotionCallback, PromoChars + 0);
- XawDialogAddButton(dialog, _("General"), PromotionCallback, PromoChars + 1);
- XawDialogAddButton(dialog, _("Lieutenant"), PromotionCallback, PromoChars + 2);
- XawDialogAddButton(dialog, _("Captain"), PromotionCallback, PromoChars + 3);
- } else {
- XawDialogAddButton(dialog, _("Queen"), PromotionCallback, PromoChars + 4);
- XawDialogAddButton(dialog, _("Rook"), PromotionCallback, PromoChars + 5);
- XawDialogAddButton(dialog, _("Bishop"), PromotionCallback, PromoChars + 6);
- XawDialogAddButton(dialog, _("Knight"), PromotionCallback, PromoChars + 7);
- }
- if (!appData.testLegality || gameInfo.variant == VariantSuicide ||
- gameInfo.variant == VariantSpartan && !WhiteOnMove(currentMove) ||
- gameInfo.variant == VariantGiveaway) {
- XawDialogAddButton(dialog, _("King"), PromotionCallback, PromoChars + 8);
- }
- if(gameInfo.variant == VariantCapablanca ||
- gameInfo.variant == VariantGothic ||
- gameInfo.variant == VariantCapaRandom) {
- XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback, PromoChars + 9);
- XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback, PromoChars + 10);
- }
- } else // [HGM] shogi
- {
- XawDialogAddButton(dialog, _("Promote"), PromotionCallback, PromoChars + 11);
- XawDialogAddButton(dialog, _("Defer"), PromotionCallback, PromoChars + 12);
- }
- XawDialogAddButton(dialog, _("cancel"), PromotionCallback, PromoChars + 13);
-
- XtRealizeWidget(promotionShell);
- CatchDeleteWindow(promotionShell, "PromotionPopDown");
-
- j = 0;
- XtSetArg(args[j], XtNwidth, &pw_width); j++;
- XtGetValues(promotionShell, args, j);
-
- XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
- lineGap + squareSize/3 +
- ((toY == BOARD_HEIGHT-1) ^ (flipView) ?
- 0 : 6*(squareSize + lineGap)), &x, &y);
-
- j = 0;
- XtSetArg(args[j], XtNx, x); j++;
- XtSetArg(args[j], XtNy, y); j++;
- XtSetValues(promotionShell, args, j);
-
- XtPopup(promotionShell, XtGrabNone);
-
- promotionUp = True;
-}
-
-void
-PromotionPopDown ()
-{
- if (!promotionUp) return;
- XtPopdown(promotionShell);
- XtDestroyWidget(promotionShell);
- promotionUp = False;
-}
-
-void
-PromotionCallback (Widget w, XtPointer client_data, XtPointer call_data)
-{
- int promoChar = * (const char *) client_data;
-
- PromotionPopDown();
-
- if (fromX == -1) return;
-
- if (! promoChar) {
- fromX = fromY = -1;
- ClearHighlights();
- return;
- }
- UserMoveEvent(fromX, fromY, toX, toY, promoChar);
-
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
- fromX = fromY = -1;
-}
-
-
-void
-ErrorCallback (Widget w, XtPointer client_data, XtPointer call_data)
-{
- dialogError = errorUp = False;
- XtPopdown(w = XtParent(XtParent(XtParent(w))));
- XtDestroyWidget(w);
- if (errorExitStatus != -1) ExitEvent(errorExitStatus);
-}
-
-
-void
-ErrorPopDown ()
-{
- if (!errorUp) return;
- dialogError = errorUp = False;
- XtPopdown(errorShell);
- XtDestroyWidget(errorShell);
- if (errorExitStatus != -1) ExitEvent(errorExitStatus);
-}
-
-void
-ErrorPopUp (char *title, char *label, int modal)
-{
- Arg args[16];
- Widget dialog, layout;
- Position x, y;
- int xx, yy;
- Window junk;
- Dimension bw_width, pw_width;
- Dimension pw_height;
- int i;
-
- i = 0;
- XtSetArg(args[i], XtNresizable, True); i++;
- XtSetArg(args[i], XtNtitle, title); i++;
- errorShell =
- XtCreatePopupShell("errorpopup", transientShellWidgetClass,
- shellUp[TransientDlg] ? (dialogError = modal = TRUE, shells[TransientDlg]) : shellWidget, args, i);
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
- layoutArgs, XtNumber(layoutArgs));
-
- i = 0;
- XtSetArg(args[i], XtNlabel, label); i++;
- XtSetArg(args[i], XtNborderWidth, 0); i++;
- dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
- layout, args, i);
-
- XawDialogAddButton(dialog, _("ok"), ErrorCallback, (XtPointer) dialog);
-
- XtRealizeWidget(errorShell);
- CatchDeleteWindow(errorShell, "ErrorPopDown");
-
- i = 0;
- XtSetArg(args[i], XtNwidth, &bw_width); i++;
- XtGetValues(boardWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNwidth, &pw_width); i++;
- XtSetArg(args[i], XtNheight, &pw_height); i++;
- XtGetValues(errorShell, args, i);
-
-#ifdef NOTDEF
- /* This code seems to tickle an X bug if it is executed too soon
- after xboard starts up. The coordinates get transformed as if
- the main window was positioned at (0, 0).
- */
- XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
- 0 - pw_height + squareSize / 3, &x, &y);
-#else
- XTranslateCoordinates(xDisplay, XtWindow(boardWidget),
- RootWindowOfScreen(XtScreen(boardWidget)),
- (bw_width - pw_width) / 2,
- 0 - pw_height + squareSize / 3, &xx, &yy, &junk);
- x = xx;
- y = yy;
-#endif
- if (y < 0) y = 0; /*avoid positioning top offscreen*/
-
- i = 0;
- XtSetArg(args[i], XtNx, x); i++;
- XtSetArg(args[i], XtNy, y); i++;
- XtSetValues(errorShell, args, i);
-
- errorUp = True;
- XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);
-}
/* Disable all user input other than deleting the window */
static int frozen = 0;
{
if (frozen) return;
/* Grab by a widget that doesn't accept input */
- XtAddGrab(messageWidget, TRUE, FALSE);
+ XtAddGrab(optList[W_MESSG].handle, TRUE, FALSE);
frozen = 1;
}
ThawUI ()
{
if (!frozen) return;
- XtRemoveGrab(messageWidget);
+ XtRemoveGrab(optList[W_MESSG].handle);
frozen = 0;
}
if (pausing != oldPausing) {
oldPausing = pausing;
- MarkMenuItem("Pause", pausing);
+ MarkMenuItem("Mode.Pause", pausing);
if (appData.showButtonBar) {
/* Always toggle, don't set. Previous code messes up when
Pixel oldbg, oldfg;
XtSetArg(args[0], XtNbackground, &oldbg);
XtSetArg(args[1], XtNforeground, &oldfg);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),
+ XtGetValues(optList[W_PAUSE].handle,
args, 2);
XtSetArg(args[0], XtNbackground, oldfg);
XtSetArg(args[1], XtNforeground, oldbg);
}
- XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
+ XtSetValues(optList[W_PAUSE].handle, args, 2);
}
}
MarkMenuItem(wname, True);
}
oldmode = gameMode;
- MarkMenuItem("Machine Match", matchMode && matchGame < appData.matchGames);
+ MarkMenuItem("Mode.MachineMatch", matchMode && matchGame < appData.matchGames);
/* Maybe all the enables should be handled here, not just this one */
- EnableMenuItem("Training", gameMode == Training || gameMode == PlayFromGameFile);
+ EnableNamedMenuItem("Mode.Training", gameMode == Training || gameMode == PlayFromGameFile);
+
+ DisplayLogos(optList[W_WHITE-1].handle, optList[W_BLACK+1].handle);
}
/*
* Button/menu procedures
*/
-int
-LoadGamePopUp (FILE *f, int gameNumber, char *title)
-{
- cmailMsgLoaded = FALSE;
- if (gameNumber == 0) {
- int error = GameListBuild(f);
- if (error) {
- DisplayError(_("Cannot build game list"), error);
- } else if (!ListEmpty(&gameList) &&
- ((ListGame *) gameList.tailPred)->number > 1) {
- GameListPopUp(f, title);
- return TRUE;
- }
- GameListDestroy();
- gameNumber = 1;
- }
- return LoadGame(f, gameNumber, title, FALSE);
-}
/* this variable is shared between CopyPositionProc and SendPositionSelection */
char *selected_fen_position=NULL;
}
void
-DisplayMessage (char *message, char *extMessage)
-{
- /* display a message in the message widget */
-
- char buf[MSG_SIZ];
- Arg arg;
-
- if (extMessage)
- {
- if (*message)
- {
- snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
- message = buf;
- }
- else
- {
- message = extMessage;
- };
- };
-
- safeStrCpy(lastMsg, message, MSG_SIZ); // [HGM] make available
-
- /* need to test if messageWidget already exists, since this function
- can also be called during the startup, if for example a Xresource
- is not set up correctly */
- if(messageWidget)
- {
- XtSetArg(arg, XtNlabel, message);
- XtSetValues(messageWidget, &arg, 1);
- };
-
- return;
+ManProc ()
+{ // called from menu
+ ManInner(NULL, NULL, NULL, NULL);
}
void
}
void
-DisplayTimerLabel (Widget w, char *color, long timer, int highlight)
+DisplayTimerLabel (Option *opt, char *color, long timer, int highlight)
{
char buf[MSG_SIZ];
Arg args[16];
+ Widget w = (Widget) opt->handle;
/* check for low time warning */
Pixel foregroundOrWarningColor = timerForegroundPixel;
foregroundOrWarningColor = lowTimeWarningColor;
if (appData.clockMode) {
- snprintf(buf, MSG_SIZ, "%s: %s", color, TimeString(timer));
+ snprintf(buf, MSG_SIZ, "%s:%s%s", color, appData.logoSize && !partnerUp ? "\n" : " ", TimeString(timer));
XtSetArg(args[0], XtNlabel, buf);
} else {
snprintf(buf, MSG_SIZ, "%s ", color);
XtSetValues(w, args, 3);
}
-void
-DisplayWhiteClock (long timeRemaining, int highlight)
-{
- Arg args[16];
-
- if(appData.noGUI) return;
- DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
- if (highlight && iconPixmap == bIconPixmap) {
- iconPixmap = wIconPixmap;
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);
- XtSetValues(shellWidget, args, 1);
- }
-}
+static Pixmap *clockIcons[] = { &wIconPixmap, &bIconPixmap };
void
-DisplayBlackClock (long timeRemaining, int highlight)
+SetClockIcon (int color)
{
Arg args[16];
-
- if(appData.noGUI) return;
- DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
- if (highlight && iconPixmap == wIconPixmap) {
- iconPixmap = bIconPixmap;
+ Pixmap pm = *clockIcons[color];
+ if (iconPixmap != pm) {
+ iconPixmap = pm;
XtSetArg(args[0], XtNiconPixmap, iconPixmap);
XtSetValues(shellWidget, args, 1);
}
static int xpmDone = 0;
static Pixmap animBufs[3*NrOfAnims]; // newBuf, saveBuf
static GC animGCs[3*NrOfAnims]; // blitGC, pieceGC, outlineGC;
+static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
static void
CreateAnimMasks (int pieceDepth)
XtGCMask mask;
XGCValues values;
+ if(cairoAnimate) {
+ DrawSeekOpen(); // set cs to board widget
+ if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
+ if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
+ c_animBufs[anr+4] = csBoardWindow;
+ c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ }
+
/* Each buffer is square size, same depth as window */
animBufs[anr+4] = xBoardWindow;
animBufs[anr+2] = XCreatePixmap(xDisplay, xBoardWindow,
{
XWindowAttributes info;
- if (xpmDone && gameInfo.variant == oldVariant) return;
+ if (!cairoAnimate && xpmDone && gameInfo.variant == oldVariant) return;
if(xpmDone) oldVariant = gameInfo.variant; // first time pieces might not be created yet
XGetWindowAttributes(xDisplay, xBoardWindow, &info);
InitAnimState(Player, &info);
/* For XPM pieces, we need bitmaps to use as masks. */
- if (useImages)
+ if (useImages & !xpmDone)
CreateAnimMasks(info.depth), xpmDone = 1;
}
}
}
+static void
+CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
+{
+ static ChessSquare oldPiece = -1;
+ static int oldSize;
+ static cairo_t *pieceSource;
+ extern int doubleClick; // in backend.c
+ if(piece != oldPiece || squareSize != oldSize) { // try make it faster by only changing cr if we need other piece
+ if(pieceSource) cairo_destroy (pieceSource);
+ pieceSource = cairo_create (dest);
+ cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
+ oldPiece = piece; oldSize = squareSize;
+ }
+ if(doubleClick) cairo_paint_with_alpha (pieceSource, 0.6);
+ else cairo_paint(pieceSource);
+}
+
void
InsertPiece (AnimNr anr, ChessSquare piece)
{
+ if(cairoAnimate) {
+ CairoOverlayPiece(piece, c_animBufs[anr]);
+ } else
OverlayPiece(piece, animGCs[anr+2], animGCs[anr+4], animBufs[anr]);
}
void
DrawBlank (AnimNr anr, int x, int y, int startColor)
{
+ if(cairoAnimate)
+ BlankSquare(x, y, startColor, EmptySquare, (Drawable) c_animBufs[anr+2], 0);
+ else
BlankSquare(x, y, startColor, EmptySquare, animBufs[anr+2], 0);
}
void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
int srcX, int srcY, int width, int height, int destX, int destY)
{
+ if(cairoAnimate) {
+ cairo_t *cr;// = cairo_create (c_animBufs[anr+destBuf]);
+ cr = cairo_create (c_animBufs[anr+destBuf]);
+ if(c_animBufs[anr+srcBuf] == csBoardWindow)
+ cairo_set_source_surface (cr, csBoardBackup, destX - srcX, destY - srcY);
+ else
+ cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+ cairo_rectangle (cr, destX, destY, width, height);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ if(c_animBufs[anr+destBuf] == csBoardWindow) {
+ cr = cairo_create (csBoardBackup); // also draw to backup
+ cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+ cairo_rectangle (cr, destX, destY, width, height);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ }
+ } else
XCopyArea(xDisplay, animBufs[anr+srcBuf], animBufs[anr+destBuf], animGCs[anr],
srcX, srcY, width, height, destX, destY);
}
SetDragPiece (AnimNr anr, ChessSquare piece)
{
Pixmap mask;
+ if(cairoAnimate) return;
/* The piece will be drawn using its own bitmap as a matte */
SelectGCMask(piece, &animGCs[anr+2], &animGCs[anr+4], &mask);
XSetClipMask(xDisplay, animGCs[anr+2], mask);
/* [AS] Arrow highlighting support */
-void
-DrawPolygon (Pnt arrow[], int nr)
-{
- XPoint pts[10];
+void DrawPolygon(Pnt arrow[], int nr)
+{ // for now on own surface; eventually this should become a global that is only destroyed on resize
+ cairo_surface_t *boardSurface;
+ cairo_t *cr;
int i;
- for(i=0; i<10; i++) pts[i].x = arrow[i].x, pts[i].y = arrow[i].y;
- XFillPolygon(xDisplay, xBoardWindow, highlineGC, pts, nr, Nonconvex, CoordModeOrigin);
- if(appData.monoMode) arrow[nr] = arrow[0], XDrawLines(xDisplay, xBoardWindow, darkSquareGC, pts, nr+1, CoordModeOrigin);
+ int w = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ int h = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ boardSurface = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), w, h);
+ cr = cairo_create (boardSurface);
+ cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
+ for (i=0;i<nr;i++) {
+ cairo_line_to(cr, arrow[i].x, arrow[i].y);
+ }
+ if(appData.monoMode) { // should we always outline arrow?
+ cairo_line_to(cr, arrow[0].x, arrow[0].y);
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke_preserve(cr);
+ }
+ SetPen(cr, 2, appData.highlightSquareColor, 0);
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+ cairo_surface_destroy (boardSurface);
+}
+
+static void
+LoadLogo (ChessProgramState *cps, int n, Boolean ics)
+{
+ char buf[MSG_SIZ], *logoName = buf;
+ if(appData.logo[n][0]) {
+ logoName = appData.logo[n];
+ } else if(appData.autoLogo) {
+ if(ics) { // [HGM] logo: in ICS mode second can be used for ICS
+ sprintf(buf, "%s/%s.png", appData.logoDir, appData.icsHost);
+ } else if(appData.directory[n] && appData.directory[n][0]) {
+ sprintf(buf, "%s/%s.png", appData.logoDir, cps->tidy);
+ }
+ }
+ if(logoName[0])
+ { ASSIGN(cps->programLogo, logoName); }
}
void
UpdateLogos (int displ)
{
- return; // no logos in XBoard yet
+ if(optList[W_WHITE-1].handle == NULL) return;
+ LoadLogo(&first, 0, 0);
+ LoadLogo(&second, 1, appData.icsActive);
+ if(displ) DisplayLogos(optList[W_WHITE-1].handle, optList[W_BLACK+1].handle);
+ return;
}