* xboard.c -- X front end for XBoard
*
* Copyright 1991 by Digital Equipment Corporation, Maynard,
- * Massachusetts.
+ * Massachusetts.
*
* Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
* 2007, 2008, 2009 Free Software Foundation, Inc.
*------------------------------------------------------------------------
** See the file ChangeLog for a revision history. */
+#define HIGHDRAG 1
+
#include "config.h"
#include <stdio.h>
#include <X11/Shell.h>
#include <X11/cursorfont.h>
#include <X11/Xatom.h>
+#include <X11/Xmu/Atoms.h>
#if USE_XAW3D
#include <X11/Xaw3d/Dialog.h>
#include <X11/Xaw3d/Form.h>
#include "bitmaps/bitmaps.h"
#endif
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
#include "bitmaps/icon_white.bm"
#include "bitmaps/icon_black.bm"
#include "bitmaps/checkmark.bm"
#include "xhistory.h"
#include "xedittags.h"
#include "gettext.h"
+#include "callback.h"
+#include "interface.h"
// must be moved to xengineoutput.h
void EngineOutputProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-
-void EngineOutputPopDown();
+ String *prms, Cardinal *nprms));
+void EvalGraphProc P((Widget w, XEvent *event,
+ String *prms, Cardinal *nprms));
#ifdef __EMX__
MenuItem *mi;
} Menu;
+typedef struct {
+ char *name;
+ gboolean value;
+} Enables;
+
+
+
int main P((int argc, char **argv));
RETSIGTYPE CmailSigHandler P((int sig));
RETSIGTYPE IntSigHandler P((int sig));
void CreatePieces P((void));
void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb));
-Widget CreateButtonBar P ((MenuItem *mi));
char *FindFont P((char *pattern, int targetPxlSize));
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));
int EventToSquare P((int x, int limit));
void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
-void EventProc 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 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 XDrawPosition P((Widget w, /*Boolean*/int repaint,
- Board board));
+void HandlePV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
void CommentPopUp P((char *title, char *label));
void CommentPopDown P((void));
void CommentCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void ICSInputBoxPopUp P((void));
void ICSInputBoxPopDown P((void));
-void FileNamePopUp P((char *label, char *def,
- FileProc proc, char *openMode));
-void FileNamePopDown P((void));
-void FileNameCallback P((Widget w, XtPointer client_data,
- XtPointer call_data));
-void FileNameAction P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void AskQuestionReplyAction P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void AskQuestionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void AskQuestionPopDown P((void));
-void PromotionPopUp P((void));
void PromotionPopDown P((void));
void PromotionCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void EditCommentCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
-void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ReloadGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void CopyPositionProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void PastePositionProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void SavePositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
-void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void MachineBlackProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MachineWhiteProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void AnalyzeModeProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void AnalyzeFileProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void IcsClientProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void EditPositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EditCommentProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void IcsInputBoxProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
-void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AdjuWhiteProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void StopObservingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void StopExaminingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void TruncateGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void RetractMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutocommProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutobsProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void FlashMovesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void GetMoveListProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void HideThinkingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void TestLegalityProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SaveSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SaveOnExitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ErrorPopDown P((void));
static char *ExpandPathName P((char *path));
static void CreateAnimVars P((void));
-static void DragPieceBegin P((int x, int y));
static void DragPieceMove P((int x, int y));
-static void DragPieceEnd P((int x, int y));
static void DrawDragPiece P((void));
char *ModeToWidgetName P((GameMode mode));
-void EngineOutputUpdate( FrontEndProgramStats * stats );
void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void TimeControlPopDown P(());
void NewVariantPopDown P(());
void SettingsPopDown P(());
+void SetMenuEnables P((Enables *enab));
void update_ics_width P(());
int get_term_width P(());
+int CopyMemoProc P(());
/*
* XBoard depends on Xt R4 or higher
*/
int xtVersion = XtSpecificationRelease;
int xScreen;
-Display *xDisplay;
+
Window xBoardWindow;
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
jailSquareColor, highlightSquareColor, premoveHighlightColor;
Pixel lowTimeWarningColor;
-GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
- bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
- wjPieceGC, bjPieceGC, prelineGC, countGC;
+
+#define LINE_TYPE_NORMAL 0
+#define LINE_TYPE_HIGHLIGHT 1
+#define LINE_TYPE_PRE 2
+
+
+GC lightSquareGC, darkSquareGC, jailSquareGC, wdPieceGC, wlPieceGC,
+ bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC,
+ wjPieceGC, bjPieceGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
+Widget layoutWidget, formWidget, boardWidget, messageWidget,
whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
- menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
+ menuBarWidget, editShell, errorShell, analysisShell,
ICSInputShell, fileNameShell, askQuestionShell;
-XSegment gridSegments[(BOARD_SIZE + 1) * 2];
-XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
+
+Widget historyShell, evalGraphShell, gameListShell;
+//XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+//XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
+
Font clockFontID, coordFontID, countFontID;
XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
Position commentX = -1, commentY = -1;
Dimension commentW, commentH;
+typedef unsigned int BoardSize;
+BoardSize boardSize;
+Boolean chessProgram;
+int minX, minY; // [HGM] placement: volatile limits on upper-left corner
int squareSize, smallLayout = 0, tinyLayout = 0,
marginW, marginH, // [HGM] for run-time resizing
fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
Pixel buttonForegroundPixel, buttonBackgroundPixel;
char *chessDir, *programName, *programVersion,
*gameCopyFilename, *gamePasteFilename;
+Boolean alwaysOnTop = False;
+Boolean saveSettingsOnExit;
+char *settingsFileName;
+char *icsTextMenuString;
+char *icsNames;
+char *firstChessProgramNames;
+char *secondChessProgramNames;
+
+WindowPlacement wpMain;
+WindowPlacement wpConsole;
+WindowPlacement wpComment;
+WindowPlacement wpMoveHistory;
+WindowPlacement wpEvalGraph;
+WindowPlacement wpEngineOutput;
+WindowPlacement wpGameList;
+WindowPlacement wpTags;
#define SOLID 0
#define OUTLINE 1
Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
-int useImages, useImageSqs;
+int useImages=0, useImageSqs;
XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
+Enables icsEnables[] = {
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Analysis Mode", False },
+ { "menuMode.Analyze File", False },
+ { "menuMode.Two Machines", False },
+#ifndef ZIPPY
+ { "menuHelp.Hint", False },
+ { "menuHelp.Book", False },
+ { "menuStep.Move Now", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Ponder Next Move", False },
+#endif
+ { NULL, False }
+};
+
+Enables ncpEnables[] = {
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Analysis Mode", False },
+ { "menuMode.Analyze File", False },
+ { "menuMode.Two Machines", False },
+ { "menuMode.ICS Client", False },
+ { "menuMode.ICS Input Box", False },
+ { "Action", False },
+ { "menuStep.Revert", False },
+ { "menuStep.Move Now", False },
+ { "menuStep.Retract Move", False },
+ { "menuOptions.Auto Comment", False },
+ { "menuOptions.Auto Flag", False },
+ { "menuOptions.Auto Flip View", False },
+ { "menuOptions.Auto Observe", False },
+ { "menuOptions.Auto Raise Board", False },
+ { "menuOptions.Get Move List", False },
+ { "menuOptions.ICS Alarm", False },
+ { "menuOptions.Move Sound", False },
+ { "menuOptions.Quiet Play", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Ponder Next Move", False },
+ { "menuHelp.Hint", False },
+ { "menuHelp.Book", False },
+ { NULL, False }
+};
+
+Enables gnuEnables[] = {
+ { "menuMode.ICS Client", False },
+ { "menuMode.ICS Input Box", False },
+ { "menuAction.Accept", False },
+ { "menuAction.Decline", False },
+ { "menuAction.Rematch", False },
+ { "menuAction.Adjourn", False },
+ { "menuAction.Stop Examining", False },
+ { "menuAction.Stop Observing", False },
+ { "menuStep.Revert", False },
+ { "menuOptions.Auto Comment", False },
+ { "menuOptions.Auto Observe", False },
+ { "menuOptions.Auto Raise Board", False },
+ { "menuOptions.Get Move List", False },
+ { "menuOptions.Premove", False },
+ { "menuOptions.Quiet Play", False },
+
+ /* The next two options rely on SetCmailMode being called *after* */
+ /* SetGNUMode so that when GNU is being used to give hints these */
+ /* menu options are still available */
+
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { NULL, False }
+};
+
+Enables cmailEnables[] = {
+ { "Action", True },
+ { "menuAction.Call Flag", False },
+ { "menuAction.Draw", True },
+ { "menuAction.Adjourn", False },
+ { "menuAction.Abort", False },
+ { "menuAction.Stop Observing", False },
+ { "menuAction.Stop Examining", False },
+ { "menuFile.Mail Move", True },
+ { "menuFile.Reload CMail Message", True },
+ { NULL, False }
+};
+
+Enables trainingOnEnables[] = {
+ { "menuMode.Edit Comment", False },
+ { "menuMode.Pause", False },
+ { "menuStep.Forward", False },
+ { "menuStep.Backward", False },
+ { "menuStep.Forward to End", False },
+ { "menuStep.Back to Start", False },
+ { "menuStep.Move Now", False },
+ { "menuStep.Truncate Game", False },
+ { NULL, False }
+};
+
+Enables trainingOffEnables[] = {
+ { "menuMode.Edit Comment", True },
+ { "menuMode.Pause", True },
+ { "menuStep.Forward", True },
+ { "menuStep.Backward", True },
+ { "menuStep.Forward to End", True },
+ { "menuStep.Back to Start", True },
+ { "menuStep.Move Now", True },
+ { "menuStep.Truncate Game", True },
+ { NULL, False }
+};
+
+Enables machineThinkingEnables[] = {
+ { "menuFile.Load Game", False },
+ { "menuFile.Load Next Game", False },
+ { "menuFile.Load Previous Game", False },
+ { "menuFile.Reload Same Game", False },
+ { "menuFile.Paste Game", False },
+ { "menuFile.Load Position", False },
+ { "menuFile.Load Next Position", False },
+ { "menuFile.Load Previous Position", False },
+ { "menuFile.Reload Same Position", False },
+ { "menuFile.Paste Position", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Two Machines", False },
+ { "menuStep.Retract Move", False },
+ { NULL, False }
+};
+
+Enables userThinkingEnables[] = {
+ { "menuFile.Load Game", True },
+ { "menuFile.Load Next Game", True },
+ { "menuFile.Load Previous Game", True },
+ { "menuFile.Reload Same Game", True },
+ { "menuFile.Paste Game", True },
+ { "menuFile.Load Position", True },
+ { "menuFile.Load Next Position", True },
+ { "menuFile.Load Previous Position", True },
+ { "menuFile.Reload Same Position", True },
+ { "menuFile.Paste Position", True },
+ { "menuMode.Machine White", True },
+ { "menuMode.Machine Black", True },
+ { "menuMode.Two Machines", True },
+ { "menuStep.Retract Move", True },
+ { NULL, False }
+};
+
+
+
MenuItem fileMenu[] = {
- {N_("New Game"), ResetProc},
{N_("New Shuffle Game ..."), ShuffleMenuProc},
{N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
- {"----", NothingProc},
- {N_("Load Game"), LoadGameProc},
- {N_("Load Next Game"), LoadNextGameProc},
- {N_("Load Previous Game"), LoadPrevGameProc},
- {N_("Reload Same Game"), ReloadGameProc},
- {N_("Save Game"), SaveGameProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
+ // {N_("Save Game"), SaveGameProc},
+ // {"----", NothingProc},
{N_("Copy Game"), CopyGameProc},
{N_("Paste Game"), PasteGameProc},
- {"----", NothingProc},
- {N_("Load Position"), LoadPositionProc},
- {N_("Load Next Position"), LoadNextPositionProc},
- {N_("Load Previous Position"), LoadPrevPositionProc},
- {N_("Reload Same Position"), ReloadPositionProc},
- {N_("Save Position"), SavePositionProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
+ // {N_("Load Position"), LoadPositionProc},
+ // {N_("Load Next Position"), LoadNextPositionProc},
+ // {N_("Load Previous Position"), LoadPrevPositionProc},
+ // {N_("Reload Same Position"), ReloadPositionProc},
+ // {N_("Save Position"), SavePositionProc},
+ // {"----", NothingProc},
{N_("Copy Position"), CopyPositionProc},
{N_("Paste Position"), PastePositionProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
{N_("Mail Move"), MailMoveProc},
{N_("Reload CMail Message"), ReloadCmailMsgProc},
- {"----", NothingProc},
- {N_("Exit"), QuitProc},
+ // {"----", NothingProc},
{NULL, NULL}
};
MenuItem modeMenu[] = {
- {N_("Machine White"), MachineWhiteProc},
- {N_("Machine Black"), MachineBlackProc},
- {N_("Two Machines"), TwoMachinesProc},
- {N_("Analysis Mode"), AnalyzeModeProc},
- {N_("Analyze File"), AnalyzeFileProc },
- {N_("ICS Client"), IcsClientProc},
- {N_("Edit Game"), EditGameProc},
- {N_("Edit Position"), EditPositionProc},
- {N_("Training"), TrainingProc},
- {"----", NothingProc},
+ // {N_("Machine White"), MachineWhiteProc},
+ // {N_("Machine Black"), MachineBlackProc},
+ // {N_("Two Machines"), TwoMachinesProc},
+ // {N_("Analysis Mode"), AnalyzeModeProc},
+ // {N_("Analyze File"), AnalyzeFileProc },
+ // {N_("ICS Client"), IcsClientProc},
+ // {N_("Edit Game"), EditGameProc},
+ // {N_("Edit Position"), EditPositionProc},
+ // {N_("Training"), TrainingProc},
+ // {"----", NothingProc},
{N_("Show Engine Output"), EngineOutputProc},
- {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
+ {N_("Show Evaluation Graph"), EvalGraphProc},
{N_("Show Game List"), ShowGameListProc},
- {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
- {"----", NothingProc},
- {N_("Edit Tags"), EditTagsProc},
+ // {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
+ // {"----", NothingProc},
+ // {N_("Edit Tags"), EditTagsProc},
{N_("Edit Comment"), EditCommentProc},
{N_("ICS Input Box"), IcsInputBoxProc},
- {N_("Pause"), PauseProc},
- {NULL, NULL}
-};
-
-MenuItem actionMenu[] = {
- {N_("Accept"), AcceptProc},
- {N_("Decline"), DeclineProc},
- {N_("Rematch"), RematchProc},
- {"----", NothingProc},
- {N_("Call Flag"), CallFlagProc},
- {N_("Draw"), DrawProc},
- {N_("Adjourn"), AdjournProc},
- {N_("Abort"), AbortProc},
- {N_("Resign"), ResignProc},
- {"----", NothingProc},
- {N_("Stop Observing"), StopObservingProc},
- {N_("Stop Examining"), StopExaminingProc},
- {"----", NothingProc},
- {N_("Adjudicate to White"), AdjuWhiteProc},
- {N_("Adjudicate to Black"), AdjuBlackProc},
- {N_("Adjudicate Draw"), AdjuDrawProc},
- {NULL, NULL}
-};
-
-MenuItem stepMenu[] = {
- {N_("Backward"), BackwardProc},
- {N_("Forward"), ForwardProc},
- {N_("Back to Start"), ToStartProc},
- {N_("Forward to End"), ToEndProc},
- {N_("Revert"), RevertProc},
- {N_("Truncate Game"), TruncateGameProc},
- {"----", NothingProc},
- {N_("Move Now"), MoveNowProc},
- {N_("Retract Move"), RetractMoveProc},
{NULL, NULL}
};
MenuItem optionsMenu[] = {
- {N_("Flip View"), FlipViewProc},
- {"----", NothingProc},
+ // {N_("Flip View"), FlipViewProc},
+ // {"----", NothingProc},
{N_("Adjudications ..."), EngineMenuProc},
{N_("General Settings ..."), UciMenuProc},
{N_("Engine #1 Settings ..."), FirstSettingsProc},
{N_("Engine #2 Settings ..."), SecondSettingsProc},
{N_("Time Control ..."), TimeControlProc},
{"----", NothingProc},
- {N_("Always Queen"), AlwaysQueenProc},
- {N_("Animate Dragging"), AnimateDraggingProc},
- {N_("Animate Moving"), AnimateMovingProc},
- {N_("Auto Comment"), AutocommProc},
- {N_("Auto Flag"), AutoflagProc},
- {N_("Auto Flip View"), AutoflipProc},
- {N_("Auto Observe"), AutobsProc},
- {N_("Auto Raise Board"), AutoraiseProc},
- {N_("Auto Save"), AutosaveProc},
- {N_("Blindfold"), BlindfoldProc},
- {N_("Flash Moves"), FlashMovesProc},
- {N_("Get Move List"), GetMoveListProc},
-#if HIGHDRAG
- {N_("Highlight Dragging"), HighlightDraggingProc},
-#endif
- {N_("Highlight Last Move"), HighlightLastMoveProc},
- {N_("Move Sound"), MoveSoundProc},
- {N_("ICS Alarm"), IcsAlarmProc},
- {N_("Old Save Style"), OldSaveStyleProc},
- {N_("Periodic Updates"), PeriodicUpdatesProc},
- {N_("Ponder Next Move"), PonderNextMoveProc},
- {N_("Popup Exit Message"), PopupExitMessageProc},
- {N_("Popup Move Errors"), PopupMoveErrorsProc},
- {N_("Premove"), PremoveProc},
- {N_("Quiet Play"), QuietPlayProc},
- {N_("Show Coords"), ShowCoordsProc},
- {N_("Hide Thinking"), HideThinkingProc},
- {N_("Test Legality"), TestLegalityProc},
- {NULL, NULL}
-};
-
-MenuItem helpMenu[] = {
- {N_("Info XBoard"), InfoProc},
- {N_("Man XBoard"), ManProc},
+ // {N_("Always Queen"), AlwaysQueenProc},
+ // {N_("Animate Dragging"), AnimateDraggingProc},
+ // {N_("Animate Moving"), AnimateMovingProc},
+ // {N_("Auto Comment"), AutocommProc},
+ // {N_("Auto Flag"), AutoflagProc},
+ // {N_("Auto Flip View"), AutoflipProc},
+ // {N_("Auto Observe"), AutobsProc},
+ // {N_("Auto Raise Board"), AutoraiseProc},
+ // {N_("Auto Save"), AutosaveProc},
+ // {N_("Blindfold"), BlindfoldProc},
+ // {N_("Flash Moves"), FlashMovesProc},
+ // {N_("Get Move List"), GetMoveListProc},
+ //#if HIGHDRAG
+ // {N_("Highlight Dragging"), HighlightDraggingProc},
+ //#endif
+ // {N_("Highlight Last Move"), HighlightLastMoveProc},
+ // {N_("Move Sound"), MoveSoundProc},
+ // {N_("ICS Alarm"), IcsAlarmProc},
+ // {N_("Old Save Style"), OldSaveStyleProc},
+ // {N_("Periodic Updates"), PeriodicUpdatesProc},
+ // {N_("Ponder Next Move"), PonderNextMoveProc},
+ // {N_("Popup Exit Message"), PopupExitMessageProc},
+ // {N_("Popup Move Errors"), PopupMoveErrorsProc},
+ // {N_("Premove"), PremoveProc},
+ // {N_("Quiet Play"), QuietPlayProc},
+ // {N_("Hide Thinking"), HideThinkingProc},
+ // {N_("Test Legality"), TestLegalityProc},
+ // {N_("Show Coords"), ShowCoordsProc},
{"----", NothingProc},
- {N_("Hint"), HintProc},
- {N_("Book"), BookProc},
- {"----", NothingProc},
- {N_("About XBoard"), AboutProc},
+ {N_("Save Settings Now"), SaveSettingsProc},
+ {N_("Save Settings on Exit"), SaveOnExitProc},
{NULL, NULL}
};
Menu menuBar[] = {
{N_("File"), fileMenu},
{N_("Mode"), modeMenu},
- {N_("Action"), actionMenu},
- {N_("Step"), stepMenu},
{N_("Options"), optionsMenu},
- {N_("Help"), helpMenu},
- {NULL, NULL}
-};
-
-#define PAUSE_BUTTON N_("P")
-MenuItem buttonBar[] = {
- {"<<", ToStartProc},
- {"<", BackwardProc},
- {PAUSE_BUTTON, PauseProc},
- {">", ForwardProc},
- {">>", ToEndProc},
{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_("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_("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,
+ 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,
+ BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
PromotePiece, DemotePiece, EmptySquare, ClearBoard },
};
{ 'Q', "Queen" }
};
-Arg shellArgs[] = {
- { XtNwidth, 0 },
- { XtNheight, 0 },
- { XtNminWidth, 0 },
- { XtNminHeight, 0 },
- { XtNmaxWidth, 0 },
- { XtNmaxHeight, 0 }
-};
-
Arg layoutArgs[] = {
{ XtNborderWidth, 0 },
{ XtNdefaultDistance, 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[] = {
- { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, whitePieceColor), XtRString,
- WHITE_PIECE_COLOR },
- { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, blackPieceColor), XtRString,
- BLACK_PIECE_COLOR },
- { "lightSquareColor", "lightSquareColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
- XtRString, LIGHT_SQUARE_COLOR },
- { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, darkSquareColor), XtRString,
- DARK_SQUARE_COLOR },
- { "highlightSquareColor", "highlightSquareColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
- XtRString, HIGHLIGHT_SQUARE_COLOR },
- { "premoveHighlightColor", "premoveHighlightColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
- XtRString, PREMOVE_HIGHLIGHT_COLOR },
- { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
- (XtPointer) MOVES_PER_SESSION },
- { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
- (XtPointer) TIME_INCREMENT },
- { "initString", "initString", XtRString, sizeof(String),
- XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
- { "secondInitString", "secondInitString", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
- { "firstComputerString", "firstComputerString", XtRString,
- sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
- COMPUTER_STRING },
- { "secondComputerString", "secondComputerString", XtRString,
- sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
- COMPUTER_STRING },
- { "firstChessProgram", "firstChessProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
- XtRString, FIRST_CHESS_PROGRAM },
- { "secondChessProgram", "secondChessProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
- XtRString, SECOND_CHESS_PROGRAM },
- { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
- XtRImmediate, (XtPointer) False },
- { "noChessProgram", "noChessProgram", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
- XtRImmediate, (XtPointer) False },
- { "firstHost", "firstHost", XtRString, sizeof(String),
- XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
- { "secondHost", "secondHost", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
- { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
- { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
- { "bitmapDirectory", "bitmapDirectory", XtRString,
- sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
- XtRString, "" },
- { "remoteShell", "remoteShell", XtRString, sizeof(String),
- XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
- { "remoteUser", "remoteUser", XtRString, sizeof(String),
- XtOffset(AppDataPtr, remoteUser), XtRString, "" },
- { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
- XtOffset(AppDataPtr, timeDelay), XtRString,
- (XtPointer) TIME_DELAY_QUOTE },
- { "timeControl", "timeControl", XtRString, sizeof(String),
- XtOffset(AppDataPtr, timeControl), XtRString,
- (XtPointer) TIME_CONTROL },
- { "internetChessServerMode", "internetChessServerMode",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsActive), XtRImmediate,
- (XtPointer) False },
- { "internetChessServerHost", "internetChessServerHost",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsHost),
- XtRString, (XtPointer) ICS_HOST },
- { "internetChessServerPort", "internetChessServerPort",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsPort), XtRString,
- (XtPointer) ICS_PORT },
- { "internetChessServerCommPort", "internetChessServerCommPort",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsCommPort), XtRString,
- ICS_COMM_PORT },
- { "internetChessServerLogonScript", "internetChessServerLogonScript",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsLogon), XtRString,
- ICS_LOGON },
- { "internetChessServerHelper", "internetChessServerHelper",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsHelper), XtRString, "" },
- { "internetChessServerInputBox", "internetChessServerInputBox",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
- (XtPointer) False },
- { "icsAlarm", "icsAlarm",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
- (XtPointer) True },
- { "icsAlarmTime", "icsAlarmTime",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
- (XtPointer) 5000 },
- { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, useTelnet), XtRImmediate,
- (XtPointer) False },
- { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
- XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
- { "gateway", "gateway", XtRString, sizeof(String),
- XtOffset(AppDataPtr, gateway), XtRString, "" },
- { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
- XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
- { "loadGameIndex", "loadGameIndex",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
- (XtPointer) 0 },
- { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
- XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
- { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
- XtRImmediate, (XtPointer) True },
- { "autoSaveGames", "autoSaveGames", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
- XtRImmediate, (XtPointer) False },
- { "blindfold", "blindfold", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
- XtRImmediate, (XtPointer) False },
- { "loadPositionFile", "loadPositionFile", XtRString,
- sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
- XtRString, "" },
- { "loadPositionIndex", "loadPositionIndex",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
- (XtPointer) 1 },
- { "savePositionFile", "savePositionFile", XtRString,
- sizeof(String), XtOffset(AppDataPtr, savePositionFile),
- XtRString, "" },
- { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
- { "matchGames", "matchGames", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, matchGames), XtRImmediate,
- (XtPointer) 0 },
- { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, monoMode), XtRImmediate,
- (XtPointer) False },
- { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, debugMode), XtRImmediate,
- (XtPointer) False },
- { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, clockMode), XtRImmediate,
- (XtPointer) True },
- { "boardSize", "boardSize", XtRString, sizeof(String),
- XtOffset(AppDataPtr, boardSize), XtRString, "" },
- { "searchTime", "searchTime", XtRString, sizeof(String),
- XtOffset(AppDataPtr, searchTime), XtRString,
- (XtPointer) "" },
- { "searchDepth", "searchDepth", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, searchDepth), XtRImmediate,
- (XtPointer) 0 },
- { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, showCoords), XtRImmediate,
- (XtPointer) False },
- { "showJail", "showJail", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, showJail), XtRImmediate,
- (XtPointer) 0 },
- { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, showThinking), XtRImmediate,
- (XtPointer) True },
- { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
- (XtPointer) True },
- { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
- (XtPointer) True },
- { "clockFont", "clockFont", XtRString, sizeof(String),
- XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
- { "coordFont", "coordFont", XtRString, sizeof(String),
- XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
- { "font", "font", XtRString, sizeof(String),
- XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
- { "ringBellAfterMoves", "ringBellAfterMoves",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, ringBellAfterMoves),
- XtRImmediate, (XtPointer) False },
- { "autoCallFlag", "autoCallFlag", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
- XtRImmediate, (XtPointer) False },
- { "autoFlipView", "autoFlipView", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
- XtRImmediate, (XtPointer) True },
- { "autoObserve", "autoObserve", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
- XtRImmediate, (XtPointer) False },
- { "autoComment", "autoComment", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
- XtRImmediate, (XtPointer) False },
- { "getMoveList", "getMoveList", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
- XtRImmediate, (XtPointer) True },
-#if HIGHDRAG
- { "highlightDragging", "highlightDragging", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
- XtRImmediate, (XtPointer) False },
-#endif
- { "highlightLastMove", "highlightLastMove", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
- XtRImmediate, (XtPointer) False },
- { "premove", "premove", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, premove),
- XtRImmediate, (XtPointer) True },
- { "testLegality", "testLegality", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
- XtRImmediate, (XtPointer) True },
- { "flipView", "flipView", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, flipView),
- XtRImmediate, (XtPointer) False },
- { "cmail", "cmailGameName", XtRString, sizeof(String),
- XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
- { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
- XtRImmediate, (XtPointer) False },
- { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
- XtRImmediate, (XtPointer) False },
- { "quietPlay", "quietPlay", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
- XtRImmediate, (XtPointer) False },
- { "titleInWindow", "titleInWindow", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
- XtRImmediate, (XtPointer) False },
- { "localLineEditing", "localLineEditing", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
- XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
-#if ZIPPY
- { "zippyTalk", "zippyTalk", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
- XtRImmediate, (XtPointer) ZIPPY_TALK },
- { "zippyPlay", "zippyPlay", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
- XtRImmediate, (XtPointer) ZIPPY_PLAY },
- { "zippyLines", "zippyLines", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
- { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
- { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
- { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
- { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
- ZIPPY_WRONG_PASSWORD },
- { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
- { "zippyUseI", "zippyUseI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
- XtRImmediate, (XtPointer) ZIPPY_USE_I },
- { "zippyBughouse", "zippyBughouse", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
- XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
- { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
- XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
- { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
- { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
- { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
- XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
- { "zippyAbort", "zippyAbort", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
- XtRImmediate, (XtPointer) ZIPPY_ABORT },
- { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
- { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
- (XtPointer) ZIPPY_MAX_GAMES },
- { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
- (XtPointer) ZIPPY_REPLAY_TIMEOUT },
- { "zippyShortGame", "zippyShortGame", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, zippyShortGame), XtRImmediate,
- (XtPointer) 0 },
-#endif
{ "flashCount", "flashCount", XtRInt, sizeof(int),
XtOffset(AppDataPtr, flashCount), XtRImmediate,
(XtPointer) FLASH_COUNT },
- { "flashRate", "flashRate", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, flashRate), XtRImmediate,
- (XtPointer) FLASH_RATE },
- { "pixmapDirectory", "pixmapDirectory", XtRString,
- sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
- XtRString, "" },
- { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
- (XtPointer) MS_LOGIN_DELAY },
- { "colorizeMessages", "colorizeMessages", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, colorize),
- XtRImmediate, (XtPointer) False },
- { "colorShout", "colorShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorShout),
- XtRString, COLOR_SHOUT },
- { "colorSShout", "colorSShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorSShout),
- XtRString, COLOR_SSHOUT },
- { "colorChannel1", "colorChannel1", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChannel1),
- XtRString, COLOR_CHANNEL1 },
- { "colorChannel", "colorChannel", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChannel),
- XtRString, COLOR_CHANNEL },
- { "colorKibitz", "colorKibitz", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorKibitz),
- XtRString, COLOR_KIBITZ },
- { "colorTell", "colorTell", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorTell),
- XtRString, COLOR_TELL },
- { "colorChallenge", "colorChallenge", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChallenge),
- XtRString, COLOR_CHALLENGE },
- { "colorRequest", "colorRequest", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorRequest),
- XtRString, COLOR_REQUEST },
- { "colorSeek", "colorSeek", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorSeek),
- XtRString, COLOR_SEEK },
- { "colorNormal", "colorNormal", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorNormal),
- XtRString, COLOR_NORMAL },
- { "soundProgram", "soundProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundProgram),
- XtRString, "play" },
- { "soundShout", "soundShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundShout),
- XtRString, "" },
- { "soundSShout", "soundSShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundSShout),
- XtRString, "" },
- { "soundChannel1", "soundChannel1", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChannel1),
- XtRString, "" },
- { "soundChannel", "soundChannel", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChannel),
- XtRString, "" },
- { "soundKibitz", "soundKibitz", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundKibitz),
- XtRString, "" },
- { "soundTell", "soundTell", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundTell),
- XtRString, "" },
- { "soundChallenge", "soundChallenge", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChallenge),
- XtRString, "" },
- { "soundRequest", "soundRequest", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundRequest),
- XtRString, "" },
- { "soundSeek", "soundSeek", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundSeek),
- XtRString, "" },
- { "soundMove", "soundMove", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundMove),
- XtRString, "$" },
- { "soundIcsWin", "soundIcsWin", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
- XtRString, "" },
- { "soundIcsLoss", "soundIcsLoss", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
- XtRString, "" },
- { "soundIcsDraw", "soundIcsDraw", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
- XtRString, "" },
- { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
- XtRString, "" },
- { "soundIcsAlarm", "soundIcsAlarm", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
- XtRString, "$" },
- { "reuseFirst", "reuseFirst", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
- XtRImmediate, (XtPointer) True },
- { "reuseSecond", "reuseSecond", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
- XtRImmediate, (XtPointer) True },
- { "animateDragging", "animateDragging", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
- XtRImmediate, (XtPointer) True },
- { "animateMoving", "animateMoving", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, animate),
- XtRImmediate, (XtPointer) True },
- { "animateSpeed", "animateSpeed", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, animSpeed),
- XtRImmediate, (XtPointer)10 },
- { "popupExitMessage", "popupExitMessage", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
- XtRImmediate, (XtPointer) True },
- { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
- XtRImmediate, (XtPointer) False },
- { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
- XtRImmediate, (XtPointer)4 },
- { "initialMode", "initialMode", XtRString,
- sizeof(String), XtOffset(AppDataPtr, initialMode),
- XtRImmediate, (XtPointer) "" },
- { "variant", "variant", XtRString,
- sizeof(String), XtOffset(AppDataPtr, variant),
- XtRImmediate, (XtPointer) "normal" },
- { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
- XtRImmediate, (XtPointer)PROTOVER },
- { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
- XtRImmediate, (XtPointer)PROTOVER },
- { "showButtonBar", "showButtonBar", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
- XtRImmediate, (XtPointer) True },
- { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
- XtRString, COLOR_LOWTIMEWARNING },
- { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
- XtRImmediate, (XtPointer) False },
- {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean, /* [DM] icsEngineAnalyze */
- sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
- XtRImmediate, (XtPointer) False },
- { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
- XtRImmediate, (XtPointer) False },
- { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
- XtRImmediate, (XtPointer) False },
- { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
- XtRImmediate, (XtPointer) False },
- { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
- XtRImmediate, (XtPointer) True },
- { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
- XtRImmediate, (XtPointer) 0},
- { "adjudicateDrawMoves", "adjudicateDrawMoves", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, adjudicateDrawMoves),
- XtRImmediate, (XtPointer) 0},
- { "pgnEventHeader", "pgnEventHeader", XtRString,
- sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
- XtRImmediate, (XtPointer) "Computer Chess Game" },
- { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
- XtRImmediate, (XtPointer) -1},
- { "gameListTags", "gameListTags", XtRString,
- sizeof(String), XtOffset(AppDataPtr, gameListTags),
- XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
-
- // [HGM] 4.3.xx options
- { "boardWidth", "boardWidth", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, NrFiles),
- XtRImmediate, (XtPointer) -1},
- { "boardHeight", "boardHeight", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, NrRanks),
- XtRImmediate, (XtPointer) -1},
- { "matchPause", "matchPause", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, matchPause),
- XtRImmediate, (XtPointer) 10000},
- { "holdingsSize", "holdingsSize", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, holdingsSize),
- XtRImmediate, (XtPointer) -1},
- { "flipBlack", "flipBlack", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
- XtRImmediate, (XtPointer) False},
- { "allWhite", "allWhite", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
- XtRImmediate, (XtPointer) False},
- { "pieceToCharTable", "pieceToCharTable", XtRString,
- sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
- XtRImmediate, (XtPointer) 0},
- { "alphaRank", "alphaRank", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
- XtRImmediate, (XtPointer) False},
- { "testClaims", "testClaims", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
- XtRImmediate, (XtPointer) True},
- { "checkMates", "checkMates", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
- XtRImmediate, (XtPointer) True},
- { "materialDraws", "materialDraws", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
- XtRImmediate, (XtPointer) True},
- { "trivialDraws", "trivialDraws", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
- XtRImmediate, (XtPointer) False},
- { "ruleMoves", "ruleMoves", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, ruleMoves),
- XtRImmediate, (XtPointer) 51},
- { "repeatsToDraw", "repeatsToDraw", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, drawRepeats),
- XtRImmediate, (XtPointer) 6},
- { "engineDebugOutput", "engineDebugOutput", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, engineComments),
- XtRImmediate, (XtPointer) 1},
- { "userName", "userName", XtRString,
- sizeof(int), XtOffset(AppDataPtr, userName),
- XtRImmediate, (XtPointer) 0},
- { "autoKibitz", "autoKibitz", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
- XtRImmediate, (XtPointer) False},
- { "firstTimeOdds", "firstTimeOdds", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
- XtRImmediate, (XtPointer) 1},
- { "secondTimeOdds", "secondTimeOdds", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
- XtRImmediate, (XtPointer) 1},
- { "timeOddsMode", "timeOddsMode", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
- XtRImmediate, (XtPointer) 0},
- { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
- XtRImmediate, (XtPointer) 1},
- { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
- XtRImmediate, (XtPointer) 1},
- { "firstNPS", "firstNPS", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, firstNPS),
- XtRImmediate, (XtPointer) -1},
- { "secondNPS", "secondNPS", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, secondNPS),
- XtRImmediate, (XtPointer) -1},
- { "serverMoves", "serverMoves", XtRString,
- sizeof(String), XtOffset(AppDataPtr, serverMovesName),
- XtRImmediate, (XtPointer) 0},
- { "serverPause", "serverPause", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, serverPause),
- XtRImmediate, (XtPointer) 0},
- { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
- XtRImmediate, (XtPointer) False},
- { "userName", "userName", XtRString,
- sizeof(String), XtOffset(AppDataPtr, userName),
- XtRImmediate, (XtPointer) 0},
- { "egtFormats", "egtFormats", XtRString,
- sizeof(String), XtOffset(AppDataPtr, egtFormats),
- XtRImmediate, (XtPointer) 0},
- { "rewindIndex", "rewindIndex", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, rewindIndex),
- XtRImmediate, (XtPointer) 0},
- { "sameColorGames", "sameColorGames", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, sameColorGames),
- XtRImmediate, (XtPointer) 0},
- { "smpCores", "smpCores", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, smpCores),
- XtRImmediate, (XtPointer) 1},
- { "niceEngines", "niceEngines", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, niceEngines),
- XtRImmediate, (XtPointer) 0},
- { "nameOfDebugFile", "nameOfDebugFile", XtRString,
- sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
- XtRImmediate, (XtPointer) "xboard.debug"},
- { "engineDebugOutput", "engineDebugOutput", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, engineComments),
- XtRImmediate, (XtPointer) 1},
- { "noGUI", "noGUI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
- XtRImmediate, (XtPointer) 0},
- { "firstOptions", "firstOptions", XtRString,
- sizeof(String), XtOffset(AppDataPtr, firstOptions),
- XtRImmediate, (XtPointer) "" },
- { "secondOptions", "secondOptions", XtRString,
- sizeof(String), XtOffset(AppDataPtr, secondOptions),
- XtRImmediate, (XtPointer) "" },
- { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
- sizeof(String), XtOffset(AppDataPtr, fenOverride1),
- XtRImmediate, (XtPointer) 0 },
- { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
- sizeof(String), XtOffset(AppDataPtr, fenOverride2),
- XtRImmediate, (XtPointer) 0 },
-
- // [HGM] Winboard_x UCI options
- { "firstIsUCI", "firstIsUCI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
- XtRImmediate, (XtPointer) False},
- { "secondIsUCI", "secondIsUCI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
- XtRImmediate, (XtPointer) False},
- { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
- XtRImmediate, (XtPointer) True},
- { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
- XtRImmediate, (XtPointer) True},
- { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
- XtRImmediate, (XtPointer) False},
- { "defaultHashSize", "defaultHashSize", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
- XtRImmediate, (XtPointer) 64},
- { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
- XtRImmediate, (XtPointer) 4},
- { "polyglotDir", "polyglotDir", XtRString,
- sizeof(String), XtOffset(AppDataPtr, polyglotDir),
- XtRImmediate, (XtPointer) "." },
- { "polyglotBook", "polyglotBook", XtRString,
- sizeof(String), XtOffset(AppDataPtr, polyglotBook),
- XtRImmediate, (XtPointer) "" },
- { "defaultPathEGTB", "defaultPathEGTB", XtRString,
- sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
- XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
- { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
- XtRImmediate, (XtPointer) 0},
- { "delayAfterQuit", "delayAfterQuit", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
- XtRImmediate, (XtPointer) 0},
- { "keepAlive", "keepAlive", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, keepAlive),
- XtRImmediate, (XtPointer) 0},
- { "forceIllegalMoves", "forceIllegalMoves", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, forceIllegal),
- XtRImmediate, (XtPointer) False},
- { "keepLineBreaksICS", "keepLineBreaksICS", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, noJoin),
- XtRImmediate, (XtPointer) True},
-};
-
-XrmOptionDescRec shellOptions[] = {
- { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
- { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
- { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
- { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
- { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
- { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
- { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
- { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
- { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
- { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
- { "-initString", "initString", XrmoptionSepArg, NULL },
- { "-firstInitString", "initString", XrmoptionSepArg, NULL },
- { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
- { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
- { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
- { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
- { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
- { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
- { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
- { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
- { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
- { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
- { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
- { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
- { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
- { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
- { "-fh", "firstHost", XrmoptionSepArg, NULL },
- { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
- { "-sh", "secondHost", XrmoptionSepArg, NULL },
- { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
- { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
- { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
- { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
- { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
- { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
- { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
- { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
- { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
- { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
- { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
- { "-td", "timeDelay", XrmoptionSepArg, NULL },
- { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
- { "-tc", "timeControl", XrmoptionSepArg, NULL },
- { "-internetChessServerMode", "internetChessServerMode",
- XrmoptionSepArg, NULL },
- { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
- { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
- { "-internetChessServerHost", "internetChessServerHost",
- XrmoptionSepArg, NULL },
- { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
- { "-internetChessServerPort", "internetChessServerPort",
- XrmoptionSepArg, NULL },
- { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
- { "-internetChessServerCommPort", "internetChessServerCommPort",
- XrmoptionSepArg, NULL },
- { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
- { "-internetChessServerLogonScript", "internetChessServerLogonScript",
- XrmoptionSepArg, NULL },
- { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
- { "-internetChessServerHelper", "internetChessServerHelper",
- XrmoptionSepArg, NULL },
- { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
- { "-internetChessServerInputBox", "internetChessServerInputBox",
- XrmoptionSepArg, NULL },
- { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
- { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
- { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
- { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
- { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
- { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
- { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
- { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
- { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
- { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
- { "-gateway", "gateway", XrmoptionSepArg, NULL },
- { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
- { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
- { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
- { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
- { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
- { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
- { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
- { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
- { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
- { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
- { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
- { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
- { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
- { "-blind", "blindfold", XrmoptionNoArg, "True" },
- { "-xblind", "blindfold", XrmoptionNoArg, "False" },
- { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
- { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
- { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
- { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
- { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
- { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
- { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
- { "-mm", "matchMode", XrmoptionNoArg, "True" },
- { "-xmm", "matchMode", XrmoptionNoArg, "False" },
- { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
- { "-mg", "matchGames", XrmoptionSepArg, NULL },
- { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
- { "-mono", "monoMode", XrmoptionNoArg, "True" },
- { "-xmono", "monoMode", XrmoptionNoArg, "False" },
- { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
- { "-debug", "debugMode", XrmoptionNoArg, "True" },
- { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
- { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
- { "-clock", "clockMode", XrmoptionNoArg, "True" },
- { "-xclock", "clockMode", XrmoptionNoArg, "False" },
- { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
- { "-size", "boardSize", XrmoptionSepArg, NULL },
- { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
- { "-st", "searchTime", XrmoptionSepArg, NULL },
- { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
- { "-depth", "searchDepth", XrmoptionSepArg, NULL },
- { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
- { "-coords", "showCoords", XrmoptionNoArg, "True" },
- { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
-#if JAIL
- { "-showJail", "showJail", XrmoptionSepArg, NULL },
- { "-jail", "showJail", XrmoptionNoArg, "1" },
- { "-sidejail", "showJail", XrmoptionNoArg, "2" },
- { "-xjail", "showJail", XrmoptionNoArg, "0" },
-#endif
- { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
- { "-thinking", "showThinking", XrmoptionNoArg, "True" },
- { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
- { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
- { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
- { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
- { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
- { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
- { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
- { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
- { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
- { "-font", "font", XrmoptionSepArg, NULL },
- { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
- { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
- { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
- { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
- { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
- { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
- { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
- { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
- { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
- { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
- { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
- { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
- { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
- { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
- { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
- { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
- { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
- { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
- { "-moves", "getMoveList", XrmoptionNoArg, "True" },
- { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
-#if HIGHDRAG
- { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
- { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
- { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
-#endif
- { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
- { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
- { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
- { "-premove", "premove", XrmoptionSepArg, NULL },
- { "-pre", "premove", XrmoptionNoArg, "True" },
- { "-xpre", "premove", XrmoptionNoArg, "False" },
- { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
- { "-legal", "testLegality", XrmoptionNoArg, "True" },
- { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
- { "-flipView", "flipView", XrmoptionSepArg, NULL },
- { "-flip", "flipView", XrmoptionNoArg, "True" },
- { "-xflip", "flipView", XrmoptionNoArg, "False" },
- { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
- { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
- XrmoptionSepArg, NULL },
- { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
- { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
- { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
- { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
- { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
- { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
- { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
- { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
- { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
- { "-title", "titleInWindow", XrmoptionNoArg, "True" },
- { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
-#ifdef ZIPPY
- { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
- { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
- { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
- { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
- { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
- { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
- { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
- { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
- { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
- { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
- { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
- { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
- { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
- { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
- { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
- { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
- { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
- { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
- { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
- { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
- { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
- { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
- { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
- { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
- { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
- { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
- { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
- { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
- { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
- { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
- { "-zippyShortGame", "zippyShortGame", XrmoptionSepArg, NULL },
-#endif
- { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
- { "-flash", "flashCount", XrmoptionNoArg, "3" },
- { "-xflash", "flashCount", XrmoptionNoArg, "0" },
- { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
- { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
- { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
- { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
- { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
- { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
- { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
- { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
- { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
- { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
- { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
- { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
- { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
- { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
- { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
- { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
- { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
- { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
- { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
- { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
- { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
- { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
- { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
- { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
- { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
- { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
- { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
- { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
- { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
- { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
- { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
- { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
- { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
- { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
- { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
- { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
- { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
- { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
- { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
- { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
- { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
- { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
- { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
- { "-animate", "animateMoving", XrmoptionNoArg, "True" },
- { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
- { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
- { "-drag", "animateDragging", XrmoptionNoArg, "True" },
- { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
- { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
- { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
- { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
- { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
- { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
- { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
- { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
- { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
- { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
- { "-mode", "initialMode", XrmoptionSepArg, NULL },
- { "-variant", "variant", XrmoptionSepArg, NULL },
- { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
- { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
- { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
- { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
- { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
- { "-lowTimeWarningColor", "lowTimeWarningColor", XrmoptionSepArg, NULL },
- { "-lowTimeWarning", "lowTimeWarning", XrmoptionSepArg, NULL },
- /* [AS,HR] New features */
- { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
- { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
- { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
- { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
- { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
- { "-adjudicateDrawMoves", "adjudicateDrawMoves", XrmoptionSepArg, NULL },
- { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },
- { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },
- { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },
- { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },
- { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },
- { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },
- { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },
- { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
- { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
- { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
- { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
- { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },
- { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },
- { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },
- { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },
- { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },
- { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },
- { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },
- { "-gameListTags", "gameListTags", XrmoptionSepArg, NULL },
- // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c
-
- /* [HGM,HR] User-selectable board size */
- { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
- { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
- { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
-
- /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */
- { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work
- { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL }, // requires front-end changes to work
- { "-allWhite", "allWhite", XrmoptionSepArg, NULL }, // requires front-end changes to work
- { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL },
- { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL },
- { "-testClaims", "testClaims", XrmoptionSepArg, NULL },
- { "-checkMates", "checkMates", XrmoptionSepArg, NULL },
- { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL },
- { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL },
- { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL },
- { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },
- { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
- { "-userName", "userName", XrmoptionSepArg, NULL },
- { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" },
- { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL },
- { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL },
- { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL },
- { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL },
- { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL },
- { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL },
- { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL },
- { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL },
- { "-serverPause", "serverPause", XrmoptionSepArg, NULL },
- { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL },
- { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL },
- { "-userName", "userName", XrmoptionSepArg, NULL },
- { "-smpCores", "smpCores", XrmoptionSepArg, NULL },
- { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL },
- { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL },
- { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL },
- { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL },
- { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL },
- { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
- { "-debugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
- { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
- { "-noGUI", "noGUI", XrmoptionNoArg, "True" },
- { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL },
- { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL },
- { "-firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
- { "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
- { "-keepAlive", "keepAlive", XrmoptionSepArg, NULL },
- { "-forceIllegalMoves", "forceIllegalMoves", XrmoptionNoArg, "True" },
- { "-keepLineBreaksICS", "keepLineBreaksICS", XrmoptionSepArg, NULL },
};
-
XtActionsRec boardActions[] = {
- { "DrawPosition", DrawPositionProc },
- { "HandleUserMove", HandleUserMove },
+ // { "HandleUserMove", HandleUserMove },
{ "AnimateUserMove", AnimateUserMove },
- { "FileNameAction", FileNameAction },
+ // { "FileNameAction", FileNameAction },
+ { "HandlePV", HandlePV },
+ { "UnLoadPV", UnLoadPV },
{ "AskQuestionProc", AskQuestionProc },
{ "AskQuestionReplyAction", AskQuestionReplyAction },
{ "PieceMenuPopup", PieceMenuPopup },
- { "WhiteClock", WhiteClock },
- { "BlackClock", BlackClock },
+ // { "WhiteClock", WhiteClock },
+ // { "BlackClock", BlackClock },
{ "Iconify", Iconify },
- { "ResetProc", ResetProc },
- { "LoadGameProc", LoadGameProc },
- { "LoadNextGameProc", LoadNextGameProc },
- { "LoadPrevGameProc", LoadPrevGameProc },
{ "LoadSelectedProc", LoadSelectedProc },
- { "ReloadGameProc", ReloadGameProc },
- { "LoadPositionProc", LoadPositionProc },
- { "LoadNextPositionProc", LoadNextPositionProc },
- { "LoadPrevPositionProc", LoadPrevPositionProc },
- { "ReloadPositionProc", ReloadPositionProc },
+ // { "LoadPositionProc", LoadPositionProc },
+ // { "LoadNextPositionProc", LoadNextPositionProc },
+ // { "LoadPrevPositionProc", LoadPrevPositionProc },
+ // { "ReloadPositionProc", ReloadPositionProc },
{ "CopyPositionProc", CopyPositionProc },
{ "PastePositionProc", PastePositionProc },
{ "CopyGameProc", CopyGameProc },
{ "PasteGameProc", PasteGameProc },
- { "SaveGameProc", SaveGameProc },
- { "SavePositionProc", SavePositionProc },
+ // { "SaveGameProc", SaveGameProc },
+ // { "SavePositionProc", SavePositionProc },
{ "MailMoveProc", MailMoveProc },
{ "ReloadCmailMsgProc", ReloadCmailMsgProc },
- { "QuitProc", QuitProc },
- { "MachineWhiteProc", MachineWhiteProc },
- { "MachineBlackProc", MachineBlackProc },
- { "AnalysisModeProc", AnalyzeModeProc },
- { "AnalyzeFileProc", AnalyzeFileProc },
- { "TwoMachinesProc", TwoMachinesProc },
- { "IcsClientProc", IcsClientProc },
- { "EditGameProc", EditGameProc },
- { "EditPositionProc", EditPositionProc },
- { "TrainingProc", EditPositionProc },
+ // { "MachineWhiteProc", MachineWhiteProc },
+ // { "MachineBlackProc", MachineBlackProc },
+ // { "AnalysisModeProc", AnalyzeModeProc },
+ // { "AnalyzeFileProc", AnalyzeFileProc },
+ // { "TwoMachinesProc", TwoMachinesProc },
+ // { "IcsClientProc", IcsClientProc },
+ // { "EditGameProc", EditGameProc },
+ // { "EditPositionProc", EditPositionProc },
+ // { "TrainingProc", EditPositionProc },
{ "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
+ { "EvalGraphProc", EvalGraphProc}, // [HGM] Winboard_x avaluation graph window
{ "ShowGameListProc", ShowGameListProc },
- { "ShowMoveListProc", HistoryShowProc},
- { "EditTagsProc", EditCommentProc },
+ // { "ShowMoveListProc", HistoryShowProc},
+ // { "EditTagsProc", EditCommentProc },
{ "EditCommentProc", EditCommentProc },
- { "IcsAlarmProc", IcsAlarmProc },
+ // { "IcsAlarmProc", IcsAlarmProc },
{ "IcsInputBoxProc", IcsInputBoxProc },
- { "PauseProc", PauseProc },
- { "AcceptProc", AcceptProc },
- { "DeclineProc", DeclineProc },
- { "RematchProc", RematchProc },
- { "CallFlagProc", CallFlagProc },
- { "DrawProc", DrawProc },
- { "AdjournProc", AdjournProc },
- { "AbortProc", AbortProc },
- { "ResignProc", ResignProc },
- { "AdjuWhiteProc", AdjuWhiteProc },
- { "AdjuBlackProc", AdjuBlackProc },
- { "AdjuDrawProc", AdjuDrawProc },
+ // { "AcceptProc", AcceptProc },
+ // { "DeclineProc", DeclineProc },
+ // { "RematchProc", RematchProc },
+ // { "CallFlagProc", CallFlagProc },
+ // { "DrawProc", DrawProc },
+ // { "AdjournProc", AdjournProc },
+ // { "AbortProc", AbortProc },
+ // { "ResignProc", ResignProc },
+ // { "AdjuWhiteProc", AdjuWhiteProc },
+ // { "AdjuBlackProc", AdjuBlackProc },
+ // { "AdjuDrawProc", AdjuDrawProc },
{ "EnterKeyProc", EnterKeyProc },
- { "StopObservingProc", StopObservingProc },
- { "StopExaminingProc", StopExaminingProc },
- { "BackwardProc", BackwardProc },
- { "ForwardProc", ForwardProc },
- { "ToStartProc", ToStartProc },
- { "ToEndProc", ToEndProc },
- { "RevertProc", RevertProc },
- { "TruncateGameProc", TruncateGameProc },
- { "MoveNowProc", MoveNowProc },
- { "RetractMoveProc", RetractMoveProc },
- { "AlwaysQueenProc", AlwaysQueenProc },
- { "AnimateDraggingProc", AnimateDraggingProc },
- { "AnimateMovingProc", AnimateMovingProc },
- { "AutoflagProc", AutoflagProc },
- { "AutoflipProc", AutoflipProc },
- { "AutobsProc", AutobsProc },
- { "AutoraiseProc", AutoraiseProc },
- { "AutosaveProc", AutosaveProc },
- { "BlindfoldProc", BlindfoldProc },
- { "FlashMovesProc", FlashMovesProc },
- { "FlipViewProc", FlipViewProc },
- { "GetMoveListProc", GetMoveListProc },
+ // { "StopObservingProc", StopObservingProc },
+ // { "StopExaminingProc", StopExaminingProc },
+ // { "BackwardProc", BackwardProc },
+ // { "ForwardProc", ForwardProc },
+ // { "ToStartProc", ToStartProc },
+ // { "ToEndProc", ToEndProc },
+ // { "RevertProc", RevertProc },
+ // { "TruncateGameProc", TruncateGameProc },
+ // { "MoveNowProc", MoveNowProc },
+ // { "RetractMoveProc", RetractMoveProc },
+ // { "AlwaysQueenProc", AlwaysQueenProc },
+ // { "AnimateDraggingProc", AnimateDraggingProc },
+ // { "AnimateMovingProc", AnimateMovingProc },
+ // { "AutoflagProc", AutoflagProc },
+ // { "AutoflipProc", AutoflipProc },
+ // { "AutobsProc", AutobsProc },
+ // { "AutoraiseProc", AutoraiseProc },
+ // { "AutosaveProc", AutosaveProc },
+ // { "BlindfoldProc", BlindfoldProc },
+ // { "FlashMovesProc", FlashMovesProc },
+ // { "FlipViewProc", FlipViewProc },
+ // { "GetMoveListProc", GetMoveListProc },
#if HIGHDRAG
- { "HighlightDraggingProc", HighlightDraggingProc },
+ // { "HighlightDraggingProc", HighlightDraggingProc },
#endif
- { "HighlightLastMoveProc", HighlightLastMoveProc },
- { "IcsAlarmProc", IcsAlarmProc },
- { "MoveSoundProc", MoveSoundProc },
- { "OldSaveStyleProc", OldSaveStyleProc },
- { "PeriodicUpdatesProc", PeriodicUpdatesProc },
- { "PonderNextMoveProc", PonderNextMoveProc },
- { "PopupExitMessageProc", PopupExitMessageProc },
- { "PopupMoveErrorsProc", PopupMoveErrorsProc },
- { "PremoveProc", PremoveProc },
- { "QuietPlayProc", QuietPlayProc },
- { "ShowCoordsProc", ShowCoordsProc },
- { "ShowThinkingProc", ShowThinkingProc },
- { "HideThinkingProc", HideThinkingProc },
- { "TestLegalityProc", TestLegalityProc },
- { "InfoProc", InfoProc },
- { "ManProc", ManProc },
- { "HintProc", HintProc },
- { "BookProc", BookProc },
+ // { "HighlightLastMoveProc", HighlightLastMoveProc },
+ // { "IcsAlarmProc", IcsAlarmProc },
+ // { "MoveSoundProc", MoveSoundProc },
+ // { "OldSaveStyleProc", OldSaveStyleProc },
+ // { "PeriodicUpdatesProc", PeriodicUpdatesProc },
+ // { "PonderNextMoveProc", PonderNextMoveProc },
+ // { "PopupExitMessageProc", PopupExitMessageProc },
+ // { "PopupMoveErrorsProc", PopupMoveErrorsProc },
+ // { "PremoveProc", PremoveProc },
+ // { "QuietPlayProc", QuietPlayProc },
+ // { "ShowThinkingProc", ShowThinkingProc },
+ // { "HideThinkingProc", HideThinkingProc },
+ // { "TestLegalityProc", TestLegalityProc },
+ { "SaveSettingsProc", SaveSettingsProc },
+ { "SaveOnExitProc", SaveOnExitProc },
+// { "InfoProc", InfoProc },
+// { "ManProc", ManProc },
+// { "HintProc", HintProc },
+// { "BookProc", BookProc },
{ "AboutGameProc", AboutGameProc },
- { "AboutProc", AboutProc },
{ "DebugProc", DebugProc },
{ "NothingProc", NothingProc },
{ "CommentPopDown", (XtActionProc) CommentPopDown },
{ "TagsPopDown", (XtActionProc) TagsPopDown },
{ "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
- { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
- { "FileNamePopDown", (XtActionProc) FileNamePopDown },
+ // { "FileNamePopDown", (XtActionProc) FileNamePopDown },
{ "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
- { "HistoryPopDown", (XtActionProc) HistoryPopDown },
+ // { "HistoryPopDown", (XtActionProc) HistoryPopDown },
{ "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+ { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
{ "ShufflePopDown", (XtActionProc) ShufflePopDown },
{ "EnginePopDown", (XtActionProc) EnginePopDown },
{ "UciPopDown", (XtActionProc) UciPopDown },
{ "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
{ "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
{ "SettingsPopDown", (XtActionProc) SettingsPopDown },
+ { "CopyMemoProc", (XtActionProc) CopyMemoProc },
};
-char globalTranslations[] =
- ":<Key>R: ResignProc() \n \
- :<Key>r: ResetProc() \n \
- :<Key>g: LoadGameProc() \n \
- :<Key>N: LoadNextGameProc() \n \
- :<Key>P: LoadPrevGameProc() \n \
- :<Key>Q: QuitProc() \n \
- :<Key>F: ToEndProc() \n \
- :<Key>f: ForwardProc() \n \
- :<Key>B: ToStartProc() \n \
- :<Key>b: BackwardProc() \n \
- :<Key>p: PauseProc() \n \
- :<Key>d: DrawProc() \n \
- :<Key>t: CallFlagProc() \n \
- :<Key>i: Iconify() \n \
- :<Key>c: Iconify() \n \
- :<Key>v: FlipViewProc() \n \
- <KeyDown>Control_L: BackwardProc() \n \
- <KeyUp>Control_L: ForwardProc() \n \
- <KeyDown>Control_R: BackwardProc() \n \
- <KeyUp>Control_R: ForwardProc() \n \
- Shift<Key>1: AskQuestionProc(\"Direct command\",\
- \"Send to chess program:\",,1) \n \
- Shift<Key>2: AskQuestionProc(\"Direct command\",\
- \"Send to second chess program:\",,2) \n";
-
-char boardTranslations[] =
- "<Btn1Down>: HandleUserMove() \n \
- <Btn1Up>: HandleUserMove() \n \
- <Btn1Motion>: AnimateUserMove() \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[] = "<BtnDown>: WhiteClock()\n";
-char blackTranslations[] = "<BtnDown>: BlackClock()\n";
+//char globalTranslations[] =
+// ":<Key>R: ResignProc() \n \
+// :<Key>r: ResetProc() \n \
+// :<Key>g: LoadGameProc() \n \
+// :<Key>N: LoadNextGameProc() \n \
+// :<Key>P: LoadPrevGameProc() \n \
+// :<Key>Q: QuitProc() \n \
+// :<Key>F: ToEndProc() \n \
+// :<Key>f: ForwardProc() \n \
+// :<Key>B: ToStartProc() \n \
+// :<Key>b: BackwardProc() \n \
+// :<Key>p: PauseProc() \n \
+// :<Key>d: DrawProc() \n \
+// :<Key>t: CallFlagProc() \n \
+// :<Key>i: Iconify() \n \
+// :<Key>c: Iconify() \n \
+// :<Key>v: FlipViewProc() \n \
+// <KeyDown>Control_L: BackwardProc() \n \
+// <KeyUp>Control_L: ForwardProc() \n \
+// <KeyDown>Control_R: BackwardProc() \n \
+// <KeyUp>Control_R: ForwardProc() \n \
+// Shift<Key>1: AskQuestionProc(\"Direct command\",\
+// \"Send to chess program:\",,1) \n \
+// Shift<Key>2: AskQuestionProc(\"Direct command\",\
+// \"Send to second chess program:\",,2) \n";
+//
+//char boardTranslations[] =
+// "<Btn1Down>: HandleUserMove() \n \
+// <Btn1Up>: HandleUserMove() \n \
+// <Btn1Motion>: AnimateUserMove() \n \
+// <Btn3Motion>: HandlePV() \n \
+// <Btn3Up>: UnLoadPV() \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[] = "<BtnDown>: WhiteClock()\n";
+//char blackTranslations[] = "<BtnDown>: BlackClock()\n";
char ICSInputTranslations[] =
"<Key>Return: EnterKeyProc() \n";
String xboardResources[] = {
- "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
+ // "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
"*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
"*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
NULL
};
-
-/* Max possible square size */
-#define MAXSQSIZE 256
-
-static int xpm_avail[MAXSQSIZE];
-
-#ifdef HAVE_DIR_STRUCT
-
-/* Extract piece size from filename */
-static int
-xpm_getsize(name, len, ext)
- char *name;
- int len;
- char *ext;
-{
- char *p, *d;
- char buf[10];
-
- if (len < 4)
- return 0;
-
- if ((p=strchr(name, '.')) == NULL ||
- StrCaseCmp(p+1, ext) != 0)
- return 0;
-
- p = name + 3;
- d = buf;
-
- while (*p && isdigit(*p))
- *(d++) = *(p++);
-
- *d = 0;
- return atoi(buf);
-}
-
-/* Setup xpm_avail */
-static int
-xpm_getavail(dirname, ext)
- char *dirname;
- char *ext;
-{
- DIR *dir;
- struct dirent *ent;
- int i;
-
- for (i=0; i<MAXSQSIZE; ++i)
- xpm_avail[i] = 0;
-
- if (appData.debugMode)
- fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
-
- dir = opendir(dirname);
- if (!dir)
- {
- fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
- programName, dirname);
- exit(1);
- }
-
- while ((ent=readdir(dir)) != NULL) {
- i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
- if (i > 0 && i < MAXSQSIZE)
- xpm_avail[i] = 1;
- }
-
- closedir(dir);
-
- return 0;
-}
-
-void
-xpm_print_avail(fp, ext)
- FILE *fp;
- char *ext;
-{
- int i;
-
- fprintf(fp, _("Available `%s' sizes:\n"), ext);
- for (i=1; i<MAXSQSIZE; ++i) {
- if (xpm_avail[i])
- printf("%d\n", i);
- }
-}
-
-/* Return XPM piecesize closest to size */
-int
-xpm_closest_to(dirname, size, ext)
- char *dirname;
- int size;
- char *ext;
-{
- int i;
- int sm_diff = MAXSQSIZE;
- int sm_index = 0;
- int diff;
-
- xpm_getavail(dirname, ext);
-
- if (appData.debugMode)
- xpm_print_avail(stderr, ext);
-
- for (i=1; i<MAXSQSIZE; ++i) {
- if (xpm_avail[i]) {
- diff = size - i;
- diff = (diff<0) ? -diff : diff;
- if (diff < sm_diff) {
- sm_diff = diff;
- sm_index = i;
- }
- }
- }
-
- if (!sm_index) {
- fprintf(stderr, _("Error: No `%s' files!\n"), ext);
- exit(1);
- }
-
- return sm_index;
-}
-#else /* !HAVE_DIR_STRUCT */
-/* If we are on a system without a DIR struct, we can't
- read the directory, so we can't collect a list of
- filenames, etc., so we can't do any size-fitting. */
-int
-xpm_closest_to(dirname, size, ext)
- char *dirname;
- int size;
- char *ext;
-{
- fprintf(stderr, _("\
-Warning: No DIR structure found on this system --\n\
- Unable to autosize for XPM/XIM pieces.\n\
- Please report this error to frankm@hiwaay.net.\n\
- Include system type & operating system in message.\n"));
- return size;
-}
-#endif /* HAVE_DIR_STRUCT */
-
static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
"magenta", "cyan", "white" };
typedef struct {
}
-/* Arrange to catch delete-window events */
-Atom wm_delete_window;
void
-CatchDeleteWindow(Widget w, String procname)
+BoardToTop()
{
- char buf[MSG_SIZ];
- XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
- snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
- XtAugmentTranslations(w, XtParseTranslationTable(buf));
+ /* this should raise the board to the top */
+ gtk_window_present(GTK_WINDOW(GUI_Window));
+ return;
}
+//---------------------------------------------------------------------------------------------------------
+// some symbol definitions to provide the proper (= XBoard) context for the code in args.h
+#define XBOARD True
+#define JAWS_ARGS
+#define CW_USEDEFAULT (1<<31)
+#define ICS_TEXT_MENU_SIZE 90
+#define DEBUG_FILE "xboard.debug"
+#define SetCurrentDirectory chdir
+#define GetCurrentDirectory(SIZE, NAME) getcwd(NAME, SIZE)
+#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"
+
+// front-end part of option handling
+
+// [HGM] This platform-dependent table provides the location for storing the color info
+extern char *crWhite, * crBlack;
+
+void *
+colorVariable[] = {
+ &appData.whitePieceColor,
+ &appData.blackPieceColor,
+ &appData.lightSquareColor,
+ &appData.darkSquareColor,
+ &appData.highlightSquareColor,
+ &appData.premoveHighlightColor,
+ &appData.lowTimeWarningColor,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &crWhite,
+ &crBlack,
+ NULL
+};
+
void
-BoardToTop()
+ParseFont(char *name, int number)
+{ // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
+ switch(number) {
+ case 0: // CLOCK_FONT
+ appData.clockFont = strdup(name);
+ break;
+ case 1: // MESSAGE_FONT
+ appData.font = strdup(name);
+ break;
+ case 2: // COORD_FONT
+ appData.coordFont = strdup(name);
+ break;
+ default:
+ return;
+ }
+}
+
+void
+SetFontDefaults()
+{ // only 2 fonts currently
+ appData.clockFont = CLOCK_FONT_NAME;
+ appData.coordFont = COORD_FONT_NAME;
+ appData.font = DEFAULT_FONT_NAME;
+}
+
+void
+CreateFonts()
+{ // no-op, until we identify the code for this already in XBoard and move it here
+}
+
+void
+ParseColor(int n, char *name)
+{ // in XBoard, just copy the color-name string
+ if(colorVariable[n]) *(char**)colorVariable[n] = strdup(name);
+}
+
+void
+ParseTextAttribs(ColorClass cc, char *s)
+{
+ (&appData.colorShout)[cc] = strdup(s);
+}
+
+void
+ParseBoardSize(void *addr, char *name)
+{
+ appData.boardSize = strdup(name);
+}
+
+void
+LoadAllSounds()
+{ // In XBoard the sound-playing program takes care of obtaining the actual sound
+}
+
+void
+SetCommPortDefaults()
+{ // for now, this is a no-op, as the corresponding option does not exist in XBoard
+}
+
+// [HGM] args: these three cases taken out to stay in front-end
+void
+SaveFontArg(FILE *f, ArgDescriptor *ad)
+{
+ char *name;
+ switch((int)ad->argLoc) {
+ case 0: // CLOCK_FONT
+ name = appData.clockFont;
+ break;
+ case 1: // MESSAGE_FONT
+ name = appData.font;
+ break;
+ case 2: // COORD_FONT
+ name = appData.coordFont;
+ break;
+ default:
+ return;
+ }
+// Do not save fonts for now, as the saved font would be board-size specific
+// and not suitable for a re-start at another board size
+// fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, name);
+}
+
+void
+ExportSounds()
+{ // nothing to do, as the sounds are at all times represented by their text-string names already
+}
+
+void
+SaveAttribsArg(FILE *f, ArgDescriptor *ad)
+{ // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)ad->argLoc]);
+}
+
+void
+SaveColor(FILE *f, ArgDescriptor *ad)
+{ // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
+ if(colorVariable[(int)ad->argLoc])
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)ad->argLoc]);
+}
+
+void
+SaveBoardSize(FILE *f, char *name, void *addr)
+{ // wrapper to shield back-end from BoardSize & sizeInfo
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
+}
+
+void
+ParseCommPortSettings(char *s)
+{ // no such option in XBoard (yet)
+}
+
+extern Widget engineOutputShell;
+extern Widget tagsShell, editTagsShell;
+void
+GetActualPlacement(Widget wg, WindowPlacement *wp)
{
Arg args[16];
- XtSetArg(args[0], XtNiconic, False);
- XtSetValues(shellWidget, args, 1);
+ Dimension w, h;
+ Position x, y;
+ int i;
- XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
+ if(!wg) return;
+
+ i = 0;
+ XtSetArg(args[i], XtNx, &x); i++;
+ XtSetArg(args[i], XtNy, &y); i++;
+ XtSetArg(args[i], XtNwidth, &w); i++;
+ XtSetArg(args[i], XtNheight, &h); i++;
+ XtGetValues(wg, args, i);
+ wp->x = x - 4;
+ wp->y = y - 23;
+ wp->height = h;
+ wp->width = w;
}
+void
+GetWindowCoords()
+{ // 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); else
+ if(MoveHistoryIsUp()) GetActualPlacement(historyShell, &wpMoveHistory);
+ if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
+ if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
+ if(commentShell) GetActualPlacement(commentShell, &wpComment);
+ else GetActualPlacement(editShell, &wpComment);
+ if(tagsShell) GetActualPlacement(tagsShell, &wpTags);
+ else GetActualPlacement(editTagsShell, &wpTags);
+}
+
+void
+PrintCommPortSettings(FILE *f, char *name)
+{ // This option does not exist in XBoard
+}
+
+int
+MySearchPath(char *installDir, char *name, char *fullname)
+{ // just append installDir and name. Perhaps ExpandPath should be used here?
+ name = ExpandPathName(name);
+ if(name && name[0] == '/') strcpy(fullname, name); else {
+ sprintf(fullname, "%s%c%s", installDir, '/', name);
+ }
+ return 1;
+}
+
+int
+MyGetFullPathName(char *name, char *fullname)
+{ // should use ExpandPath?
+ name = ExpandPathName(name);
+ strcpy(fullname, name);
+ return 1;
+}
+
+void
+EnsureOnScreen(int *x, int *y, int minX, int minY)
+{
+ return;
+}
+
+int
+MainWindowUp()
+{ // [HGM] args: allows testing if main window is realized from back-end
+ return xBoardWindow != 0;
+}
+
+void
+PopUpStartupDialog()
+{ // start menu not implemented in XBoard
+}
+char *
+ConvertToLine(int argc, char **argv)
+{
+ static char line[128*1024], buf[1024];
+ int i;
+
+ line[0] = NULLCHAR;
+ for(i=1; i<argc; i++) {
+ if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
+ && argv[i][0] != '{' )
+ sprintf(buf, "{%s} ", argv[i]);
+ else sprintf(buf, "%s ", argv[i]);
+ strcat(line, buf);
+ }
+ line[strlen(line)-1] = NULLCHAR;
+ return line;
+}
+
+//--------------------------------------------------------------------------------------------
+
#ifdef IDSIZES
// eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
#else
+
#define BoardSize int
void InitDrawingSizes(BoardSize boardSize, int flags)
{ // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
XtGeometryResult gres;
int i;
- if(!formWidget) return;
-
- /*
- * Enable shell resizing.
- */
- shellArgs[0].value = (XtArgVal) &w;
- shellArgs[1].value = (XtArgVal) &h;
- XtGetValues(shellWidget, shellArgs, 2);
-
- shellArgs[4].value = 2*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);
-
- boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- CreateGrid();
-
- 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) {
+ if (appData.titleInWindow)
+ {
i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(titleWidget, args, i);
- if (smallLayout) {
+ if (smallLayout)
+ {
w = boardWidth - 2*bor;
- } else {
- XtSetArg(args[0], XtNwidth, &w);
- XtGetValues(menuBarWidget, args, 1);
+ }
+ else
+ {
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);
+ if(!formWidget) return;
/*
* Inhibit shell resizing.
*/
- shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
- 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);
// [HGM] pieces: tailor piece bitmaps to needs of specific variant
// (only for xpm)
char *p;
XrmDatabase xdb;
int forceMono = False;
-#define INDIRECTION
-#ifdef INDIRECTION
- // [HGM] before anything else, expand any indirection files amongst options
- char *argvCopy[1000]; // 1000 seems enough
- char newArgs[10000]; // holds actual characters
- int k = 0;
srandom(time(0)); // [HGM] book: make random truly random
- j = 0;
- for(i=0; i<argc; i++) {
- if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
-//fprintf(stderr, "arg %s\n", argv[i]);
- if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
- char c;
- FILE *f = fopen(argv[i]+1, "rb");
- if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
- argvCopy[j++] = newArgs + k; // get ready for first argument from file
- while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
- if(c == '\n') {
- if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
- newArgs[k++] = 0; // terminate current arg
- if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
- argvCopy[j++] = newArgs + k; // get ready for next
- } else {
- if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
- newArgs[k++] = c;
- }
- }
- newArgs[k] = 0;
- j--;
- fclose(f);
- }
- }
- argvCopy[j] = NULL;
- argv = argvCopy;
- argc = j;
-#endif
-
setbuf(stdout, NULL);
setbuf(stderr, NULL);
debugFP = stderr;
+ if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
+ printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+ exit(0);
+ }
+
programName = strrchr(argv[0], '/');
if (programName == NULL)
programName = argv[0];
textdomain(PACKAGE);
#endif
- shellWidget =
- XtAppInitialize(&appContext, "XBoard", shellOptions,
- XtNumber(shellOptions),
- &argc, argv, xboardResources, NULL, 0);
- if (argc > 1)
- { /* left over command line arguments, print out help and exit.
- * Use two columns to print help
- */
- fprintf(stderr, _("%s: unrecognized argument %s\n"),
- programName, argv[1]);
-
- fprintf(stderr, "Recognized options:\n");
- for(i = 0; i < XtNumber(shellOptions); i++)
- {
- /* print first column */
- j = fprintf(stderr, " %s%s", shellOptions[i].option,
- (shellOptions[i].argKind == XrmoptionSepArg
- ? " ARG" : ""));
- /* print second column and end line */
- if (++i < XtNumber(shellOptions))
- {
- fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
- shellOptions[i].option,
- (shellOptions[i].argKind == XrmoptionSepArg
- ? " ARG" : ""));
- }
- else
- {
- fprintf(stderr, "\n");
- };
- };
- exit(2);
- };
+ /* set up GTK */
+ gtk_init (&argc, &argv);
+
+ /* parse glade file to build widgets */
+
+ builder = gtk_builder_new ();
+ gtk_builder_add_from_file (builder, "gtk-interface.xml", NULL);
+
+ /* test if everything worked ok */
+
+ GUI_Window = GTK_WIDGET (gtk_builder_get_object (builder, "MainWindow"));
+ if(!GUI_Window) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Aspect = GTK_WIDGET (gtk_builder_get_object (builder, "Aspectframe"));
+ if(!GUI_Aspect) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_History = GTK_WIDGET (gtk_builder_get_object (builder, "MoveHistory"));
+ if(!GUI_History) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Menubar = GTK_WIDGET (gtk_builder_get_object (builder, "MenuBar"));
+ if(!GUI_Menubar) printf("Error: gtk_builder didn't work!\n");
+ GUI_Timer = GTK_WIDGET (gtk_builder_get_object (builder, "Timer"));
+ if(!GUI_Timer) printf("Error: gtk_builder didn't work!\n");
+ GUI_Buttonbar = GTK_WIDGET (gtk_builder_get_object (builder, "ButtonBar"));
+ if(!GUI_Buttonbar) printf("Error: gtk_builder didn't work!\n");
+ GUI_Board = GTK_WIDGET (gtk_builder_get_object (builder, "Board"));
+ if(!GUI_Board) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Whiteclock = GTK_WIDGET (gtk_builder_get_object (builder, "WhiteClock"));
+ if(!GUI_Whiteclock) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Blackclock = GTK_WIDGET (gtk_builder_get_object (builder, "BlackClock"));
+ if(!GUI_Blackclock) printf("Error: gtk_builder didn't work!\n");
+
+ LIST_MoveHistory = GTK_LIST_STORE (gtk_builder_get_object (builder, "MoveHistoryStore"));
+ if(!LIST_MoveHistory) printf("Error: gtk_builder didn't work!\n");
+
+ /* EditTags window */
+ GUI_EditTags = GTK_WIDGET (gtk_builder_get_object (builder, "EditTags"));
+ if(!GUI_EditTags) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_EditTagsTextArea = GTK_WIDGET (gtk_builder_get_object (builder, "EditTagsTextArea"));
+ if(!GUI_EditTagsTextArea) printf("Error: gtk_builder didn't work!\n");
+
+
+ gtk_builder_connect_signals (builder, NULL);
+
+ // don't unref the builder, since we use it to get references to widgets
+ // g_object_unref (G_OBJECT (builder));
+
+ /* end parse glade file */
+
+ appData.boardSize = "";
+ InitAppData(ConvertToLine(argc, argv));
p = getenv("HOME");
if (p == NULL) p = "/tmp";
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);
+// 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];
setbuf(debugFP, NULL);
}
- /* [HGM,HR] make sure board size is acceptable */
- if(appData.NrFiles > BOARD_SIZE ||
- appData.NrRanks > BOARD_SIZE )
- DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
#if !HIGHDRAG
/* This feature does not work; animation needs a rewrite */
#endif
InitBackEnd1();
- xDisplay = XtDisplay(shellWidget);
- xScreen = DefaultScreen(xDisplay);
- wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
+ gameInfo.variant = StringToVariant(appData.variant);
+ InitPosition(FALSE);
- gameInfo.variant = StringToVariant(appData.variant);
- InitPosition(FALSE);
-
-#ifdef IDSIZE
- InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
-#else
- if (isdigit(appData.boardSize[0])) {
- i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
- &lineGap, &clockFontPxlSize, &coordFontPxlSize,
- &fontPxlSize, &smallLayout, &tinyLayout);
- if (i == 0) {
- fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
- programName, appData.boardSize);
- exit(2);
- }
- if (i < 7) {
- /* Find some defaults; use the nearest known size */
- SizeDefaults *szd, *nearest;
- int distance = 99999;
- nearest = szd = sizeDefaults;
- while (szd->name != NULL) {
- if (abs(szd->squareSize - squareSize) < distance) {
- nearest = szd;
- distance = abs(szd->squareSize - squareSize);
- if (distance == 0) break;
- }
- szd++;
- }
- if (i < 2) lineGap = nearest->lineGap;
- if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
- if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
- if (i < 5) fontPxlSize = nearest->fontPxlSize;
- if (i < 6) smallLayout = nearest->smallLayout;
- if (i < 7) tinyLayout = nearest->tinyLayout;
- }
- } else {
- SizeDefaults *szd = sizeDefaults;
- if (*appData.boardSize == NULLCHAR) {
- while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
- DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
- szd++;
- }
- if (szd->name == NULL) szd--;
- } else {
- while (szd->name != NULL &&
- StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
- if (szd->name == NULL) {
- fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
- programName, appData.boardSize);
- exit(2);
- }
- }
- squareSize = szd->squareSize;
- lineGap = szd->lineGap;
- clockFontPxlSize = szd->clockFontPxlSize;
- coordFontPxlSize = szd->coordFontPxlSize;
- fontPxlSize = szd->fontPxlSize;
- smallLayout = szd->smallLayout;
- tinyLayout = szd->tinyLayout;
- }
- /* Now, using squareSize as a hint, find a good XPM/XIM set size */
- if (strlen(appData.pixmapDirectory) > 0) {
- p = ExpandPathName(appData.pixmapDirectory);
- if (!p) {
- fprintf(stderr, _("Error expanding path name \"%s\"\n"),
- appData.pixmapDirectory);
- exit(1);
- }
- if (appData.debugMode) {
- fprintf(stderr, _("\
-XBoard square size (hint): %d\n\
-%s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
- }
- squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
- if (appData.debugMode) {
- fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
- }
- }
+ squareSize = 40;
+ lineGap = 1;
+ clockFontPxlSize = 20;
+ coordFontPxlSize = 20;
+ fontPxlSize = 20;
+ smallLayout = 16;
+ tinyLayout = 10;
- /* [HR] height treated separately (hacked) */
- boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- if (appData.showJail == 1) {
- /* Jail on top and bottom */
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight,
- boardHeight + 2*(lineGap + squareSize));
- } else if (appData.showJail == 2) {
- /* Jail on sides */
- XtSetArg(boardArgs[1], XtNwidth,
- boardWidth + 2*(lineGap + squareSize));
- XtSetArg(boardArgs[2], XtNheight, boardHeight);
- } else {
- /* No jail */
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight, boardHeight);
- }
-
+
/*
* Determine what fonts to use.
*/
- appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
- clockFontID = XLoadFont(xDisplay, appData.clockFont);
- clockFontStruct = XQueryFont(xDisplay, clockFontID);
- appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
- coordFontID = XLoadFont(xDisplay, appData.coordFont);
- coordFontStruct = XQueryFont(xDisplay, coordFontID);
- appData.font = FindFont(appData.font, fontPxlSize);
- countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
- countFontStruct = XQueryFont(xDisplay, countFontID);
+// appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
+// clockFontID = XLoadFont(xDisplay, appData.clockFont);
+// clockFontStruct = XQueryFont(xDisplay, clockFontID);
+// appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
+// coordFontID = XLoadFont(xDisplay, appData.coordFont);
+// coordFontStruct = XQueryFont(xDisplay, coordFontID);
+// appData.font = FindFont(appData.font, fontPxlSize);
+// countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
+// countFontStruct = XQueryFont(xDisplay, countFontID);
// appData.font = FindFont(appData.font, fontPxlSize);
- xdb = XtDatabase(xDisplay);
- XrmPutStringResource(&xdb, "*font", appData.font);
+// xdb = XtDatabase(xDisplay);
+// XrmPutStringResource(&xdb, "*font", appData.font);
/*
* Detect if there are not enough colors available and adapt.
*/
- if (DefaultDepth(xDisplay, xScreen) <= 2) {
- appData.monoMode = True;
- }
+// if (DefaultDepth(xDisplay, xScreen) <= 2) {
+// appData.monoMode = True;
+// }
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.lightSquareColor;
vFrom.size = strlen(appData.lightSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.darkSquareColor;
vFrom.size = strlen(appData.darkSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.whitePieceColor;
vFrom.size = strlen(appData.whitePieceColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.blackPieceColor;
vFrom.size = strlen(appData.blackPieceColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.highlightSquareColor;
vFrom.size = strlen(appData.highlightSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.premoveHighlightColor;
vFrom.size = strlen(appData.premoveHighlightColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (forceMono) {
fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
programName);
-
+
if (appData.bitmapDirectory == NULL ||
appData.bitmapDirectory[0] == NULLCHAR)
appData.bitmapDirectory = DEF_BITMAP_DIR;
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)
+ // 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),
- (unsigned long) XBlackPixel(xDisplay, xScreen));
- }
-
if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
textColors[ColorNone].attr = 0;
- XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
+ // XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
/*
* widget hierarchy
} 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);
- XtSetArg(args[0], XtNtop, XtChainTop);
- XtSetArg(args[1], XtNbottom, XtChainTop);
- XtSetValues(menuBarWidget, args, 2);
-
- widgetList[j++] = whiteTimerWidget =
- XtCreateWidget("whiteTime", labelWidgetClass,
- formWidget, timerArgs, XtNumber(timerArgs));
- XtSetArg(args[0], XtNfont, clockFontStruct);
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainTop);
- XtSetValues(whiteTimerWidget, args, 3);
-
- widgetList[j++] = blackTimerWidget =
- XtCreateWidget("blackTime", labelWidgetClass,
- formWidget, timerArgs, XtNumber(timerArgs));
- XtSetArg(args[0], XtNfont, clockFontStruct);
- 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);
+ /* todo check what this appdata does */
}
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);
+ /* TODO hide button bar if requested */
}
- 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));
+ if (appData.titleInWindow)
+ {
+ if (smallLayout)
+ {
+ /* make it small */
+ if (appData.showButtonBar)
+ {
- XtManageChildren(widgetList, j);
+ }
+ }
+ else
+ {
+ if (appData.showButtonBar)
+ {
+ }
+ }
+ }
+ else
+ {
+ }
- timerWidth = (boardWidth - sep) / 2;
- XtSetArg(args[0], XtNwidth, timerWidth);
- XtSetValues(whiteTimerWidget, args, 1);
- XtSetValues(blackTimerWidget, args, 1);
- XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
- XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
- XtGetValues(whiteTimerWidget, args, 2);
+ /* set some checkboxes in the menu according to appData */
- if (appData.showButtonBar) {
- XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
- XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
- }
+ if (appData.alwaysPromoteToQueen)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Always Queen")),TRUE);
- /*
- * 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);
+ if (appData.animateDragging)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Animate Dragging")),TRUE);
- XtRealizeWidget(shellWidget);
+ if (appData.animate)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Animate Moving")),TRUE);
- /*
- * 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);
+ if (appData.autoComment)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Comment")),TRUE);
-#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 */
- }
+ if (appData.autoCallFlag)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Flag")),TRUE);
- 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);
- }
+ if (appData.autoFlipView)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Flip View")),TRUE);
- /* !! 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 */
- XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
- XtSetArg(args[1], XtNright, XtChainRight);
- XtSetValues(messageWidget, args, 2);
+ if (appData.autoObserve)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Observe")),TRUE);
- 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;
- }
+ if (appData.autoRaiseBoard)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Raise Board")),TRUE);
- 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);
+ if (appData.autoSaveGames)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Save")),TRUE);
- xBoardWindow = XtWindow(boardWidget);
+ if (appData.saveGameFile[0] != NULLCHAR)
+ {
+ /* Can't turn this off from menu */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Save")),TRUE);
+ gtk_action_set_sensitive(GTK_ACTION (gtk_builder_get_object (builder, "menuOptions.Auto Save")),FALSE);
+ }
- // [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
+ if (appData.blindfold)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Blindfold")),TRUE);
- /*
- * Create X checkmark bitmap and initialize option menu checks.
- */
- ReadBitmap(&xMarkPixmap, "checkmark.bm",
- checkmark_bits, checkmark_width, checkmark_height);
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- if (appData.alwaysPromoteToQueen) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
- args, 1);
- }
- if (appData.animateDragging) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Animate Dragging"),
- args, 1);
- }
- if (appData.animate) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
- args, 1);
- }
- if (appData.autoComment) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
- args, 1);
- }
- if (appData.autoCallFlag) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
- args, 1);
- }
- if (appData.autoFlipView) {
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
- args, 1);
- }
- if (appData.autoObserve) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
- args, 1);
- }
- if (appData.autoRaiseBoard) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Auto Raise Board"), args, 1);
- }
- if (appData.autoSaveGames) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
- }
- if (appData.saveGameFile[0] != NULLCHAR) {
- /* Can't turn this off from menu */
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- False);
+ if (appData.flashCount > 0)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Flash Moves")),TRUE);
+
+ if (appData.getMoveList)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Get Move List")),TRUE);
- }
- if (appData.blindfold) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Blindfold"), args, 1);
- }
- if (appData.flashCount > 0) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Flash Moves"),
- args, 1);
- }
- if (appData.getMoveList) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
- args, 1);
- }
#if HIGHDRAG
- if (appData.highlightDragging) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Dragging"),
- args, 1);
- }
+ if (appData.highlightDragging)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Highlight Dragging")),TRUE);
#endif
- if (appData.highlightLastMove) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Last Move"),
- args, 1);
- }
- if (appData.icsAlarm) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
- args, 1);
- }
- if (appData.ringBellAfterMoves) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
- args, 1);
- }
- if (appData.oldSaveStyle) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Old Save Style"), args, 1);
- }
- if (appData.periodicUpdates) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Periodic Updates"), args, 1);
- }
- if (appData.ponderNextMove) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Ponder Next Move"), args, 1);
- }
- if (appData.popupExitMessage) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Popup Exit Message"), args, 1);
- }
- if (appData.popupMoveErrors) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Popup Move Errors"), args, 1);
- }
- if (appData.premove) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Premove"), args, 1);
- }
- if (appData.quietPlay) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Quiet Play"), args, 1);
- }
- if (appData.showCoords) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
- args, 1);
- }
- if (appData.hideThinkingFromHuman) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
- args, 1);
- }
- if (appData.testLegality) {
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
- args, 1);
- }
- /*
- * Create an icon.
- */
- ReadBitmap(&wIconPixmap, "icon_white.bm",
- icon_white_bits, icon_white_width, icon_white_height);
- ReadBitmap(&bIconPixmap, "icon_black.bm",
- icon_black_bits, icon_black_width, icon_black_height);
- iconPixmap = wIconPixmap;
- i = 0;
- XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
- XtSetValues(shellWidget, args, i);
+ if (appData.highlightLastMove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Highlight Last Move")),TRUE);
- /*
- * Create a cursor for the board widget.
- */
- window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
- XChangeWindowAttributes(xDisplay, xBoardWindow,
- CWCursor, &window_attributes);
+ if (appData.icsAlarm)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.ICS Alarm")),TRUE);
- /*
- * Inhibit shell resizing.
- */
- 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);
- marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
- marginH = h - boardHeight;
+ if (appData.ringBellAfterMoves)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Move Sound")),TRUE);
- CatchDeleteWindow(shellWidget, "QuitProc");
+ if (appData.oldSaveStyle)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Old Save Style")),TRUE);
- CreateGCs();
- CreateGrid();
-#if HAVE_LIBXPM
- if (appData.bitmapDirectory[0] != NULLCHAR) {
- CreatePieces();
- } else {
- CreateXPMPieces();
- }
-#else
- CreateXIMPieces();
- /* Create regular pieces */
- if (!useImages) CreatePieces();
-#endif
+ if (appData.periodicUpdates)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Periodic Updates")),TRUE);
+
+ if (appData.ponderNextMove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Ponder Next Move")),TRUE);
+
+ if (appData.popupExitMessage)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Popup Exit Message")),TRUE);
+
+ if (appData.popupMoveErrors)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Popup Move Errors")),TRUE);
+
+ if (appData.premove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Premove")),TRUE);
+
+ if (appData.quietPlay)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Quit Play")),TRUE);
+
+ if (appData.showCoords)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Show Coords")),TRUE);
+
+ if (appData.showThinking)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Hide Thinking")),TRUE);
+
+ if (appData.testLegality)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Test Legality")),TRUE);
+ // TODO: add
+ // if (saveSettingsOnExit) {
+ // XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Save Settings on Exit"),
+ // args, 1);
+ // }
+
+
+ /* end setting check boxes */
+
+ /* load square colors */
+ SVGLightSquare = load_pixbuf("svg/LightSquare.svg",squareSize);
+ SVGDarkSquare = load_pixbuf("svg/DarkSquare.svg",squareSize);
+ SVGNeutralSquare = load_pixbuf("svg/NeutralSquare.svg",squareSize);
+
+ /* use two icons to indicate if it is white's or black's turn */
+ WhiteIcon = load_pixbuf("svg/icon_white.svg",0);
+ BlackIcon = load_pixbuf("svg/icon_black.svg",0);
+ WindowIcon = WhiteIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
+
+
+ /* realize window */
+ gtk_widget_show (GUI_Window);
+
+ /* recalc boardsize */
+ CreateGCs();
+ CreatePieces();
CreatePieceMenus();
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, False,
- (XtEventHandler) EventProc, NULL);
- /* end why */
-
InitBackEnd2();
if (errorExitStatus == -1) {
if (appData.icsInputBox) ICSInputBoxPopUp();
}
+ #ifdef SIGWINCH
+ signal(SIGWINCH, TermSizeSigHandler);
+ #endif
signal(SIGINT, IntSigHandler);
signal(SIGTERM, IntSigHandler);
if (*appData.cmailGameName != NULLCHAR) {
gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
InitPosition(TRUE);
- XtAppMainLoop(appContext);
+ /*
+ * Create a cursor for the board widget.
+ * (This needs to be called after the window has been created to have access to board-window)
+ */
+
+ BoardCursor = gdk_cursor_new(GDK_HAND2);
+ gdk_window_set_cursor(GUI_Board->window, BoardCursor);
+ gdk_cursor_destroy(BoardCursor);
+
+ /* end cursor */
+ gtk_main ();
+
if (appData.debugMode) fclose(debugFP); // [DM] debug
return 0;
}
if (appData.icsActive && oldICSInteractionTitle != NULL) {
DisplayIcsInteractionTitle(oldICSInteractionTitle);
}
+ if (saveSettingsOnExit) SaveSettings(settingsFileName);
unlink(gameCopyFilename);
unlink(gamePasteFilename);
}
return;
}
-typedef struct {
- char *name;
- Boolean value;
-} Enables;
+void
+GreyRevert(grey)
+ Boolean grey;
+{
+ Widget w;
+ if (!menuBarWidget) return;
+ w = XtNameToWidget(menuBarWidget, "menuStep.Revert");
+ if (w == NULL) {
+ DisplayError("menuStep.Revert", 0);
+ } else {
+ XtSetSensitive(w, !grey);
+ }
+}
void
SetMenuEnables(enab)
Enables *enab;
{
- Widget w;
- if (!menuBarWidget) return;
+ GObject *o;
+
+ if (!builder) return;
while (enab->name != NULL) {
- w = XtNameToWidget(menuBarWidget, enab->name);
- if (w == NULL) {
- DisplayError(enab->name, 0);
- } else {
- XtSetSensitive(w, enab->value);
- }
+ o = gtk_builder_get_object(builder, enab->name);
+ if(GTK_IS_WIDGET(o))
+ gtk_widget_set_sensitive(GTK_WIDGET (o),enab->value);
+ else
+ {
+ if(GTK_IS_ACTION(o))
+ gtk_action_set_sensitive(GTK_ACTION (o),enab->value);
+ else
+ DisplayError(enab->name, 0);
+ }
enab++;
}
}
-Enables icsEnables[] = {
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Machine White", False },
- { "menuMode.Analysis Mode", False },
- { "menuMode.Analyze File", False },
- { "menuMode.Two Machines", False },
-#ifndef ZIPPY
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
- { "menuStep.Move Now", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Hide Thinking", False },
- { "menuOptions.Ponder Next Move", False },
-#endif
- { NULL, False }
-};
-
-Enables ncpEnables[] = {
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { "menuMode.Machine White", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Analysis Mode", False },
- { "menuMode.Analyze File", False },
- { "menuMode.Two Machines", False },
- { "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
- { "Action", False },
- { "menuStep.Revert", False },
- { "menuStep.Move Now", False },
- { "menuStep.Retract Move", False },
- { "menuOptions.Auto Comment", False },
- { "menuOptions.Auto Flag", False },
- { "menuOptions.Auto Flip View", False },
- { "menuOptions.Auto Observe", False },
- { "menuOptions.Auto Raise Board", False },
- { "menuOptions.Get Move List", False },
- { "menuOptions.ICS Alarm", False },
- { "menuOptions.Move Sound", False },
- { "menuOptions.Quiet Play", False },
- { "menuOptions.Hide Thinking", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Ponder Next Move", False },
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
- { NULL, False }
-};
-
-Enables gnuEnables[] = {
- { "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
- { "menuAction.Accept", False },
- { "menuAction.Decline", False },
- { "menuAction.Rematch", False },
- { "menuAction.Adjourn", False },
- { "menuAction.Stop Examining", False },
- { "menuAction.Stop Observing", False },
- { "menuStep.Revert", False },
- { "menuOptions.Auto Comment", False },
- { "menuOptions.Auto Observe", False },
- { "menuOptions.Auto Raise Board", False },
- { "menuOptions.Get Move List", False },
- { "menuOptions.Premove", False },
- { "menuOptions.Quiet Play", False },
-
- /* The next two options rely on SetCmailMode being called *after* */
- /* SetGNUMode so that when GNU is being used to give hints these */
- /* menu options are still available */
-
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { NULL, False }
-};
-
-Enables cmailEnables[] = {
- { "Action", True },
- { "menuAction.Call Flag", False },
- { "menuAction.Draw", True },
- { "menuAction.Adjourn", False },
- { "menuAction.Abort", False },
- { "menuAction.Stop Observing", False },
- { "menuAction.Stop Examining", False },
- { "menuFile.Mail Move", True },
- { "menuFile.Reload CMail Message", True },
- { NULL, False }
-};
-
-Enables trainingOnEnables[] = {
- { "menuMode.Edit Comment", False },
- { "menuMode.Pause", False },
- { "menuStep.Forward", False },
- { "menuStep.Backward", False },
- { "menuStep.Forward to End", False },
- { "menuStep.Back to Start", False },
- { "menuStep.Move Now", False },
- { "menuStep.Truncate Game", False },
- { NULL, False }
-};
-
-Enables trainingOffEnables[] = {
- { "menuMode.Edit Comment", True },
- { "menuMode.Pause", True },
- { "menuStep.Forward", True },
- { "menuStep.Backward", True },
- { "menuStep.Forward to End", True },
- { "menuStep.Back to Start", True },
- { "menuStep.Move Now", True },
- { "menuStep.Truncate Game", True },
- { NULL, False }
-};
-
-Enables machineThinkingEnables[] = {
- { "menuFile.Load Game", False },
- { "menuFile.Load Next Game", False },
- { "menuFile.Load Previous Game", False },
- { "menuFile.Reload Same Game", False },
- { "menuFile.Paste Game", False },
- { "menuFile.Load Position", False },
- { "menuFile.Load Next Position", False },
- { "menuFile.Load Previous Position", False },
- { "menuFile.Reload Same Position", False },
- { "menuFile.Paste Position", False },
- { "menuMode.Machine White", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Two Machines", False },
- { "menuStep.Retract Move", False },
- { NULL, False }
-};
-
-Enables userThinkingEnables[] = {
- { "menuFile.Load Game", True },
- { "menuFile.Load Next Game", True },
- { "menuFile.Load Previous Game", True },
- { "menuFile.Reload Same Game", True },
- { "menuFile.Paste Game", True },
- { "menuFile.Load Position", True },
- { "menuFile.Load Next Position", True },
- { "menuFile.Load Previous Position", True },
- { "menuFile.Reload Same Position", True },
- { "menuFile.Paste Position", True },
- { "menuMode.Machine White", True },
- { "menuMode.Machine Black", True },
- { "menuMode.Two Machines", True },
- { "menuStep.Retract Move", True },
- { NULL, False }
-};
-
void SetICSMode()
{
SetMenuEnables(icsEnables);
#ifdef ZIPPY
if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
+ {}; // XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
#endif
}
{
SetMenuEnables(trainingOnEnables);
if (appData.showButtonBar) {
- XtSetSensitive(buttonBarWidget, False);
+ // XtSetSensitive(buttonBarWidget, False);
}
CommentPopDown();
}
{
SetMenuEnables(trainingOffEnables);
if (appData.showButtonBar) {
- XtSetSensitive(buttonBarWidget, True);
+ // XtSetSensitive(buttonBarWidget, True);
}
}
case MachinePlaysBlack:
case MachinePlaysWhite:
case TwoMachinesPlay:
- XtSetSensitive(XtNameToWidget(menuBarWidget,
- ModeToWidgetName(gameMode)), True);
+// XtSetSensitive(XtNameToWidget(menuBarWidget,
+// ModeToWidgetName(gameMode)), True);
break;
default:
break;
nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
#else
- fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
- if (nfonts < 1) {
- fprintf(stderr, _("%s: no fonts match pattern %s\n"),
- programName, pattern);
- exit(2);
- }
+// fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
+// if (nfonts < 1) {
+// fprintf(stderr, _("%s: no fonts match pattern %s\n"),
+// programName, pattern);
+// exit(2);
+// }
#endif
best = fonts[0];
#ifdef ENABLE_NLS
if (missing_count > 0)
XFreeStringList(missing_list);
- XFreeFontSet(xDisplay, fntSet);
+ // XFreeFontSet(xDisplay, fntSet);
#else
XFreeFontNames(fonts);
#endif
void CreateGCs()
{
- XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
- | GCBackground | GCFunction | GCPlaneMask;
- XGCValues gc_values;
- GC copyInvertedGC;
-
- gc_values.plane_mask = AllPlanes;
- gc_values.line_width = lineGap;
- gc_values.line_style = LineSolid;
- gc_values.function = GXcopy;
-
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);
- gc_values.background = XBlackPixel(xDisplay, xScreen);
- lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);
- gc_values.background = XWhitePixel(xDisplay, xScreen);
- coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
- XSetFont(xDisplay, coordGC, coordFontID);
-
- // [HGM] make font for holdings counts (white on black0
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);
- gc_values.background = XBlackPixel(xDisplay, xScreen);
- countGC = XtGetGC(shellWidget, value_mask, &gc_values);
- XSetFont(xDisplay, countGC, countFontID);
-
- if (appData.monoMode) {
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);
- gc_values.background = XWhitePixel(xDisplay, xScreen);
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);
- gc_values.background = XBlackPixel(xDisplay, xScreen);
- lightSquareGC = wbPieceGC
- = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);
- gc_values.background = XWhitePixel(xDisplay, xScreen);
- darkSquareGC = bwPieceGC
- = XtGetGC(shellWidget, value_mask, &gc_values);
-
- if (DefaultDepth(xDisplay, xScreen) == 1) {
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
- gc_values.function = GXcopyInverted;
- copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);
- gc_values.function = GXcopy;
- if (XBlackPixel(xDisplay, xScreen) == 1) {
- bwPieceGC = darkSquareGC;
- wbPieceGC = copyInvertedGC;
- } else {
- bwPieceGC = copyInvertedGC;
- wbPieceGC = lightSquareGC;
- }
- }
- } else {
- gc_values.foreground = highlightSquareColor;
- gc_values.background = highlightSquareColor;
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = premoveHighlightColor;
- gc_values.background = premoveHighlightColor;
- prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = lightSquareColor;
- gc_values.background = darkSquareColor;
- lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = darkSquareColor;
- gc_values.background = lightSquareColor;
- darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = jailSquareColor;
- gc_values.background = jailSquareColor;
- jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = darkSquareColor;
- wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = lightSquareColor;
- wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = jailSquareColor;
- wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = darkSquareColor;
- bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = lightSquareColor;
- blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = jailSquareColor;
- bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
- }
-}
-
-void loadXIM(xim, xmask, filename, dest, mask)
- XImage *xim;
- XImage *xmask;
- char *filename;
- Pixmap *dest;
- Pixmap *mask;
-{
- int x, y, w, h, p;
- FILE *fp;
- Pixmap temp;
- XGCValues values;
- GC maskGC;
-
- fp = fopen(filename, "rb");
- if (!fp) {
- fprintf(stderr, _("%s: error loading XIM!\n"), programName);
- exit(1);
- }
-
- w = fgetc(fp);
- h = fgetc(fp);
-
- for (y=0; y<h; ++y) {
- for (x=0; x<h; ++x) {
- p = fgetc(fp);
-
- switch (p) {
- case 0:
- XPutPixel(xim, x, y, blackPieceColor);
- if (xmask)
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
- break;
- case 1:
- XPutPixel(xim, x, y, darkSquareColor);
- if (xmask)
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
- break;
- case 2:
- XPutPixel(xim, x, y, whitePieceColor);
- if (xmask)
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
- break;
- case 3:
- XPutPixel(xim, x, y, lightSquareColor);
- if (xmask)
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
- break;
- }
- }
- }
-
- /* create Pixmap of piece */
- *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, xim->depth);
- XPutImage(xDisplay, *dest, lightSquareGC, xim,
- 0, 0, 0, 0, w, h);
-
- /* create Pixmap of clipmask
- Note: We assume the white/black pieces have the same
- outline, so we make only 6 masks. This is okay
- since the XPM clipmask routines do the same. */
- if (xmask) {
- temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, xim->depth);
- XPutImage(xDisplay, temp, lightSquareGC, xmask,
- 0, 0, 0, 0, w, h);
-
- /* now create the 1-bit version */
- *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, 1);
-
- values.foreground = 1;
- values.background = 0;
-
- /* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, *mask,
- GCForeground | GCBackground, &values);
- XCopyPlane(xDisplay, temp, *mask, maskGC,
- 0, 0, squareSize, squareSize, 0, 0, 1);
- XFreePixmap(xDisplay, temp);
- }
-}
-
-
-char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
-
-void CreateXIMPieces()
-{
- int piece, kind;
- char buf[MSG_SIZ];
- u_int ss;
- static char *ximkind[] = { "ll", "ld", "dl", "dd" };
- XImage *ximtemp;
-
- ss = squareSize;
-
- /* The XSynchronize calls were copied from CreatePieces.
- Not sure if needed, but can't hurt */
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt
- buffering bug */
-
- /* temp needed by loadXIM() */
- ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
-
- if (strlen(appData.pixmapDirectory) == 0) {
- useImages = 0;
- } else {
- useImages = 1;
- if (appData.monoMode) {
- DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
- 0, 2);
- ExitEvent(2);
- }
- fprintf(stderr, _("\nLoading XIMs...\n"));
- /* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- fprintf(stderr, "%d", piece+1);
- for (kind=0; kind<4; kind++) {
- fprintf(stderr, ".");
- snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
- ExpandPathName(appData.pixmapDirectory),
- piece <= (int) WhiteKing ? "" : "w",
- pieceBitmapNames[piece],
- ximkind[kind], ss);
- ximPieceBitmap[kind][piece] =
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
- loadXIM(ximPieceBitmap[kind][piece],
- ximtemp, buf,
- &(xpmPieceBitmap2[kind][piece]),
- &(ximMaskPm2[piece]));
- if(piece <= (int)WhiteKing)
- xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
- }
- fprintf(stderr," ");
- }
- /* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
- draw them with solid squares. */
- snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
- if (access(buf, 0) != 0) {
- useImageSqs = 0;
- } else {
- useImageSqs = 1;
- fprintf(stderr, _("light square "));
- ximLightSquare=
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
-
- loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
- fprintf(stderr, _("dark square "));
- snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
- ExpandPathName(appData.pixmapDirectory), ss);
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
- ximDarkSquare=
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
- loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
- xpmJailSquare = xpmLightSquare;
- }
- fprintf(stderr, _("Done.\n"));
- }
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
-}
-
-#if HAVE_LIBXPM
-void CreateXPMPieces()
-{
- int piece, kind, r;
- char buf[MSG_SIZ];
- u_int ss = squareSize;
- XpmAttributes attr;
- static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
- XpmColorSymbol symbols[4];
-
- /* The XSynchronize calls were copied from CreatePieces.
- Not sure if needed, but can't hurt */
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
-
- /* Setup translations so piece colors match square colors */
- symbols[0].name = "light_piece";
- symbols[0].value = appData.whitePieceColor;
- symbols[1].name = "dark_piece";
- symbols[1].value = appData.blackPieceColor;
- symbols[2].name = "light_square";
- symbols[2].value = appData.lightSquareColor;
- symbols[3].name = "dark_square";
- symbols[3].value = appData.darkSquareColor;
-
- attr.valuemask = XpmColorSymbols;
- attr.colorsymbols = symbols;
- attr.numsymbols = 4;
-
- if (appData.monoMode) {
- DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
- 0, 2);
- ExitEvent(2);
- }
- if (strlen(appData.pixmapDirectory) == 0) {
- XpmPieces* pieces = builtInXpms;
- useImages = 1;
- /* Load pieces */
- while (pieces->size != squareSize && pieces->size) pieces++;
- if (!pieces->size) {
- fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
- exit(1);
- }
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- for (kind=0; kind<4; kind++) {
-
- if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
- pieces->xpm[piece][kind],
- &(xpmPieceBitmap2[kind][piece]),
- NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
- r, buf);
- exit(1);
- }
- if(piece <= (int) WhiteKing)
- xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
- }
- }
- useImageSqs = 0;
- xpmJailSquare = xpmLightSquare;
- } else {
- useImages = 1;
-
- fprintf(stderr, _("\nLoading XPMs...\n"));
-
- /* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- fprintf(stderr, "%d ", piece+1);
- for (kind=0; kind<4; kind++) {
- snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
- ExpandPathName(appData.pixmapDirectory),
- piece > (int) WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- xpmkind[kind], ss);
- if (appData.debugMode) {
- fprintf(stderr, _("(File:%s:) "), buf);
- }
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &(xpmPieceBitmap2[kind][piece]),
- NULL, &attr)) != 0) {
- if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
- // [HGM] missing: read of unorthodox piece failed; substitute King.
- snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
- ExpandPathName(appData.pixmapDirectory),
- xpmkind[kind], ss);
- if (appData.debugMode) {
- fprintf(stderr, _("(Replace by File:%s:) "), buf);
- }
- r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &(xpmPieceBitmap2[kind][piece]),
- NULL, &attr);
- }
- if (r != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
- r, buf);
- exit(1);
- }
- }
- if(piece <= (int) WhiteKing)
- xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
- }
- }
- /* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
- draw them with solid squares. */
- fprintf(stderr, _("light square "));
- snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
- if (access(buf, 0) != 0) {
- useImageSqs = 0;
- } else {
- useImageSqs = 1;
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
-
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &xpmLightSquare, NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
- exit(1);
- }
- fprintf(stderr, _("dark square "));
- snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
- ExpandPathName(appData.pixmapDirectory), ss);
- if (appData.debugMode) {
- fprintf(stderr, _("(File:%s:) "), buf);
- }
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &xpmDarkSquare, NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
- exit(1);
- }
- }
- xpmJailSquare = xpmLightSquare;
- fprintf(stderr, _("Done.\n"));
- }
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
+ /* GCs are not needed anymore for GTK just left them in here for the moment, since there is a lot of X-code still around that's wants them*/
+ return;
}
-#endif /* HAVE_LIBXPM */
-
-#if HAVE_LIBXPM
-/* No built-in bitmaps */
-void CreatePieces()
-{
- int piece, kind;
- char buf[MSG_SIZ];
- u_int ss = squareSize;
-
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt
- buffering bug */
-
- for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
- }
- }
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
-}
-#else
-/* With built-in bitmaps */
void CreatePieces()
{
- BuiltInBits* bib = builtInBits;
- int piece, kind;
- char buf[MSG_SIZ];
- u_int ss = squareSize;
-
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt
- buffering bug */
-
- while (bib->squareSize != ss && bib->squareSize != 0) bib++;
-
- for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf,
- bib->bits[kind][piece], ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
- }
- }
+ int i;
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
-}
-#endif
-
-void ReadBitmap(pm, name, bits, wreq, hreq)
- Pixmap *pm;
- String name;
- unsigned char bits[];
- u_int wreq, hreq;
-{
- int x_hot, y_hot;
- u_int w, h;
- int errcode;
- char msg[MSG_SIZ], fullname[MSG_SIZ];
-
- if (*appData.bitmapDirectory != NULLCHAR) {
- strcpy(fullname, appData.bitmapDirectory);
- strcat(fullname, "/");
- strcat(fullname, name);
- errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
- &w, &h, pm, &x_hot, &y_hot);
- fprintf(stderr, "load %s\n", name);
- if (errcode != BitmapSuccess) {
- switch (errcode) {
- case BitmapOpenFailed:
- snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
- break;
- case BitmapFileInvalid:
- snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
- break;
- case BitmapNoMemory:
- snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
- fullname);
- break;
- default:
- snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
- errcode, fullname);
- break;
- }
- fprintf(stderr, _("%s: %s...using built-in\n"),
- programName, msg);
- } else if (w != wreq || h != hreq) {
- fprintf(stderr,
- _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
- programName, fullname, w, h, wreq, hreq);
- } else {
- return;
+ /* free if used
+ for(i=0;i<MAXPIECES;i++)
+ {
+ if(SVGpieces[i])
+ {
+ g_free(SVGpieces[i]);
+ SVGpieces[i]=NULL;
}
}
- if (bits != NULL) {
- *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
- wreq, hreq);
- }
-}
+ */
-void CreateGrid()
-{
- int i, j;
+ /* reload these */
+ SVGLightSquare = load_pixbuf("svg/LightSquare.svg",squareSize);
+ SVGDarkSquare = load_pixbuf("svg/DarkSquare.svg",squareSize);
+ SVGNeutralSquare = load_pixbuf("svg/NeutralSquare.svg",squareSize);
- if (lineGap == 0) return;
- /* [HR] Split this into 2 loops for non-square boards. */
+ /* get some defaults going */
+ for(i=WhitePawn; i<DemotePiece+1; i++)
+ SVGpieces[i] = load_pixbuf("svg/NeutralSquare.svg",squareSize);
+
+ SVGpieces[WhitePawn] = load_pixbuf("svg/WhitePawn.svg",squareSize);
+ SVGpieces[WhiteKnight] = load_pixbuf("svg/WhiteKnight.svg",squareSize);
+ SVGpieces[WhiteBishop] = load_pixbuf("svg/WhiteBishop.svg",squareSize);
+ SVGpieces[WhiteRook] = load_pixbuf("svg/WhiteRook.svg",squareSize);
+ SVGpieces[WhiteQueen] = load_pixbuf("svg/WhiteQueen.svg",squareSize);
+ SVGpieces[WhiteKing] = load_pixbuf("svg/WhiteKing.svg",squareSize);
- for (i = 0; i < BOARD_HEIGHT + 1; i++) {
- gridSegments[i].x1 = 0;
- gridSegments[i].x2 =
- lineGap + BOARD_WIDTH * (squareSize + lineGap);
- gridSegments[i].y1 = gridSegments[i].y2
- = lineGap / 2 + (i * (squareSize + lineGap));
- }
+ SVGpieces[BlackPawn] = load_pixbuf("svg/BlackPawn.svg",squareSize);
+ SVGpieces[BlackKnight] = load_pixbuf("svg/BlackKnight.svg",squareSize);
+ SVGpieces[BlackBishop] = load_pixbuf("svg/BlackBishop.svg",squareSize);
+ SVGpieces[BlackRook] = load_pixbuf("svg/BlackRook.svg",squareSize);
+ SVGpieces[BlackQueen] = load_pixbuf("svg/BlackQueen.svg",squareSize);
+ SVGpieces[BlackKing] = load_pixbuf("svg/BlackKing.svg",squareSize);
- for (j = 0; j < BOARD_WIDTH + 1; j++) {
- gridSegments[j + i].y1 = 0;
- gridSegments[j + i].y2 =
- lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- gridSegments[j + i].x1 = gridSegments[j + i].x2
- = lineGap / 2 + (j * (squareSize + lineGap));
- }
+ return;
}
+
static void MenuBarSelect(w, addr, index)
Widget w;
caddr_t addr;
return menuBar;
}
-Widget CreateButtonBar(mi)
- 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(name, color)
Arg args[16];
ChessSquare selection;
- whitePieceMenu = CreatePieceMenu("menuW", 0);
- blackPieceMenu = CreatePieceMenu("menuB", 1);
-
- 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);
- }
- }
+// whitePieceMenu = CreatePieceMenu("menuW", 0);
+// blackPieceMenu = CreatePieceMenu("menuB", 1);
+//
+// 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);
+// }
+// }
}
void SetupDropMenu()
Cardinal *num_params;
{
String whichMenu;
+
+ if (event->type != ButtonRelease) UnLoadPV(); // [HGM] pv
if (event->type != ButtonPress) return;
if (errorUp) ErrorPopDown();
switch (gameMode) {
case IcsExamining:
whichMenu = params[0];
break;
+ case IcsObserving:
+ if(!appData.icsEngineAnalyze) return;
case IcsPlayingWhite:
case IcsPlayingBlack:
- case EditGame:
+ if(!appData.zippyPlay) goto noZip;
+ case AnalyzeMode:
+ case AnalyzeFile:
case MachinePlaysWhite:
case MachinePlaysBlack:
- if (appData.testLegality &&
+ case TwoMachinesPlay: // [HGM] pv: use for showing PV
+ if (!appData.dropMenu) {
+ LoadPV(event->xbutton.x, event->xbutton.y);
+ return;
+ }
+ if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
+ gameMode == AnalyzeFile || gameMode == IcsObserving) return;
+ case EditGame:
+ noZip:
+ if (!appData.dropMenu || appData.testLegality &&
gameInfo.variant != VariantBughouse &&
gameInfo.variant != VariantCrazyhouse) return;
SetupDropMenu();
DropMenuEvent(piece, pmFromX, pmFromY);
}
-void WhiteClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetWhiteToPlayEvent();
- } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {
- CallFlagEvent();
- }
-}
-
-void BlackClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetBlackToPlayEvent();
- } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {
- CallFlagEvent();
- }
-}
-
-
/*
* If the user selects on a border boundary, return -1; if off the board,
* return -2. Otherwise map the event coordinate to the square.
TimeDelay(msec);
}
-static void drawHighlight(file, rank, gc)
- int file, rank;
- GC gc;
+static void drawHighlight(file, rank, line_type)
+ int file, rank, line_type;
{
int x, y;
+ cairo_t *cr;
if (lineGap == 0 || appData.blindfold) return;
- if (flipView) {
+ if (flipView)
+ {
x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
(squareSize + lineGap);
y = lineGap/2 + rank * (squareSize + lineGap);
- } else {
+ }
+ else
+ {
x = lineGap/2 + file * (squareSize + lineGap);
y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
(squareSize + lineGap);
- }
+ }
+
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
+
+ /* draw the highlight */
+ cairo_move_to (cr, x, y);
+ cairo_rel_line_to (cr, 0,squareSize+lineGap);
+ cairo_rel_line_to (cr, squareSize+lineGap,0);
+ cairo_rel_line_to (cr, 0,-squareSize-lineGap);
+ cairo_close_path (cr);
- XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
- squareSize+lineGap, squareSize+lineGap);
+ cairo_set_line_width (cr, lineGap);
+ switch(line_type)
+ {
+ /* TODO: use appdata colors */
+ case LINE_TYPE_HIGHLIGHT:
+ cairo_set_source_rgba (cr, 1, 1, 0, 1.0);
+ break;
+ case LINE_TYPE_PRE:
+ cairo_set_source_rgba (cr, 1, 0, 0, 1.0);
+ break;
+ case LINE_TYPE_NORMAL:
+ default:
+ cairo_set_source_rgba (cr, 0, 1, 0, 1.0);
+ }
+
+ cairo_stroke (cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+
+ return;
}
int hi1X = -1, hi1Y = -1, hi2X = -1, hi2Y = -1;
SetHighlights(fromX, fromY, toX, toY)
int fromX, fromY, toX, toY;
{
- if (hi1X != fromX || hi1Y != fromY) {
- if (hi1X >= 0 && hi1Y >= 0) {
- drawHighlight(hi1X, hi1Y, lineGC);
- }
- if (fromX >= 0 && fromY >= 0) {
- drawHighlight(fromX, fromY, highlineGC);
- }
- }
- if (hi2X != toX || hi2Y != toY) {
- if (hi2X >= 0 && hi2Y >= 0) {
- drawHighlight(hi2X, hi2Y, lineGC);
- }
- if (toX >= 0 && toY >= 0) {
- drawHighlight(toX, toY, highlineGC);
- }
- }
+ if (hi1X != fromX || hi1Y != fromY)
+ {
+ if (hi1X >= 0 && hi1Y >= 0)
+ {
+ drawHighlight(hi1X, hi1Y, LINE_TYPE_NORMAL);
+ }
+ if (fromX >= 0 && fromY >= 0)
+ {
+ drawHighlight(fromX, fromY, LINE_TYPE_HIGHLIGHT);
+ }
+ }
+ if (hi2X != toX || hi2Y != toY)
+ {
+ if (hi2X >= 0 && hi2Y >= 0)
+ {
+ drawHighlight(hi2X, hi2Y, LINE_TYPE_NORMAL);
+ }
+ if (toX >= 0 && toY >= 0)
+ {
+ drawHighlight(toX, toY, LINE_TYPE_HIGHLIGHT);
+ }
+ }
hi1X = fromX;
hi1Y = fromY;
hi2X = toX;
hi2Y = toY;
+
+ return;
}
void
SetPremoveHighlights(fromX, fromY, toX, toY)
int fromX, fromY, toX, toY;
{
- if (pm1X != fromX || pm1Y != fromY) {
- if (pm1X >= 0 && pm1Y >= 0) {
- drawHighlight(pm1X, pm1Y, lineGC);
- }
- if (fromX >= 0 && fromY >= 0) {
- drawHighlight(fromX, fromY, prelineGC);
- }
- }
- if (pm2X != toX || pm2Y != toY) {
- if (pm2X >= 0 && pm2Y >= 0) {
- drawHighlight(pm2X, pm2Y, lineGC);
- }
- if (toX >= 0 && toY >= 0) {
- drawHighlight(toX, toY, prelineGC);
- }
- }
+ if (pm1X != fromX || pm1Y != fromY)
+ {
+ if (pm1X >= 0 && pm1Y >= 0)
+ {
+ drawHighlight(pm1X, pm1Y, LINE_TYPE_NORMAL);
+ }
+ if (fromX >= 0 && fromY >= 0)
+ {
+ drawHighlight(fromX, fromY, LINE_TYPE_PRE);
+ }
+ }
+ if (pm2X != toX || pm2Y != toY)
+ {
+ if (pm2X >= 0 && pm2Y >= 0)
+ {
+ drawHighlight(pm2X, pm2Y, LINE_TYPE_NORMAL);
+ }
+ if (toX >= 0 && toY >= 0)
+ {
+ drawHighlight(toX, toY, LINE_TYPE_PRE);
+ }
+ }
+
pm1X = fromX;
pm1Y = fromY;
pm2X = toX;
pm2Y = toY;
+
+ return;
}
void
ChessSquare piece;
Drawable dest;
{
- if (useImages && useImageSqs) {
- Pixmap pm;
- switch (color) {
- case 1: /* light */
- pm = xpmLightSquare;
- break;
- case 0: /* dark */
- pm = xpmDarkSquare;
- break;
- case 2: /* neutral */
- default:
- pm = xpmJailSquare;
- break;
- }
- XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- } else {
- GC gc;
- switch (color) {
- case 1: /* light */
- gc = lightSquareGC;
- break;
- case 0: /* dark */
- gc = darkSquareGC;
- break;
- case 2: /* neutral */
- default:
- gc = jailSquareGC;
- break;
- }
- XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);
- }
-}
+ GdkPixbuf *pb;
-/*
- I split out the routines to draw a piece so that I could
- make a generic flash routine.
-*/
-static void monoDrawPiece_1bit(piece, square_color, x, y, dest)
- ChessSquare piece;
- int square_color, x, y;
- Drawable dest;
-{
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToOutline(piece)
- : *pieceToSolid(piece),
- dest, bwPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- break;
- case 0: /* dark */
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToSolid(piece)
- : *pieceToOutline(piece),
- dest, wbPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- break;
- }
-}
-
-static void monoDrawPiece(piece, square_color, x, y, dest)
- ChessSquare piece;
- int square_color, x, y;
- Drawable dest;
-{
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToOutline(piece)
- : *pieceToSolid(piece),
- dest, bwPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 0: /* dark */
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToSolid(piece)
- : *pieceToOutline(piece),
- dest, wbPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- }
-}
-
-static void colorDrawPiece(piece, square_color, x, y, dest)
- ChessSquare piece;
- int square_color, x, y;
- Drawable dest;
-{
- if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
- switch (square_color) {
- case 1: /* light */
- XCopyPlane(xDisplay, *pieceToSolid(piece),
- dest, (int) piece < (int) BlackPawn
- ? wlPieceGC : blPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 0: /* dark */
- XCopyPlane(xDisplay, *pieceToSolid(piece),
- dest, (int) piece < (int) BlackPawn
- ? wdPieceGC : bdPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 2: /* neutral */
- default:
- XCopyPlane(xDisplay, *pieceToSolid(piece),
- dest, (int) piece < (int) BlackPawn
- ? wjPieceGC : bjPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- }
+ switch (color)
+ {
+ case 0: /* dark */
+ pb = SVGDarkSquare;
+ break;
+ case 1: /* light */
+ pb = SVGLightSquare;
+ break;
+ case 2: /* neutral */
+ default:
+ pb = SVGNeutralSquare;
+ break;
+ }
+ gdk_draw_pixbuf(GDK_WINDOW(GUI_Board->window),NULL,pb,0,0,x,y,-1,-1, GDK_RGB_DITHER_NORMAL, 0, 0);
+ return;
}
-static void colorDrawPieceImage(piece, square_color, x, y, dest)
+static void DrawPiece(piece, square_color, x, y, dest)
ChessSquare piece;
int square_color, x, y;
Drawable dest;
{
- int kind;
-
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- if ((int)piece < (int) BlackPawn) {
- kind = 0;
- } else {
- kind = 2;
- piece -= BlackPawn;
- }
- break;
- case 0: /* dark */
- if ((int)piece < (int) BlackPawn) {
- kind = 1;
- } else {
- kind = 3;
- piece -= BlackPawn;
- }
- break;
- }
- XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
- dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
-}
-
-typedef void (*DrawFunc)();
+ /* redraw background, since piece might be transparent in some areas */
+ BlankSquare(x,y,square_color,piece,dest);
-DrawFunc ChooseDrawFunc()
-{
- if (appData.monoMode) {
- if (DefaultDepth(xDisplay, xScreen) == 1) {
- return monoDrawPiece_1bit;
- } else {
- return monoDrawPiece;
- }
- } else {
- if (useImages)
- return colorDrawPieceImage;
- else
- return colorDrawPiece;
- }
+ /* draw piece */
+ gdk_draw_pixbuf(GDK_WINDOW(GUI_Board->window),NULL,
+ GDK_PIXBUF(SVGpieces[piece]),0,0,x,y,-1,-1,
+ GDK_RGB_DITHER_NORMAL, 0, 0);
+ return ;
}
/* [HR] determine square color depending on chess variant. */
int row, column, do_flash;
ChessSquare piece;
{
- int square_color, x, y, direction, font_ascent, font_descent;
+ int square_color, x, y;
int i;
char string[2];
- XCharStruct overall;
- DrawFunc drawfunc;
int flash_delay;
/* Calculate delay in milliseconds (2-delays per complete flash) */
flash_delay = 500 / appData.flashRate;
- if (flipView) {
+ /* calculate x and y coordinates from row and column */
+ if (flipView)
+ {
x = lineGap + ((BOARD_WIDTH-1)-column) *
(squareSize + lineGap);
y = lineGap + row * (squareSize + lineGap);
- } else {
+ }
+ else
+ {
x = lineGap + column * (squareSize + lineGap);
y = lineGap + ((BOARD_HEIGHT-1)-row) *
(squareSize + lineGap);
- }
+ }
square_color = SquareColor(row, column);
- if ( // [HGM] holdings: blank out area between board and holdings
- column == BOARD_LEFT-1 || column == BOARD_RGHT
- || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
- || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
- BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
-
- // [HGM] print piece counts next to holdings
- string[1] = NULLCHAR;
- if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
- string[0] = '0' + piece;
- XTextExtents(countFontStruct, string, 1, &direction,
- &font_ascent, &font_descent, &overall);
- if (appData.monoMode) {
- XDrawImageString(xDisplay, xBoardWindow, countGC,
- x + squareSize - overall.width - 2,
- y + font_ascent + 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, countGC,
- x + squareSize - overall.width - 2,
- y + font_ascent + 1, string, 1);
- }
- }
- if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
- string[0] = '0' + piece;
- XTextExtents(countFontStruct, string, 1, &direction,
- &font_ascent, &font_descent, &overall);
- if (appData.monoMode) {
- XDrawImageString(xDisplay, xBoardWindow, countGC,
- x + 2, y + font_ascent + 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, countGC,
- x + 2, y + font_ascent + 1, string, 1);
- }
- }
- } else {
- if (piece == EmptySquare || appData.blindfold) {
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- } else {
- drawfunc = ChooseDrawFunc();
- if (do_flash && appData.flashCount > 0) {
- for (i=0; i<appData.flashCount; ++i) {
-
- drawfunc(piece, square_color, x, y, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
-
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
- }
- }
- drawfunc(piece, square_color, x, y, xBoardWindow);
- }
- }
+ // [HGM] holdings: blank out area between board and holdings
+ if ( column == BOARD_LEFT-1 || column == BOARD_RGHT
+ || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
+ || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) )
+ {
+ BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
- string[1] = NULLCHAR;
- if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
- && column >= BOARD_LEFT && column < BOARD_RGHT) {
- string[0] = 'a' + column - BOARD_LEFT;
- XTextExtents(coordFontStruct, string, 1, &direction,
- &font_ascent, &font_descent, &overall);
- if (appData.monoMode) {
- XDrawImageString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
- y + squareSize - font_descent - 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
- y + squareSize - font_descent - 1, string, 1);
- }
- }
- if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
- string[0] = ONE + row;
- XTextExtents(coordFontStruct, string, 1, &direction,
- &font_ascent, &font_descent, &overall);
- if (appData.monoMode) {
- XDrawImageString(xDisplay, xBoardWindow, coordGC,
- x + 2, y + font_ascent + 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, coordGC,
- x + 2, y + font_ascent + 1, string, 1);
- }
- }
-}
+ // [HGM] print piece counts next to holdings
+ string[1] = NULLCHAR;
+ if(piece > 1)
+ {
+ cairo_text_extents_t extents;
+ cairo_t *cr;
+ int xpos, ypos;
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
-/* Why is this needed on some versions of X? */
-void EventProc(widget, unused, event)
- Widget widget;
- caddr_t unused;
- XEvent *event;
-{
- if (!XtIsRealized(widget))
- return;
+ string[0] = '0' + piece;
- switch (event->type) {
- case Expose:
- if (event->xexpose.count > 0) return; /* no clipping is done */
- XDrawPosition(widget, True, NULL);
- break;
- default:
- return;
- }
-}
-/* end why */
+ /* TODO this has to go into the font-selection */
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
-void DrawPosition(fullRedraw, board)
- /*Boolean*/int fullRedraw;
- Board board;
-{
- XDrawPosition(boardWidget, fullRedraw, board);
+ cairo_set_font_size (cr, 12.0);
+ cairo_text_extents (cr, string, &extents);
+
+ if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) )
+ {
+ xpos= x + squareSize - extents.width - 2;
+ ypos= y + extents.y_bearing + 1;
+ }
+ if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1)
+ {
+ xpos= x + 2;
+ ypos = y + extents.y_bearing + 1;
+ }
+
+ /* TODO mono mode? */
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 1.0, 1.0, 1);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+ }
+ }
+ else
+ {
+ /* square on the board */
+ if (piece == EmptySquare || appData.blindfold)
+ {
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ }
+ else
+ {
+ if (do_flash && appData.flashCount > 0)
+ {
+ for (i=0; i<appData.flashCount; ++i)
+ {
+
+ DrawPiece(piece, square_color, x, y, xBoardWindow);
+ do_flash_delay(flash_delay);
+
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ do_flash_delay(flash_delay);
+ }
+ }
+ DrawPiece(piece, square_color, x, y, xBoardWindow);
+ }
+ }
+
+ /* show coordinates if necessary */
+ if(appData.showCoords)
+ {
+ cairo_text_extents_t extents;
+ cairo_t *cr;
+ int xpos, ypos;
+
+ /* TODO this has to go into the font-selection */
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
+ cairo_set_font_size (cr, 12.0);
+
+ string[1] = NULLCHAR;
+
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
+
+ if (row == (flipView ? BOARD_HEIGHT-1 : 0) &&
+ column >= BOARD_LEFT && column < BOARD_RGHT)
+ {
+ string[0] = 'a' + column - BOARD_LEFT;
+ cairo_text_extents (cr, string, &extents);
+
+ xpos = x + squareSize - extents.width - 2;
+ ypos = y + squareSize - extents.height - extents.y_bearing - 1;
+
+ if (appData.monoMode)
+ { /*TODO*/
+ }
+ else
+ {
+ }
+
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 1.0, 0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+ }
+ if ( column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT))
+ {
+
+ string[0] = ONE + row;
+ cairo_text_extents (cr, string, &extents);
+
+ xpos = x + 2;
+ ypos = y + extents.height + 1;
+
+ if (appData.monoMode)
+ { /*TODO*/
+ }
+ else
+ {
+ }
+
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 0, 1.0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+
+ }
+ /* free memory */
+ cairo_destroy (cr);
+ }
+
+ return;
}
+
/* Returns 1 if there are "too many" differences between b1 and b2
(i.e. more than 1 move was made) */
static int too_many_diffs(b1, b2)
return 0;
}
-static int damage[BOARD_SIZE][BOARD_SIZE];
+static int damage[BOARD_RANKS][BOARD_FILES];
/*
* event handler for redrawing the board
*/
-void XDrawPosition(w, repaint, board)
- Widget w;
+void DrawPosition( repaint, board)
/*Boolean*/int repaint;
- Board board;
+ Board board;
{
- int i, j, do_flash;
- static int lastFlipView = 0;
- static int lastBoardValid = 0;
- static Board lastBoard;
- Arg args[16];
- int rrow, rcol;
+ int i, j, do_flash;
+ static int lastFlipView = 0;
+ static int lastBoardValid = 0;
+ static Board lastBoard;
+ int rrow, rcol;
- if (board == NULL) {
- if (!lastBoardValid) return;
- board = lastBoard;
- }
- if (!lastBoardValid || lastFlipView != flipView) {
- XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
- args, 1);
- }
-
- /*
- * It would be simpler to clear the window with XClearWindow()
- * but this causes a very distracting flicker.
- */
+ if (board == NULL) {
+ if (!lastBoardValid) return;
+ board = lastBoard;
+ }
+ if (!lastBoardValid || lastFlipView != flipView) {
+ // XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
+ // XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
+ // args, 1);
+ }
- if (!repaint && lastBoardValid && lastFlipView == flipView) {
+ /*
+ * It would be simpler to clear the window with XClearWindow()
+ * but this causes a very distracting flicker.
+ */
- /* If too much changes (begin observing new game, etc.), don't
- do flashing */
- do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
+ if (!repaint && lastBoardValid && lastFlipView == flipView)
+ {
+ /* If too much changes (begin observing new game, etc.), don't
+ do flashing */
+ do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
- /* Special check for castling so we don't flash both the king
- and the rook (just flash the king). */
- if (do_flash) {
- if (check_castle_draw(board, lastBoard, &rrow, &rcol)) {
- /* Draw rook with NO flashing. King will be drawn flashing later */
- DrawSquare(rrow, rcol, board[rrow][rcol], 0);
- lastBoard[rrow][rcol] = board[rrow][rcol];
+ /* Special check for castling so we don't flash both the king
+ and the rook (just flash the king). */
+ if (do_flash)
+ {
+ if (check_castle_draw(board, lastBoard, &rrow, &rcol))
+ {
+ /* Draw rook with NO flashing. King will be drawn flashing later */
+ DrawSquare(rrow, rcol, board[rrow][rcol], 0);
+ lastBoard[rrow][rcol] = board[rrow][rcol];
}
}
- /* First pass -- Draw (newly) empty squares and repair damage.
- This prevents you from having a piece show up twice while it
- is flashing on its new square */
- for (i = 0; i < BOARD_HEIGHT; i++)
- for (j = 0; j < BOARD_WIDTH; j++)
- if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
- || damage[i][j]) {
- DrawSquare(i, j, board[i][j], 0);
- damage[i][j] = False;
- }
-
- /* Second pass -- Draw piece(s) in new position and flash them */
- for (i = 0; i < BOARD_HEIGHT; i++)
- for (j = 0; j < BOARD_WIDTH; j++)
- if (board[i][j] != lastBoard[i][j]) {
- DrawSquare(i, j, board[i][j], do_flash);
- }
- } else {
- if (lineGap > 0)
- XDrawSegments(xDisplay, xBoardWindow, lineGC,
- gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
-
- for (i = 0; i < BOARD_HEIGHT; i++)
- for (j = 0; j < BOARD_WIDTH; j++) {
+ /* First pass -- Draw (newly) empty squares and repair damage.
+ This prevents you from having a piece show up twice while it
+ is flashing on its new square */
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
+ || damage[i][j])
+ {
DrawSquare(i, j, board[i][j], 0);
damage[i][j] = False;
- }
- }
-
- CopyBoard(lastBoard, board);
- lastBoardValid = 1;
- lastFlipView = flipView;
+ }
- /* Draw highlights */
- if (pm1X >= 0 && pm1Y >= 0) {
- drawHighlight(pm1X, pm1Y, prelineGC);
- }
- if (pm2X >= 0 && pm2Y >= 0) {
- drawHighlight(pm2X, pm2Y, prelineGC);
- }
- if (hi1X >= 0 && hi1Y >= 0) {
- drawHighlight(hi1X, hi1Y, highlineGC);
- }
- if (hi2X >= 0 && hi2Y >= 0) {
- drawHighlight(hi2X, hi2Y, highlineGC);
+ /* Second pass -- Draw piece(s) in new position and flash them */
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ if (board[i][j] != lastBoard[i][j])
+ {
+ DrawSquare(i, j, board[i][j], do_flash);
+ }
}
+ else
+ {
+ /* redraw Grid */
+ if (lineGap > 0)
+ {
+ int x1,x2,y1,y2;
+ cairo_t *cr;
- /* If piece being dragged around board, must redraw that too */
- DrawDragPiece();
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
- XSync(xDisplay, False);
-}
+ cairo_set_line_width (cr, lineGap);
+ /* TODO: use appdata colors */
+ cairo_set_source_rgba (cr, 0, 1, 0, 1.0);
-/*
- * event handler for redrawing the board
- */
-void DrawPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- XDrawPosition(w, True, NULL);
-}
+ cairo_stroke (cr);
+ for (i = 0; i < BOARD_HEIGHT + 1; i++)
+ {
+ x1 = 0;
+ x2 = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ y1 = y2 = lineGap / 2 + (i * (squareSize + lineGap));
-/*
- * 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(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- int x, y;
- Boolean saveAnimate;
- static int second = 0, promotionChoice = 0;
- ChessMove moveType;
-
- if (w != boardWidget || errorExitStatus != -1) return;
-
- x = EventToSquare(event->xbutton.x, BOARD_WIDTH);
- y = EventToSquare(event->xbutton.y, BOARD_HEIGHT);
- if (!flipView && y >= 0) {
- y = BOARD_HEIGHT - 1 - y;
- }
- if (flipView && x >= 0) {
- x = BOARD_WIDTH - 1 - x;
- }
-
- if(promotionChoice) { // we are waiting for a click to indicate promotion piece
- if(event->type == ButtonRelease) return; // ignore upclick of click-click destination
- promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
- if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
- if(gameInfo.holdingsWidth &&
- (WhiteOnMove(currentMove)
- ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
- : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
- // click in right holdings, for determining promotion piece
- ChessSquare p = boards[currentMove][y][x];
- if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
- if(p != EmptySquare) {
- FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
- fromX = fromY = -1;
- return;
+ cairo_move_to (cr, x1, y1);
+ cairo_rel_line_to (cr, x2,0);
+ cairo_stroke (cr);
}
- }
- DrawPosition(FALSE, boards[currentMove]);
- return;
- }
- if (event->type == ButtonPress) ErrorPopDown();
-
- if (promotionUp) {
- if (event->type == ButtonPress) {
- XtPopdown(promotionShell);
- XtDestroyWidget(promotionShell);
- promotionUp = False;
- ClearHighlights();
- fromX = fromY = -1;
- } else {
- return;
- }
- }
- /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
- if(event->type == ButtonPress
- && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
- || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
- || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
- return;
+ for (j = 0; j < BOARD_WIDTH + 1; j++)
+ {
+ y1 = 0;
+ y2 = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ x1 = x2 = lineGap / 2 + (j * (squareSize + lineGap));
- if (fromX == -1) {
- if (event->type == ButtonPress) {
- /* First square, prepare to drag */
- if (OKToStartUserMove(x, y)) {
- fromX = x;
- fromY = y;
- second = 0;
- DragPieceBegin(event->xbutton.x, event->xbutton.y);
- if (appData.highlightDragging) {
- SetHighlights(x, y, -1, -1);
- }
+ cairo_move_to (cr, x1, y1);
+ cairo_rel_line_to (cr, 0, y2);
+ cairo_stroke (cr);
}
- }
- return;
- }
- /* fromX != -1 */
- if (event->type == ButtonRelease && x == fromX && y == fromY) {
- /* Click on single square in stead of drag-drop */
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- if (appData.animateDragging) {
- /* Undo animation damage if any */
- DrawPosition(FALSE, NULL);
+ /* free memory */
+ cairo_destroy (cr);
}
- if (second) {
- /* Second up/down in same square; just abort move */
- second = 0;
- fromX = fromY = -1;
- ClearHighlights();
- gotPremove = 0;
- ClearPremoveHighlights();
- } else {
- /* First upclick in same square; start click-click mode */
- SetHighlights(x, y, -1, -1);
- }
- return;
- }
- moveType = UserMoveTest(fromX, fromY, x, y, NULLCHAR, event->type == ButtonRelease);
-
- if (moveType == Comment) { // kludge for indicating capture-own on Press
- /* Clicked again on same color piece -- changed his mind */
- /* note that re-clicking same square always hits same color piece */
- second = (x == fromX && y == fromY);
- if (appData.highlightDragging) {
- SetHighlights(x, y, -1, -1);
- } else {
- ClearHighlights();
- }
- if (OKToStartUserMove(x, y)) {
- fromX = x;
- fromY = y;
- DragPieceBegin(event->xbutton.x, event->xbutton.y);
- }
- return;
+ /* draw pieces */
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ {
+ DrawSquare(i, j, board[i][j], 0);
+ damage[i][j] = False;
+ }
}
- if(moveType == AmbiguousMove) { // kludge to indicate edit-position move
- fromX = fromY = -1;
- ClearHighlights();
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- DrawPosition(FALSE, boards[currentMove]);
- return;
- }
+ CopyBoard(lastBoard, board);
+ lastBoardValid = 1;
+ lastFlipView = flipView;
- /* Complete move; (x,y) is now different from (fromX, fromY) on both Press and Release */
- toX = x;
- toY = y;
- saveAnimate = appData.animate;
- if (event->type == ButtonPress) {
- /* Finish clickclick move */
- if (appData.animate || appData.highlightLastMove) {
- SetHighlights(fromX, fromY, toX, toY);
- } else {
- ClearHighlights();
- }
- } else {
- /* Finish drag move */
- if (appData.highlightLastMove) {
- SetHighlights(fromX, fromY, toX, toY);
- } else {
- ClearHighlights();
- }
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- /* Don't animate move and drag both */
- appData.animate = FALSE;
+ /* Draw highlights */
+ if (pm1X >= 0 && pm1Y >= 0)
+ {
+ drawHighlight(pm1X, pm1Y, LINE_TYPE_PRE);
}
- if (moveType == WhitePromotionKnight || moveType == BlackPromotionKnight ||
- (moveType == WhitePromotionQueen || moveType == BlackPromotionQueen) &&
- appData.alwaysPromoteToQueen) { // promotion, but no choice
- FinishMove(moveType, fromX, fromY, toX, toY, 'q');
- } else
- if (moveType == WhitePromotionQueen || moveType == BlackPromotionQueen ) {
- SetHighlights(fromX, fromY, toX, toY);
- if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
- // [HGM] super: promotion to captured piece selected from holdings
- ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
- promotionChoice = TRUE;
- // kludge follows to temporarily execute move on display, without promoting yet
- boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
- boards[currentMove][toY][toX] = p;
- DrawPosition(FALSE, boards[currentMove]);
- boards[currentMove][fromY][fromX] = p; // take back, but display stays
- boards[currentMove][toY][toX] = q;
- DisplayMessage("Click in holdings to choose piece", "");
- return;
- }
- PromotionPopUp();
- goto skipClearingFrom; // the skipped stuff is done asynchronously by PromotionCallback
- } else
- if(moveType != ImpossibleMove) { // valid move, but no promotion
- FinishMove(moveType, fromX, fromY, toX, toY, NULLCHAR);
- } else { // invalid move; could have set premove
- ClearHighlights();
+ if (pm2X >= 0 && pm2Y >= 0)
+ {
+ drawHighlight(pm2X, pm2Y, LINE_TYPE_PRE);
+ }
+ if (hi1X >= 0 && hi1Y >= 0)
+ {
+ drawHighlight(hi1X, hi1Y, LINE_TYPE_HIGHLIGHT);
}
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
- fromX = fromY = -1;
-skipClearingFrom:
- appData.animate = saveAnimate;
- if (appData.animate || appData.animateDragging) {
- /* Undo animation damage if needed */
- DrawPosition(FALSE, NULL);
+ if (hi2X >= 0 && hi2Y >= 0)
+ {
+ drawHighlight(hi2X, hi2Y, LINE_TYPE_HIGHLIGHT);
}
+
+ /* If piece being dragged around board, must redraw that too */
+ DrawDragPiece();
+
+ return;
}
void AnimateUserMove (Widget w, XEvent * event,
DragPieceMove(event->xmotion.x, event->xmotion.y);
}
+void HandlePV (Widget w, XEvent * event,
+ String * params, Cardinal * nParams)
+{ // [HGM] pv: walk PV
+ MovePV(event->xmotion.x, event->xmotion.y, lineGap + BOARD_HEIGHT * (squareSize + lineGap));
+}
+
Widget CommentCreate(name, text, mutable, callback, lines)
char *name, *text;
int /*Boolean*/ mutable;
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
#if TOPLEVEL
- shell =
- XtCreatePopupShell(name, topLevelShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, topLevelShellWidgetClass,
+// shellWidget, args, j);
#else
- shell =
- XtCreatePopupShell(name, transientShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, transientShellWidgetClass,
+// shellWidget, args, j);
#endif
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, shell,
commentH = pw_height + (lines - 1) * ew_height;
commentW = bw_width - 16;
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
#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(shellWidget,
- (bw_width - commentW) / 2, 0 - commentH / 2,
- &commentX, &commentY);
+// XtTranslateCoords(shellWidget,
+// (bw_width - commentW) / 2, 0 - commentH / 2,
+// &commentX, &commentY);
#else /*!NOTDEF*/
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
- RootWindowOfScreen(XtScreen(shellWidget)),
- (bw_width - commentW) / 2, 0 - commentH / 2,
- &xx, &yy, &junk);
+// XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
+// RootWindowOfScreen(XtScreen(shellWidget)),
+// (bw_width - commentW) / 2, 0 - commentH / 2,
+// &xx, &yy, &junk);
commentX = xx;
commentY = yy;
#endif /*!NOTDEF*/
if (commentY < 0) commentY = 0; /*avoid positioning top offscreen*/
}
+
+ if(wpComment.width > 0) {
+ commentX = wpComment.x;
+ commentY = wpComment.y;
+ commentW = wpComment.width;
+ commentH = wpComment.height;
+ }
+
j = 0;
XtSetArg(args[j], XtNheight, commentH); j++;
XtSetArg(args[j], XtNwidth, commentW); j++;
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
#if TOPLEVEL
- shell =
- XtCreatePopupShell(name, topLevelShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, topLevelShellWidgetClass,
+// shellWidget, args, j);
#else
- shell =
- XtCreatePopupShell(name, transientShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, transientShellWidgetClass,
+// shellWidget, args, j);
#endif
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, shell,
h = pw_height + (lines - 1) * ew_height;
w = bw_width - 16;
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
#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(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);
+// XtTranslateCoords(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);
#else /*!NOTDEF*/
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
- RootWindowOfScreen(XtScreen(shellWidget)),
- (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);
+// XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
+// RootWindowOfScreen(XtScreen(shellWidget)),
+// (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);
#endif /*!NOTDEF*/
x = xx;
y = yy;
editShell =
CommentCreate(title, text, True, EditCommentCallback, 4);
XtRealizeWidget(editShell);
- CatchDeleteWindow(editShell, "EditCommentPopDown");
+ // CatchDeleteWindow(editShell, "EditCommentPopDown");
} else {
edit = XtNameToWidget(editShell, "*form.text");
j = 0;
edit = XtNameToWidget(ICSInputShell, "*form.text");
XtOverrideTranslations(edit, tr);
XtRealizeWidget(ICSInputShell);
- CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
+ // CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
} else {
edit = XtNameToWidget(ICSInputShell, "*form.text");
commentShell =
CommentCreate(title, text, False, CommentCallback, 4);
XtRealizeWidget(commentShell);
- CatchDeleteWindow(commentShell, "CommentPopDown");
+ // CatchDeleteWindow(commentShell, "CommentPopDown");
} else {
edit = XtNameToWidget(commentShell, "*form.text");
j = 0;
}
XtPopup(commentShell, XtGrabNone);
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
commentUp = True;
}
XtSetArg(args[j], XtNheight, &commentH); j++;
XtGetValues(commentShell, args, j);
XtPopdown(commentShell);
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
commentUp = False;
}
-void FileNamePopUp(label, def, proc, openMode)
- char *label;
- char *def;
- FileProc proc;
- char *openMode;
-{
- Arg args[16];
- Widget popup, layout, dialog, edit;
- Window root, child;
- int x, y, i;
- int win_x, win_y;
- unsigned int mask;
-
- fileProc = proc; /* I can't see a way not */
- fileOpenMode = openMode; /* to use globals here */
-
- i = 0;
- XtSetArg(args[i], XtNresizable, True); i++;
- XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
- XtSetArg(args[i], XtNtitle, XtNewString(_("File name prompt"))); i++;
- fileNameShell = popup =
- XtCreatePopupShell("File name prompt", transientShellWidgetClass,
- shellWidget, args, i);
-
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,
- layoutArgs, XtNumber(layoutArgs));
-
- i = 0;
- XtSetArg(args[i], XtNlabel, label); i++;
- XtSetArg(args[i], XtNvalue, def); i++;
- XtSetArg(args[i], XtNborderWidth, 0); i++;
- dialog = XtCreateManagedWidget("fileName", dialogWidgetClass,
- layout, args, i);
-
- XawDialogAddButton(dialog, _("ok"), FileNameCallback, (XtPointer) dialog);
- XawDialogAddButton(dialog, _("cancel"), FileNameCallback,
- (XtPointer) dialog);
-
- XtRealizeWidget(popup);
- CatchDeleteWindow(popup, "FileNamePopDown");
-
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,
- &x, &y, &win_x, &win_y, &mask);
-
- XtSetArg(args[0], XtNx, x - 10);
- XtSetArg(args[1], XtNy, y - 30);
- XtSetValues(popup, args, 2);
-
- XtPopup(popup, XtGrabExclusive);
- filenameUp = True;
-
- edit = XtNameToWidget(dialog, "*value");
- XtSetKeyboardFocus(popup, edit);
-}
-
-void FileNamePopDown()
-{
- if (!filenameUp) return;
- XtPopdown(fileNameShell);
- XtDestroyWidget(fileNameShell);
- filenameUp = False;
- ModeHighlight();
-}
-
-void FileNameCallback(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
-{
- String name;
- Arg args[16];
-
- XtSetArg(args[0], XtNlabel, &name);
- XtGetValues(w, args, 1);
-
- if (strcmp(name, _("cancel")) == 0) {
- FileNamePopDown();
- return;
- }
-
- FileNameAction(w, NULL, NULL, NULL);
-}
-
-void FileNameAction(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- String name;
- FILE *f;
- char *p, *fullname;
- int index;
-
- name = XawDialogGetValueString(w = XtParent(w));
-
- if ((name != NULL) && (*name != NULLCHAR)) {
- strcpy(buf, name);
- XtPopdown(w = XtParent(XtParent(w)));
- XtDestroyWidget(w);
- filenameUp = False;
-
- p = strrchr(buf, ' ');
- if (p == NULL) {
- index = 0;
- } else {
- *p++ = NULLCHAR;
- index = atoi(p);
- }
- fullname = ExpandPathName(buf);
- if (!fullname) {
- ErrorPopUp(_("Error"), _("Can't open file"), FALSE);
- }
- else {
- f = fopen(fullname, fileOpenMode);
- if (f == NULL) {
- DisplayError(_("Failed to open file"), errno);
- } else {
- (void) (*fileProc)(f, index, buf);
- }
- }
- ModeHighlight();
- return;
- }
-
- XtPopdown(w = XtParent(XtParent(w)));
- XtDestroyWidget(w);
- filenameUp = False;
- ModeHighlight();
-}
-
void PromotionPopUp()
{
Arg args[16];
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));
-
+// 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++;
XawDialogAddButton(dialog, _("King"), PromotionCallback,
(XtPointer) dialog);
}
- if(gameInfo.variant == VariantCapablanca ||
- gameInfo.variant == VariantGothic ||
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
gameInfo.variant == VariantCapaRandom) {
XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
(XtPointer) dialog);
(XtPointer) dialog);
XtRealizeWidget(promotionShell);
- CatchDeleteWindow(promotionShell, "PromotionPopDown");
+ // CatchDeleteWindow(promotionShell, "PromotionPopDown");
j = 0;
XtSetArg(args[j], XtNwidth, &pw_width); j++;
promoChar = ToLower(name[0]);
}
- FinishMove(NormalMove, fromX, fromY, toX, toY, promoChar);
+ UserMoveEvent(fromX, fromY, toX, toY, promoChar);
if (!appData.highlightLastMove || gotPremove) ClearHighlights();
if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
{
if (!errorUp) return;
errorUp = False;
- XtPopdown(errorShell);
- XtDestroyWidget(errorShell);
+
+ if(GUI_Error)
+ gtk_widget_destroy(GTK_WIDGET(GUI_Error));
+
if (errorExitStatus != -1) ExitEvent(errorExitStatus);
+
+ return;
}
void ErrorPopUp(title, label, modal)
char *title, *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,
- shellWidget, args, i);
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
- layoutArgs, XtNumber(layoutArgs));
+ GUI_Error = gtk_message_dialog_new(GTK_WINDOW(GUI_Window),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_CLOSE,
+ (gchar *)label);
- 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);
+ gtk_window_set_title(GTK_WINDOW(GUI_Error),(gchar *) title);
+ if(modal)
+ {
+ gtk_dialog_run(GTK_DIALOG(GUI_Error));
+ gtk_widget_destroy(GTK_WIDGET(GUI_Error));
+ }
+ else
+ {
+ g_signal_connect_swapped (GUI_Error, "response",
+ G_CALLBACK (ErrorPopDownProc),
+ GUI_Error);
+ errorUp = True;
+ gtk_widget_show(GTK_WIDGET(GUI_Error));
+ }
- errorUp = True;
- XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);
+ return;
}
/* Disable all user input other than deleting the window */
{
if (frozen) return;
/* Grab by a widget that doesn't accept input */
- XtAddGrab(messageWidget, TRUE, FALSE);
+ // XtAddGrab(messageWidget, TRUE, FALSE);
frozen = 1;
}
void ThawUI()
{
if (!frozen) return;
- XtRemoveGrab(messageWidget);
+ // XtRemoveGrab(messageWidget);
frozen = 0;
}
void ModeHighlight()
{
- Arg args[16];
static int oldPausing = FALSE;
static GameMode oldmode = (GameMode) -1;
char *wname;
- if (!boardWidget || !XtIsRealized(boardWidget)) return;
+ // todo this toggling of the pause button doesn't seem to work?
+ // e.g. select pause from buttonbar doesn't activate menumode.pause
+
+ // if (!boardWidget || !XtIsRealized(boardWidget)) return;
if (pausing != oldPausing) {
- oldPausing = pausing;
+ oldPausing = pausing;
+ gtk_button_set_relief(GTK_BUTTON (gtk_builder_get_object (builder, "menuMode.Pause")),pausing?GTK_RELIEF_NORMAL:GTK_RELIEF_NONE);
+ /* toggle background color in showbuttonbar */
+ if (appData.showButtonBar) {
if (pausing) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ gtk_button_pressed(GTK_BUTTON (gtk_builder_get_object (builder, "buttonbar.Pause")));
} else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Pause"),
- args, 1);
-
- if (appData.showButtonBar) {
- /* Always toggle, don't set. Previous code messes up when
- invoked while the button is pressed, as releasing it
- toggles the state again. */
- {
- Pixel oldbg, oldfg;
- XtSetArg(args[0], XtNbackground, &oldbg);
- XtSetArg(args[1], XtNforeground, &oldfg);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),
- args, 2);
- XtSetArg(args[0], XtNbackground, oldfg);
- XtSetArg(args[1], XtNforeground, oldbg);
- }
- XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
+ gtk_button_released(GTK_BUTTON (gtk_builder_get_object (builder, "buttonbar.Pause")));
}
+ }
}
wname = ModeToWidgetName(oldmode);
- if (wname != NULL) {
- XtSetArg(args[0], XtNleftBitmap, None);
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
- }
- wname = ModeToWidgetName(gameMode);
- if (wname != NULL) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
- }
+ if(wname)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, wname)),True);
+
oldmode = gameMode;
/* Maybe all the enables should be handled here, not just this one */
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Training"),
- gameMode == Training || gameMode == PlayFromGameFile);
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuMode.Training")),
+ gameMode == Training || gameMode == PlayFromGameFile);
}
/*
* Button/menu procedures
*/
-void ResetProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ResetGameEvent();
- EngineOutputPopDown();
-}
int LoadGamePopUp(f, gameNumber, title)
FILE *f;
char *title;
{
cmailMsgLoaded = FALSE;
- if (gameNumber == 0) {
+
+ if (gameNumber == 0)
+ {
int error = GameListBuild(f);
- if (error) {
+
+ if (error)
+ {
DisplayError(_("Cannot build game list"), error);
- } else if (!ListEmpty(&gameList) &&
- ((ListGame *) gameList.tailPred)->number > 1) {
- GameListPopUp(f, title);
+ }
+ else if (!ListEmpty(&gameList)
+ && ((ListGame *) gameList.tailPred)->number > 1)
+ {
+ // TODO convert to GTK
+ // GameListPopUp(f, title);
return TRUE;
- }
+ };
+
GameListDestroy();
gameNumber = 1;
- }
- return LoadGame(f, gameNumber, title, FALSE);
-}
-
-void LoadGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
- Reset(FALSE, TRUE);
- }
- FileNamePopUp(_("Load game file name?"), "", LoadGamePopUp, "rb");
-}
-
-void LoadNextGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(1);
-}
-
-void LoadPrevGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(-1);
-}
-
-void ReloadGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(0);
-}
-
-void LoadNextPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(1);
-}
-
-void LoadPrevPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(-1);
-}
-
-void ReloadPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(0);
-}
-
-void LoadPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
- Reset(FALSE, TRUE);
- }
- FileNamePopUp(_("Load position file name?"), "", LoadPosition, "rb");
-}
-
-void SaveGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- FileNamePopUp(_("Save game file name?"),
- DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),
- SaveGame, "a");
-}
+ };
-void SavePositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- FileNamePopUp(_("Save position file name?"),
- DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),
- SavePosition, "a");
+ return LoadGame(f, gameNumber, title, FALSE);
}
void ReloadCmailMsgProc(w, event, prms, nprms)
}
/* this variable is shared between CopyPositionProc and SendPositionSelection */
-static char *selected_fen_position=NULL;
+char *selected_fen_position=NULL;
-static Boolean
+Boolean
SendPositionSelection(Widget w, Atom *selection, Atom *target,
Atom *type_return, XtPointer *value_return,
unsigned long *length_return, int *format_return)
char *selection_tmp;
if (!selected_fen_position) return False; /* should never happen */
- if (*target == XA_STRING){
- /* note: since no XtSelectionDoneProc was registered, Xt will
- * automatically call XtFree on the value returned. So have to
- * make a copy of it allocated with XtMalloc */
- selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
- strcpy(selection_tmp, selected_fen_position);
-
- *value_return=selection_tmp;
- *length_return=strlen(selection_tmp);
- *type_return=XA_STRING;
- *format_return = 8; /* bits per byte */
- return True;
- } else {
- return False;
- }
+// if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
+// /* note: since no XtSelectionDoneProc was registered, Xt will
+// * automatically call XtFree on the value returned. So have to
+// * make a copy of it allocated with XtMalloc */
+// selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
+// strcpy(selection_tmp, selected_fen_position);
+//
+// *value_return=selection_tmp;
+// *length_return=strlen(selection_tmp);
+// *type_return=*target;
+// *format_return = 8; /* bits per byte */
+// return True;
+// } else if (*target == XA_TARGETS(xDisplay)) {
+// Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+// targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+// targets_tmp[1] = XA_STRING;
+// *value_return = targets_tmp;
+// *type_return = XA_ATOM;
+// *length_return = 2;
+// *format_return = 8 * sizeof(Atom);
+// if (*format_return > 32) {
+// *length_return *= *format_return / 32;
+// *format_return = 32;
+// }
+// return True;
+// } else {
+// return False;
+// }
}
/* note: when called from menu all parameters are NULL, so no clue what the
String *prms;
Cardinal *nprms;
{
- int ret;
-
+ /*
+ * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+ * have a notion of a position that is selected but not copied.
+ * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+ */
+ if(gameMode == EditPosition) EditPositionDone(TRUE);
if (selected_fen_position) free(selected_fen_position);
selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
if (!selected_fen_position) return;
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
- CurrentTime,
- SendPositionSelection,
- NULL/* lose_ownership_proc */ ,
- NULL/* transfer_done_proc */);
- if (!ret) {
- free(selected_fen_position);
- selected_fen_position=NULL;
- }
+// XtOwnSelection(menuBarWidget, XA_PRIMARY,
+// CurrentTime,
+// SendPositionSelection,
+// NULL/* lose_ownership_proc */ ,
+// NULL/* transfer_done_proc */);
+// XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+// CurrentTime,
+// SendPositionSelection,
+// NULL/* lose_ownership_proc */ ,
+// NULL/* transfer_done_proc */);
}
/* function called when the data to Paste is ready */
String *prms;
Cardinal *nprms;
{
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
- /* (XtSelectionCallbackProc) */ PastePositionCB,
- NULL, /* client_data passed to PastePositionCB */
-
- /* better to use the time field from the event that triggered the
- * call to this function, but that isn't trivial to get
- */
- CurrentTime
- );
+// XtGetSelectionValue(menuBarWidget,
+// appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+// /* (XtSelectionCallbackProc) */ PastePositionCB,
+// NULL, /* client_data passed to PastePositionCB */
+//
+// /* better to use the time field from the event that triggered the
+// * call to this function, but that isn't trivial to get
+// */
+// CurrentTime
+// );
return;
}
{
char *selection_tmp;
- if (*target == XA_STRING){
- FILE* f = fopen(gameCopyFilename, "r");
- long len;
- size_t count;
- if (f == NULL) return False;
- fseek(f, 0, 2);
- len = ftell(f);
- rewind(f);
- selection_tmp = XtMalloc(len + 1);
- count = fread(selection_tmp, 1, len, f);
- if (len != count) {
- XtFree(selection_tmp);
- return False;
- }
- selection_tmp[len] = NULLCHAR;
- *value_return = selection_tmp;
- *length_return = len;
- *type_return = XA_STRING;
- *format_return = 8; /* bits per byte */
- return True;
- } else {
- return False;
- }
+// if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
+// FILE* f = fopen(gameCopyFilename, "r");
+// long len;
+// size_t count;
+// if (f == NULL) return False;
+// fseek(f, 0, 2);
+// len = ftell(f);
+// rewind(f);
+// selection_tmp = XtMalloc(len + 1);
+// count = fread(selection_tmp, 1, len, f);
+// if (len != count) {
+// XtFree(selection_tmp);
+// return False;
+// }
+// selection_tmp[len] = NULLCHAR;
+// *value_return = selection_tmp;
+// *length_return = len;
+// *type_return = *target;
+// *format_return = 8; /* bits per byte */
+// return True;
+// } else if (*target == XA_TARGETS(xDisplay)) {
+// Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+// targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+// targets_tmp[1] = XA_STRING;
+// *value_return = targets_tmp;
+// *type_return = XA_ATOM;
+// *length_return = 2;
+// *format_return = 8 * sizeof(Atom);
+// if (*format_return > 32) {
+// *length_return *= *format_return / 32;
+// *format_return = 32;
+// }
+// return True;
+// } else {
+// return False;
+// }
}
/* note: when called from menu all parameters are NULL, so no clue what the
ret = SaveGameToFile(gameCopyFilename, FALSE);
if (!ret) return;
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
- CurrentTime,
- SendGameSelection,
- NULL/* lose_ownership_proc */ ,
- NULL/* transfer_done_proc */);
+ /*
+ * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+ * have a notion of a game that is selected but not copied.
+ * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+ */
+// XtOwnSelection(menuBarWidget, XA_PRIMARY,
+// CurrentTime,
+// SendGameSelection,
+// NULL/* lose_ownership_proc */ ,
+// NULL/* transfer_done_proc */);
+// XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+// CurrentTime,
+// SendGameSelection,
+// NULL/* lose_ownership_proc */ ,
+// NULL/* transfer_done_proc */);
}
/* function called when the data to Paste is ready */
String *prms;
Cardinal *nprms;
{
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
- /* (XtSelectionCallbackProc) */ PasteGameCB,
- NULL, /* client_data passed to PasteGameCB */
-
- /* better to use the time field from the event that triggered the
- * call to this function, but that isn't trivial to get
- */
- CurrentTime
- );
- return;
-}
-
-
-void AutoSaveGame()
-{
- SaveGameProc(NULL, NULL, NULL, NULL);
-}
-
-
-void QuitProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ExitEvent(0);
-}
-
-void PauseProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- PauseEvent();
-}
-
-
-void MachineBlackProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MachineBlackEvent();
-}
-
-void MachineWhiteProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MachineWhiteEvent();
+// XtGetSelectionValue(menuBarWidget,
+// appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+// /* (XtSelectionCallbackProc) */ PasteGameCB,
+// NULL, /* client_data passed to PasteGameCB */
+//
+// /* better to use the time field from the event that triggered the
+// * call to this function, but that isn't trivial to get
+// */
+// CurrentTime
+// );
+// return;
}
-void AnalyzeModeProc(w, event, prms, nprms)
+void SaveOnExitProc(w, event, prms, nprms)
Widget w;
XEvent *event;
String *prms;
Cardinal *nprms;
{
- char buf[MSG_SIZ];
-
- if (!first.analysisSupport) {
- snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
- DisplayError(buf, 0);
- return;
- }
- /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
- if (appData.icsActive) {
- if (gameMode != IcsObserving) {
- sprintf(buf,_("You are not observing a game"));
- DisplayError(buf, 0);
- /* secure check */
- if (appData.icsEngineAnalyze) {
- if (appData.debugMode)
- fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
- ExitAnalyzeMode();
- ModeHighlight();
- }
- return;
- }
- /* if enable, use want disable icsEngineAnalyze */
- if (appData.icsEngineAnalyze) {
- ExitAnalyzeMode();
- ModeHighlight();
- return;
- }
- appData.icsEngineAnalyze = TRUE;
- if (appData.debugMode)
- fprintf(debugFP, _("ICS engine analyze starting... \n"));
- }
- if (!appData.showThinking)
- ShowThinkingProc(w,event,prms,nprms);
+ Arg args[16];
- AnalyzeModeEvent();
-}
+ saveSettingsOnExit = !saveSettingsOnExit;
-void AnalyzeFileProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (!first.analysisSupport) {
- char buf[MSG_SIZ];
- snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
- DisplayError(buf, 0);
- return;
+ if (saveSettingsOnExit) {
+ XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ } else {
+ XtSetArg(args[0], XtNleftBitmap, None);
}
- Reset(FALSE, TRUE);
-
- if (!appData.showThinking)
- ShowThinkingProc(w,event,prms,nprms);
-
- AnalyzeFileEvent();
- FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
- AnalysisPeriodicEvent(1);
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Save Settings on Exit"),
+ args, 1);
}
-void TwoMachinesProc(w, event, prms, nprms)
+void SaveSettingsProc(w, event, prms, nprms)
Widget w;
XEvent *event;
String *prms;
Cardinal *nprms;
{
- TwoMachinesEvent();
+ SaveSettings(settingsFileName);
}
-void IcsClientProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- IcsClientEvent();
-}
-void EditGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- EditGameEvent();
-}
-
-void EditPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
+void AutoSaveGame()
{
- EditPositionEvent();
+ SaveGameProc(NULL, NULL);
+ return;
}
-void TrainingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- TrainingEvent();
-}
void EditCommentProc(w, event, prms, nprms)
Widget w;
}
}
-void AcceptProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AcceptEvent();
-}
-
-void DeclineProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- DeclineEvent();
-}
-
-void RematchProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RematchEvent();
-}
-
-void CallFlagProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- CallFlagEvent();
-}
-
-void DrawProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- DrawEvent();
-}
-
-void AbortProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AbortEvent();
-}
-
-void AdjournProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AdjournEvent();
-}
-
-void ResignProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ResignEvent();
-}
-
-void AdjuWhiteProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- UserAdjudicationEvent(+1);
-}
-
-void AdjuBlackProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- UserAdjudicationEvent(-1);
-}
-
-void AdjuDrawProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- UserAdjudicationEvent(0);
-}
void EnterKeyProc(w, event, prms, nprms)
Widget w;
ICSInputSendText();
}
-void StopObservingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- StopObservingEvent();
-}
-
-void StopExaminingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- StopExaminingEvent();
-}
-
-
-void ForwardProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ForwardEvent();
-}
-
-
-void BackwardProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- BackwardEvent();
-}
-
-void ToStartProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ToStartEvent();
-}
-
-void ToEndProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ToEndEvent();
-}
-
-void RevertProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RevertEvent();
-}
-
-void TruncateGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- TruncateGameEvent();
-}
-void RetractMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RetractMoveEvent();
-}
-
-void MoveNowProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MoveNowEvent();
-}
-
-
-void AlwaysQueenProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;
-
- if (appData.alwaysPromoteToQueen) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
- args, 1);
-}
-
-void AnimateDraggingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.animateDragging = !appData.animateDragging;
-
- if (appData.animateDragging) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- CreateAnimVars();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Dragging"),
- args, 1);
-}
-
-void AnimateMovingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.animate = !appData.animate;
-
- if (appData.animate) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- CreateAnimVars();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
- args, 1);
-}
-
-void AutocommProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoComment = !appData.autoComment;
-
- if (appData.autoComment) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
- args, 1);
-}
-
-
-void AutoflagProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoCallFlag = !appData.autoCallFlag;
-
- if (appData.autoCallFlag) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
- args, 1);
-}
-
-void AutoflipProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoFlipView = !appData.autoFlipView;
-
- if (appData.autoFlipView) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),
- args, 1);
-}
-
-void AutobsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoObserve = !appData.autoObserve;
-
- if (appData.autoObserve) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
- args, 1);
-}
-
-void AutoraiseProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoRaiseBoard = !appData.autoRaiseBoard;
-
- if (appData.autoRaiseBoard) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Raise Board"),
- args, 1);
-}
-
-void AutosaveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoSaveGames = !appData.autoSaveGames;
-
- if (appData.autoSaveGames) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
-}
-
-void BlindfoldProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.blindfold = !appData.blindfold;
-
- if (appData.blindfold) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Blindfold"),
- args, 1);
-
- DrawPosition(True, NULL);
-}
-
-void TestLegalityProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.testLegality = !appData.testLegality;
-
- if (appData.testLegality) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Test Legality"),
- args, 1);
-}
-
-
-void FlashMovesProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- if (appData.flashCount == 0) {
- appData.flashCount = 3;
- } else {
- appData.flashCount = -appData.flashCount;
- }
-
- if (appData.flashCount > 0) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flash Moves"),
- args, 1);
-}
-
-void FlipViewProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- flipView = !flipView;
- DrawPosition(True, NULL);
-}
-
-void GetMoveListProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.getMoveList = !appData.getMoveList;
-
- if (appData.getMoveList) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- GetMoveListEvent();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
- args, 1);
-}
-
-#if HIGHDRAG
-void HighlightDraggingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.highlightDragging = !appData.highlightDragging;
-
- if (appData.highlightDragging) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Dragging"), args, 1);
-}
-#endif
-
-void HighlightLastMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.highlightLastMove = !appData.highlightLastMove;
-
- if (appData.highlightLastMove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Last Move"), args, 1);
-}
-
-void IcsAlarmProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.icsAlarm = !appData.icsAlarm;
-
- if (appData.icsAlarm) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.ICS Alarm"), args, 1);
-}
-
-void MoveSoundProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.ringBellAfterMoves = !appData.ringBellAfterMoves;
-
- if (appData.ringBellAfterMoves) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
- args, 1);
-}
-
-
-void OldSaveStyleProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.oldSaveStyle = !appData.oldSaveStyle;
-
- if (appData.oldSaveStyle) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Old Save Style"),
- args, 1);
-}
-
-void PeriodicUpdatesProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- PeriodicUpdatesEvent(!appData.periodicUpdates);
-
- if (appData.periodicUpdates) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Periodic Updates"),
- args, 1);
-}
-
-void PonderNextMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- PonderNextMoveEvent(!appData.ponderNextMove);
-
- if (appData.ponderNextMove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Ponder Next Move"),
- args, 1);
-}
-
-void PopupExitMessageProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.popupExitMessage = !appData.popupExitMessage;
-
- if (appData.popupExitMessage) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Popup Exit Message"), args, 1);
-}
-
-void PopupMoveErrorsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.popupMoveErrors = !appData.popupMoveErrors;
-
- if (appData.popupMoveErrors) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Popup Move Errors"),
- args, 1);
-}
-
-void PremoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.premove = !appData.premove;
-
- if (appData.premove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Premove"), args, 1);
-}
-
-void QuietPlayProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.quietPlay = !appData.quietPlay;
-
- if (appData.quietPlay) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Quiet Play"),
- args, 1);
-}
-
-void ShowCoordsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.showCoords = !appData.showCoords;
-
- if (appData.showCoords) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
- args, 1);
-
- DrawPosition(True, NULL);
-}
-
-void ShowThinkingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
- ShowThinkingEvent();
-}
-
-void HideThinkingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
- ShowThinkingEvent();
-
- if (appData.hideThinkingFromHuman) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
- args, 1);
-}
-
-void InfoProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
- INFODIR, INFOFILE);
- system(buf);
-}
-
-void ManProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- String name;
- if (nprms && *nprms > 0)
- name = prms[0];
- else
- name = "xboard";
- snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
- system(buf);
-}
-
-void HintProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- HintEvent();
-}
-
-void BookProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- BookEvent();
-}
-
-void AboutProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
-#if ZIPPY
- char *zippy = " (with Zippy code)";
-#else
- char *zippy = "";
-#endif
- snprintf(buf, sizeof(buf), "%s%s\n\n%s\n%s\n%s\n\n%s%s\n%s",
- programVersion, zippy,
- "Copyright 1991 Digital Equipment Corporation",
- "Enhancements Copyright 1992-2009 Free Software Foundation",
- "Enhancements Copyright 2005 Alessandro Scotti",
- PACKAGE, " is free software and carries NO WARRANTY;",
- "see the file COPYING for more information.");
- ErrorPopUp(_("About XBoard"), buf, FALSE);
-}
void DebugProc(w, event, prms, nprms)
Widget w;
{
Arg args[16];
- fromX = fromY = -1;
- XtSetArg(args[0], XtNiconic, True);
- XtSetValues(shellWidget, args, 1);
+// fromX = fromY = -1;
+// XtSetArg(args[0], XtNiconic, True);
+// XtSetValues(shellWidget, args, 1);
}
void DisplayMessage(message, extMessage)
- char *message, *extMessage;
+ gchar *message, *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;
- };
- };
-
- /* 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;
+ char buf[MSG_SIZ];
+ Arg arg;
+
+ if (extMessage) {
+ if (*message) {
+ snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
+ message = buf;
+ } else {
+ message = extMessage;
+ }
+ }
+ gtk_label_set_text( GTK_LABEL(gtk_builder_get_object (builder, "Messages")),message);
+
+ return;
}
void DisplayTitle(text)
char *text;
{
- Arg args[16];
- int i;
- char title[MSG_SIZ];
- char icon[MSG_SIZ];
+ gchar title[MSG_SIZ];
if (text == NULL) text = "";
- if (appData.titleInWindow) {
- i = 0;
- XtSetArg(args[i], XtNlabel, text); i++;
- XtSetValues(titleWidget, args, i);
- }
+ if (appData.titleInWindow)
+ {
+ /* TODO */
+ }
- if (*text != NULLCHAR) {
- strcpy(icon, text);
+ if (*text != NULLCHAR)
+ {
strcpy(title, text);
- } else if (appData.icsActive) {
- snprintf(icon, sizeof(icon), "%s", appData.icsHost);
+ }
+ else if (appData.icsActive)
+ {
snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
- } else if (appData.cmailGameName[0] != NULLCHAR) {
- snprintf(icon, sizeof(icon), "%s", "CMail");
+ }
+ else if (appData.cmailGameName[0] != NULLCHAR)
+ {
snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
#ifdef GOTHIC
// [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
- } else if (gameInfo.variant == VariantGothic) {
- strcpy(icon, programName);
+ }
+ else if (gameInfo.variant == VariantGothic)
+ {
strcpy(title, GOTHIC);
#endif
#ifdef FALCON
- } else if (gameInfo.variant == VariantFalcon) {
- strcpy(icon, programName);
+ }
+ else if (gameInfo.variant == VariantFalcon)
+ {
strcpy(title, FALCON);
#endif
- } else if (appData.noChessProgram) {
- strcpy(icon, programName);
+ }
+ else if (appData.noChessProgram)
+ {
strcpy(title, programName);
- } else {
- strcpy(icon, first.tidy);
+ }
+ else
+ {
snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
- }
- i = 0;
- XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
- XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;
- XtSetValues(shellWidget, args, i);
+ }
+ gtk_window_set_title(GTK_WINDOW(GUI_Window),title);
+
+ return;
}
Window root, parent, *children;
unsigned int nchildren;
int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
- for (;;) {
- if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
- if (!XQueryTree(xDisplay, win, &root, &parent,
- &children, &nchildren)) break;
- if (children) XFree((void *)children);
- if (parent == root || parent == 0) break;
- win = parent;
- }
+// for (;;) {
+// if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
+// if (!XQueryTree(xDisplay, win, &root, &parent,
+// &children, &nchildren)) break;
+// if (children) XFree((void *)children);
+// if (parent == root || parent == 0) break;
+// win = parent;
+// }
XSetErrorHandler(oldHandler);
}
if (oldICSInteractionTitle == NULL) {
i = 0;
XtSetArg(args[i], XtNresizable, True); i++;
XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
- askQuestionShell = popup =
- XtCreatePopupShell(title, transientShellWidgetClass,
- shellWidget, args, i);
-
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,
- layoutArgs, XtNumber(layoutArgs));
-
+// askQuestionShell = popup =
+// XtCreatePopupShell(title, transientShellWidgetClass,
+// shellWidget, args, i);
+//
+// layout =
+// XtCreateManagedWidget(layoutName, formWidgetClass, popup,
+// layoutArgs, XtNumber(layoutArgs));
+//
i = 0;
XtSetArg(args[i], XtNlabel, question); i++;
XtSetArg(args[i], XtNvalue, ""); i++;
(XtPointer) dialog);
XtRealizeWidget(popup);
- CatchDeleteWindow(popup, "AskQuestionPopDown");
-
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,
- &x, &y, &win_x, &win_y, &mask);
-
- XtSetArg(args[0], XtNx, x - 10);
- XtSetArg(args[1], XtNy, y - 30);
- XtSetValues(popup, args, 2);
+ // CatchDeleteWindow(popup, "AskQuestionPopDown");
- XtPopup(popup, XtGrabExclusive);
- askQuestionUp = True;
-
- edit = XtNameToWidget(dialog, "*value");
- XtSetKeyboardFocus(popup, edit);
+// XQueryPointer(xDisplay, xBoardWindow, &root, &child,
+// &x, &y, &win_x, &win_y, &mask);
+//
+// XtSetArg(args[0], XtNx, x - 10);
+// XtSetArg(args[1], XtNy, y - 30);
+// XtSetValues(popup, args, 2);
+//
+// XtPopup(popup, XtGrabExclusive);
+// askQuestionUp = True;
+//
+// edit = XtNameToWidget(dialog, "*value");
+// XtSetKeyboardFocus(popup, edit);
}
#endif /* not HAVE_GETHOSTNAME */
}
-XtIntervalId delayedEventTimerXID = 0;
+guint delayedEventTimerTag = 0;
DelayedEventCallback delayedEventCallback = 0;
void
-FireDelayedEvent()
+FireDelayedEvent(data)
+ gpointer data;
{
- delayedEventTimerXID = 0;
- delayedEventCallback();
+ /* remove timer */
+ g_source_remove(delayedEventTimerTag);
+ delayedEventTimerTag = 0;
+
+ /* call function */
+ delayedEventCallback();
+
+ return;
}
void
ScheduleDelayedEvent(cb, millisec)
- DelayedEventCallback cb; long millisec;
+ DelayedEventCallback cb; guint millisec;
{
- if(delayedEventTimerXID && delayedEventCallback == cb)
+ if(delayedEventTimerTag && delayedEventCallback == cb)
// [HGM] alive: replace, rather than add or flush identical event
- XtRemoveTimeOut(delayedEventTimerXID);
+ g_source_remove(delayedEventTimerTag);
delayedEventCallback = cb;
- delayedEventTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
+ delayedEventTimerTag = g_timeout_add(millisec,(GSourceFunc) FireDelayedEvent, NULL);
+ return;
}
DelayedEventCallback
GetDelayedEvent()
{
- if (delayedEventTimerXID) {
- return delayedEventCallback;
- } else {
- return NULL;
- }
+ if (delayedEventTimerTag)
+ {
+ return delayedEventCallback;
+ }
+ else
+ {
+ return NULL;
+ }
}
void
CancelDelayedEvent()
{
- if (delayedEventTimerXID) {
- XtRemoveTimeOut(delayedEventTimerXID);
- delayedEventTimerXID = 0;
- }
+ if (delayedEventTimerTag)
+ {
+ g_source_remove(delayedEventTimerTag);
+ delayedEventTimerTag = 0;
+ }
+
+ return;
}
-XtIntervalId loadGameTimerXID = 0;
+guint loadGameTimerTag = 0;
int LoadGameTimerRunning()
{
- return loadGameTimerXID != 0;
+ return loadGameTimerTag != 0;
}
int StopLoadGameTimer()
{
- if (loadGameTimerXID != 0) {
- XtRemoveTimeOut(loadGameTimerXID);
- loadGameTimerXID = 0;
+ if (loadGameTimerTag != 0) {
+ g_source_remove(loadGameTimerTag);
+ loadGameTimerTag = 0;
return TRUE;
} else {
return FALSE;
}
void
-LoadGameTimerCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+LoadGameTimerCallback(data)
+ gpointer data;
{
- loadGameTimerXID = 0;
- AutoPlayGameLoop();
+ /* remove timer */
+ g_source_remove(loadGameTimerTag);
+ loadGameTimerTag = 0;
+
+ AutoPlayGameLoop();
+ return;
}
void
StartLoadGameTimer(millisec)
long millisec;
{
- loadGameTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) LoadGameTimerCallback,
- (XtPointer) 0);
+ loadGameTimerTag =
+ g_timeout_add( millisec, (GSourceFunc) LoadGameTimerCallback, NULL);
+ return;
}
-XtIntervalId analysisClockXID = 0;
+guint analysisClockTag = 0;
-void
-AnalysisClockCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+gboolean
+AnalysisClockCallback(data)
+ gpointer data;
{
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
- || appData.icsEngineAnalyze) { // [DM]
+ || appData.icsEngineAnalyze)
+ {
AnalysisPeriodicEvent(0);
- StartAnalysisClock();
- }
+ return 1; /* keep on going */
+ }
+ return 0; /* stop timer */
}
void
StartAnalysisClock()
{
- analysisClockXID =
- XtAppAddTimeOut(appContext, 2000,
- (XtTimerCallbackProc) AnalysisClockCallback,
- (XtPointer) 0);
+ analysisClockTag =
+ g_timeout_add( 2000,(GSourceFunc) AnalysisClockCallback, NULL);
+ return;
}
-XtIntervalId clockTimerXID = 0;
+guint clockTimerTag = 0;
int ClockTimerRunning()
{
- return clockTimerXID != 0;
+ return clockTimerTag != 0;
}
int StopClockTimer()
{
- if (clockTimerXID != 0) {
- XtRemoveTimeOut(clockTimerXID);
- clockTimerXID = 0;
+ if (clockTimerTag != 0)
+ {
+ g_source_remove(clockTimerTag);
+ clockTimerTag = 0;
return TRUE;
- } else {
+ }
+ else
+ {
return FALSE;
- }
+ }
}
void
-ClockTimerCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+ClockTimerCallback(data)
+ gpointer data;
{
- clockTimerXID = 0;
- DecrementClocks();
+ /* remove timer */
+ g_source_remove(clockTimerTag);
+ clockTimerTag = 0;
+
+ DecrementClocks();
+ return;
}
void
StartClockTimer(millisec)
long millisec;
{
- clockTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) ClockTimerCallback,
- (XtPointer) 0);
+ clockTimerTag = g_timeout_add(millisec,(GSourceFunc) ClockTimerCallback,NULL);
+ return;
}
void
DisplayTimerLabel(w, color, timer, highlight)
- Widget w;
+ GtkWidget *w;
char *color;
long timer;
int highlight;
{
- char buf[MSG_SIZ];
- Arg args[16];
-
- /* check for low time warning */
- Pixel foregroundOrWarningColor = timerForegroundPixel;
-
- if (timer > 0 &&
- appData.lowTimeWarning &&
- (timer / 1000) < appData.icsAlarmTime)
- foregroundOrWarningColor = lowTimeWarningColor;
-
- if (appData.clockMode) {
- sprintf(buf, "%s: %s", color, TimeString(timer));
- XtSetArg(args[0], XtNlabel, buf);
- } else {
- sprintf(buf, "%s ", color);
- XtSetArg(args[0], XtNlabel, buf);
- }
-
- if (highlight) {
+ gchar buf[MSG_SIZ];
- XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
- XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
- } else {
- XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
- XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
- }
- XtSetValues(w, args, 3);
+ if (appData.clockMode) {
+ sprintf(buf, "%s: %s", color, TimeString(timer));
+ } else {
+ sprintf(buf, "%s ", color);
+ }
+ gtk_label_set_text(GTK_LABEL(w),buf);
+
+ /* check for low time warning */
+// Pixel foregroundOrWarningColor = timerForegroundPixel;
+
+// if (timer > 0 &&
+// appData.lowTimeWarning &&
+// (timer / 1000) < appData.icsAlarmTime)
+// foregroundOrWarningColor = lowTimeWarningColor;
+//
+// if (appData.clockMode) {
+// sprintf(buf, "%s: %s", color, TimeString(timer));
+// XtSetArg(args[0], XtNlabel, buf);
+// } else {
+// sprintf(buf, "%s ", color);
+// XtSetArg(args[0], XtNlabel, buf);
+// }
+//
+// if (highlight) {
+//
+// XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
+// XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
+// } else {
+// XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
+// XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
+// }
+//
+// XtSetValues(w, args, 3);
+//
}
void
long timeRemaining;
int highlight;
{
- Arg args[16];
+ if(appData.noGUI) return;
- if(appData.noGUI) return;
- DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
- if (highlight && iconPixmap == bIconPixmap) {
- iconPixmap = wIconPixmap;
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);
- XtSetValues(shellWidget, args, 1);
+ DisplayTimerLabel(GUI_Whiteclock, _("White"), timeRemaining, highlight);
+ if (highlight && WindowIcon == BlackIcon)
+ {
+ WindowIcon = WhiteIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
}
}
long timeRemaining;
int highlight;
{
- Arg args[16];
-
if(appData.noGUI) return;
- DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
- if (highlight && iconPixmap == wIconPixmap) {
- iconPixmap = bIconPixmap;
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);
- XtSetValues(shellWidget, args, 1);
- }
+
+ DisplayTimerLabel(GUI_Blackclock, _("Black"), timeRemaining, highlight);
+ if (highlight && WindowIcon == WhiteIcon)
+ {
+ WindowIcon = BlackIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
+ }
}
#define CPNone 0
strcpy(buf, cmdLine);
p = buf;
for (;;) {
+ while(*p == ' ') p++;
argv[i++] = p;
- p = strchr(p, ' ');
+ if(*p == '"' || *p == '\'')
+ p = strchr(++argv[i-1], *p);
+ else p = strchr(p, ' ');
if (p == NULL) break;
*p++ = NULLCHAR;
}
SetUpChildIO(to_prog, from_prog);
- #ifdef SIGWINCH
- signal(SIGWINCH, TermSizeSigHandler);
- #endif
-
if ((pid = fork()) == 0) {
/* Child process */
// [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
int lineByLine;
char *unused;
InputCallback func;
- XtInputId xid;
+ guint sid;
char buf[INPUT_SOURCE_BUF_SIZE];
VOIDSTAR closure;
} InputSource;
void
-DoInputCallback(closure, source, xid)
- caddr_t closure;
- int *source;
- XtInputId *xid;
+DoInputCallback(io,cond,data)
+ GIOChannel *io;
+ GIOCondition cond;
+ gpointer *data;
{
- InputSource *is = (InputSource *) closure;
- int count;
- int error;
- char *p, *q;
-
- if (is->lineByLine) {
- count = read(is->fd, is->unused,
- INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
- if (count <= 0) {
- (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
- return;
+ /* read input from one of the input source (for example a chess program, ICS, etc).
+ * and call a function that will handle the input
+ */
+
+ int count; /* how many bytes did we read */
+ int error;
+ char *p, *q;
+
+ /* All information (callback function, file descriptor, etc) is
+ * saved in an InputSource structure
+ */
+ InputSource *is = (InputSource *) data;
+
+ if (is->lineByLine)
+ {
+ count = read(is->fd, is->unused,
+ INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
+
+ if (count <= 0)
+ {
+ (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
+ return;
}
- is->unused += count;
- p = is->buf;
- while (p < is->unused) {
- q = memchr(p, '\n', is->unused - p);
- if (q == NULL) break;
- q++;
- (is->func)(is, is->closure, p, q - p, 0);
- p = q;
+ is->unused += count;
+ p = is->buf;
+ /* break input into lines and call the callback function on each
+ * line
+ */
+ while (p < is->unused)
+ {
+ q = memchr(p, '\n', is->unused - p);
+ if (q == NULL) break;
+ q++;
+ (is->func)(is, is->closure, p, q - p, 0);
+ p = q;
}
- q = is->buf;
- while (p < is->unused) {
- *q++ = *p++;
+ /* remember not yet used part of the buffer */
+ q = is->buf;
+ while (p < is->unused)
+ {
+ *q++ = *p++;
}
- is->unused = q;
- } else {
- count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
- if (count == -1)
- error = errno;
- else
- error = 0;
- (is->func)(is, is->closure, is->buf, count, error);
+ is->unused = q;
}
+ else
+ {
+ /* read maximum length of input buffer and send the whole buffer
+ * to the callback function
+ */
+ count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+ }
+
+ return;
}
InputSourceRef AddInputSource(pr, lineByLine, func, closure)
VOIDSTAR closure;
{
InputSource *is;
+ GIOChannel *channel;
ChildProc *cp = (ChildProc *) pr;
is = (InputSource *) calloc(1, sizeof(InputSource));
is->kind = cp->kind;
is->fd = cp->fdFrom;
}
- if (lineByLine) {
- is->unused = is->buf;
- }
+ if (lineByLine)
+ is->unused = is->buf;
+ else
+ is->unused = NULL;
+
+// is->xid = XtAppAddInput(appContext, is->fd,
+// (XtPointer) (XtInputReadMask),
+// (XtInputCallbackProc) DoInputCallback,
+// (XtPointer) is);
+//
- is->xid = XtAppAddInput(appContext, is->fd,
- (XtPointer) (XtInputReadMask),
- (XtInputCallbackProc) DoInputCallback,
- (XtPointer) is);
+ /* TODO: will this work on windows?*/
+
+ channel = g_io_channel_unix_new(is->fd);
+ g_io_channel_set_close_on_unref (channel, TRUE);
+ is->sid = g_io_add_watch(channel, G_IO_IN,(GIOFunc) DoInputCallback, is);
is->closure = closure;
return (InputSourceRef) is;
}
{
InputSource *is = (InputSource *) isr;
- if (is->xid == 0) return;
- XtRemoveInput(is->xid);
- is->xid = 0;
+ if (is->sid == 0) return;
+ g_source_remove(is->sid);
+ is->sid = 0;
+ return;
}
int OutputToProcess(pr, message, count, outError)
int count;
int *outError;
{
+ static int line = 0;
ChildProc *cp = (ChildProc *) pr;
int outCount;
if (pr == NoProc)
- outCount = fwrite(message, 1, count, stdout);
+ {
+ if (appData.noJoin || !appData.useInternalWrap)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ int width = get_term_width();
+ int len = wrap(NULL, message, count, width, &line);
+ char *msg = malloc(len);
+ int dbgchk;
+
+ if (!msg)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ dbgchk = wrap(msg, message, count, width, &line);
+ if (dbgchk != len && appData.debugMode)
+ fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
+ outCount = fwrite(msg, 1, dbgchk, stdout);
+ free(msg);
+ }
+ }
+ }
else
outCount = write(cp->fdTo, message, count);
unsigned long plane;
XGCValues values;
+ /* just return for gtk at the moment */
+ return;
+
/* Need a bitmap just to get a GC with right depth */
- buf = XCreatePixmap(xDisplay, xBoardWindow,
- 8, 8, 1);
+// buf = XCreatePixmap(xDisplay, xBoardWindow,
+// 8, 8, 1);
values.foreground = 1;
values.background = 0;
/* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, buf,
- GCForeground | GCBackground, &values);
- XFreePixmap(xDisplay, buf);
-
- buf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, pieceDepth);
- values.foreground = XBlackPixel(xDisplay, xScreen);
- values.background = XWhitePixel(xDisplay, xScreen);
- bufGC = XCreateGC(xDisplay, buf,
- GCForeground | GCBackground, &values);
-
+// maskGC = XCreateGC(xDisplay, buf,
+// GCForeground | GCBackground, &values);
+// XFreePixmap(xDisplay, buf);
+//
+// buf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, pieceDepth);
+// values.foreground = XBlackPixel(xDisplay, xScreen);
+// values.background = XWhitePixel(xDisplay, xScreen);
+// bufGC = XCreateGC(xDisplay, buf,
+// GCForeground | GCBackground, &values);
+//
for (piece = WhitePawn; piece <= BlackKing; piece++) {
/* Begin with empty mask */
- if(!xpmDone) // [HGM] pieces: keep using existing
- xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, 1);
- XSetFunction(xDisplay, maskGC, GXclear);
- XFillRectangle(xDisplay, xpmMask[piece], maskGC,
- 0, 0, squareSize, squareSize);
-
+// if(!xpmDone) // [HGM] pieces: keep using existing
+// xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, 1);
+// XSetFunction(xDisplay, maskGC, GXclear);
+// XFillRectangle(xDisplay, xpmMask[piece], maskGC,
+// 0, 0, squareSize, squareSize);
+//
/* Take a copy of the piece */
if (White(piece))
kind = 0;
else
kind = 2;
- XSetFunction(xDisplay, bufGC, GXcopy);
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
- buf, bufGC,
- 0, 0, squareSize, squareSize, 0, 0);
+// XSetFunction(xDisplay, bufGC, GXcopy);
+// XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
+// buf, bufGC,
+// 0, 0, squareSize, squareSize, 0, 0);
/* XOR the background (light) over the piece */
- XSetFunction(xDisplay, bufGC, GXxor);
- if (useImageSqs)
- XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
- 0, 0, squareSize, squareSize, 0, 0);
- else {
- XSetForeground(xDisplay, bufGC, lightSquareColor);
- XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
- }
+// XSetFunction(xDisplay, bufGC, GXxor);
+// if (useImageSqs)
+// XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
+// 0, 0, squareSize, squareSize, 0, 0);
+// else {
+// XSetForeground(xDisplay, bufGC, lightSquareColor);
+// XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
+// }
/* We now have an inverted piece image with the background
erased. Construct mask by just selecting all the non-zero
pixels - no need to reconstruct the original image. */
- XSetFunction(xDisplay, maskGC, GXor);
+ // XSetFunction(xDisplay, maskGC, GXor);
plane = 1;
/* Might be quicker to download an XImage and create bitmap
data from it rather than this N copies per piece, but it
only takes a fraction of a second and there is a much
longer delay for loading the pieces. */
- for (n = 0; n < pieceDepth; n ++) {
- XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
- 0, 0, squareSize, squareSize,
- 0, 0, plane);
- plane = plane << 1;
- }
+// for (n = 0; n < pieceDepth; n ++) {
+// XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
+// 0, 0, squareSize, squareSize,
+// 0, 0, plane);
+// plane = plane << 1;
+// }
}
/* Clean up */
- XFreePixmap(xDisplay, buf);
- XFreeGC(xDisplay, bufGC);
- XFreeGC(xDisplay, maskGC);
+// XFreePixmap(xDisplay, buf);
+// XFreeGC(xDisplay, bufGC);
+// XFreeGC(xDisplay, maskGC);
}
static void
XGCValues values;
/* Each buffer is square size, same depth as window */
- anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, info->depth);
- anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, info->depth);
-
- /* Create a plain GC for blitting */
- mask = GCForeground | GCBackground | GCFunction |
- GCPlaneMask | GCGraphicsExposures;
- values.foreground = XBlackPixel(xDisplay, xScreen);
- values.background = XWhitePixel(xDisplay, xScreen);
- values.function = GXcopy;
- values.plane_mask = AllPlanes;
- values.graphics_exposures = False;
- anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
-
- /* Piece will be copied from an existing context at
- the start of each new animation/drag. */
- anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
-
- /* Outline will be a read-only copy of an existing */
- anim->outlineGC = None;
+// anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, info->depth);
+// anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, info->depth);
+//
+// /* Create a plain GC for blitting */
+// mask = GCForeground | GCBackground | GCFunction |
+// GCPlaneMask | GCGraphicsExposures;
+// values.foreground = XBlackPixel(xDisplay, xScreen);
+// values.background = XWhitePixel(xDisplay, xScreen);
+// values.function = GXcopy;
+// values.plane_mask = AllPlanes;
+// values.graphics_exposures = False;
+// anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
+//
+// /* Piece will be copied from an existing context at
+// the start of each new animation/drag. */
+// anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
+//
+// /* Outline will be a read-only copy of an existing */
+// anim->outlineGC = None;
}
static void
static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
XWindowAttributes info;
+ /* for gtk at the moment just ... */
+ return;
+
if (xpmDone && gameInfo.variant == old) return;
if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
- XGetWindowAttributes(xDisplay, xBoardWindow, &info);
+ // XGetWindowAttributes(xDisplay, xBoardWindow, &info);
- InitAnimState(&game, &info);
- InitAnimState(&player, &info);
+ // InitAnimState(&game, &info);
+ // InitAnimState(&player, &info);
/* For XPM pieces, we need bitmaps to use as masks. */
- if (useImages)
- CreateAnimMasks(info.depth);
+ // if (useImages)
+ // CreateAnimMasks(info.depth);
xpmDone = 1;
}
FrameDelay (time)
int time;
{
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
if (time > 0)
usleep(time * 1000);
}
else
source = blPieceGC;
}
- XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
+ // XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
/* Outline only used in mono mode and is not modified */
if (White(piece))
if (!useImages) {
/* Draw solid rectangle which will be clipped to shape of piece */
- XFillRectangle(xDisplay, dest, clip,
- 0, 0, squareSize, squareSize);
+// XFillRectangle(xDisplay, dest, clip,
+// 0, 0, squareSize, squareSize)
+;
if (appData.monoMode)
/* Also draw outline in contrasting color for black
on black / white on white cases */
- XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
- 0, 0, squareSize, squareSize, 0, 0, 1);
+// XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
+// 0, 0, squareSize, squareSize, 0, 0, 1)
+;
} else {
/* Copy the piece */
if (White(piece))
kind = 0;
else
kind = 2;
- XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
- dest, clip,
- 0, 0, squareSize, squareSize,
- 0, 0);
+// XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
+// dest, clip,
+// 0, 0, squareSize, squareSize,
+// 0, 0);
}
}
anim->prevFrame = *start;
/* The piece will be drawn using its own bitmap as a matte */
- SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
- XSetClipMask(xDisplay, anim->pieceGC, mask);
+// SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
+// XSetClipMask(xDisplay, anim->pieceGC, mask);
}
static void
int count, i;
/* Save what we are about to draw into the new buffer */
- XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
- frame->x, frame->y, squareSize, squareSize,
- 0, 0);
+// XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
+// frame->x, frame->y, squareSize, squareSize,
+// 0, 0);
/* Erase bits of the previous frame */
if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
/* Where the new frame overlapped the previous,
the contents in newBuf are wrong. */
- XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
- overlap.x, overlap.y,
- overlap.width, overlap.height,
- pt.x, pt.y);
+// XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
+// overlap.x, overlap.y,
+// overlap.width, overlap.height,
+// pt.x, pt.y);
/* Repaint the areas in the old that don't overlap new */
CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);
for (i = 0; i < count; i++)
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- updates[i].x - anim->prevFrame.x,
- updates[i].y - anim->prevFrame.y,
- updates[i].width, updates[i].height,
- updates[i].x, updates[i].y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// updates[i].x - anim->prevFrame.x,
+// updates[i].y - anim->prevFrame.y,
+// updates[i].width, updates[i].height,
+// updates[i].x, updates[i].y)
+;
} else {
/* Easy when no overlap */
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- anim->prevFrame.x, anim->prevFrame.y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// anim->prevFrame.x, anim->prevFrame.y);
}
/* Save this frame for next time round */
- XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
- 0, 0, squareSize, squareSize,
- 0, 0);
+// XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// 0, 0);
anim->prevFrame = *frame;
/* Draw piece over original screen contents, not current,
and copy entire rect. Wipes out overlapping piece images. */
OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);
- XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- frame->x, frame->y);
+// XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// frame->x, frame->y);
}
static void
if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {
CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);
for (i = 0; i < count; i++)
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- updates[i].x - anim->prevFrame.x,
- updates[i].y - anim->prevFrame.y,
- updates[i].width, updates[i].height,
- updates[i].x, updates[i].y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// updates[i].x - anim->prevFrame.x,
+// updates[i].y - anim->prevFrame.y,
+// updates[i].width, updates[i].height,
+// updates[i].x, updates[i].y)
+;
} else {
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- anim->prevFrame.x, anim->prevFrame.y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// anim->prevFrame.x, anim->prevFrame.y);
}
}
if (!appData.animate || appData.blindfold)
return;
- if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
- board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
+ if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
+ board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
damage[toY][toX] = True;
}
-static void
+void
DragPieceBegin(x, y)
int x; int y;
{
as seen by opponent) the move hasn't been made yet. */
if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
- XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
- corner.x, corner.y, squareSize, squareSize,
- 0, 0); // [HGM] zh: unstack in stead of grab
+// XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
+// corner.x, corner.y, squareSize, squareSize,
+// 0, 0); // [HGM] zh: unstack in stead of grab
damage[boardY][boardX] = True;
} else {
player.dragActive = False;
corner.x = x - player.mouseDelta.x;
corner.y = y - player.mouseDelta.y;
AnimationFrame(&player, &corner, player.dragPiece);
-#if HIGHDRAG
+#if HIGHDRAG*0
if (appData.highlightDragging) {
int boardX, boardY;
BoardSquare(x, y, &boardX, &boardY);
#endif
}
-static void
+void
DragPieceEnd(x, y)
int x; int y;
{
damage[player.startBoardY][player.startBoardX] = TRUE;
}
-void
-SetProgramStats( FrontEndProgramStats * stats )
-{
- // [HR] TODO
- // [HGM] done, but perhaps backend should call this directly?
- EngineOutputUpdate( stats );
-}
-
#include <sys/ioctl.h>
int get_term_width()
{
projects / xboard.git / blobdiff