home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #3 / amigamamagazinepolishissue1998.iso / szachy / gnu / amyboard-3.2.pl2 / amiga / amyboard.c next >
C/C++ Source or Header  |  1995-05-23  |  60KB  |  1,941 lines
  1. /***
  2. ***
  3. ***  amyboard.c -- Amiga front end for XBoard
  4. ***
  5. *** ------------------------------------------------------------------------
  6. *** This program is free software; you can redistribute it and/or modify
  7. *** it under the terms of the GNU General Public License as published by
  8. *** the Free Software Foundation; either version 2 of the License, or
  9. *** (at your option) any later version.
  10. ***
  11. *** This program is distributed in the hope that it will be useful,
  12. *** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. *** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. *** GNU General Public License for more details.
  15. ***
  16. *** You should have received a copy of the GNU General Public License
  17. *** along with this program; if not, write to the Free Software
  18. *** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. *** ------------------------------------------------------------------------
  20. ***
  21. **/
  22. /**/
  23.  
  24.  
  25. /***  Version information
  26. ***/
  27. #define VERSION         322
  28. #define REVISION        5
  29. #define DATE            "23.05.95"
  30. #define NAME            "AmyBoard"
  31. #define VERS            "AmyBoard 322.5"
  32. #define VSTRING         "AmyBoard 322.5 (23.05.95)"
  33. #define VERSTAG         "\0$VER: AmyBoard 322.5 (23.05.95)"
  34. /**/
  35.  
  36.  
  37. /***  Include files
  38. ***/
  39. #include "amyboard.h"
  40.  
  41. #include <libraries/gadtools.h>
  42. #include <libraries/asl.h>
  43. #include <libraries/iffparse.h>
  44. /**/
  45.  
  46.  
  47. /***  Global variables
  48. ***/
  49. char *programName                       = VERS;
  50.  
  51. AmigaAppData amigaAppData;
  52.  
  53. APTR xboardApp                          = NULL;
  54. APTR xboardWindow;
  55. APTR xboardChessboard;
  56. APTR xboardMenu;
  57. APTR xboardText;
  58. APTR xboardExtText;
  59. APTR xboardUpperTime;
  60. APTR xboardLowerTime;
  61.  
  62.  
  63. void LoadGameProc(void);
  64. void LoadNextGameProc(void);
  65. void LoadPrevGameProc(void);
  66. void ReloadGameProc(void);
  67. void LoadPositionProc(void);
  68. void SaveGameProc(void);
  69. void SavePositionProc(void);
  70. void ReloadCmailGameProc(void);
  71. void AboutProc(void);
  72. void QuitProc(void);
  73. void AlwaysQueenProc(void);
  74. void AutoflagProc(void);
  75. void AutoobsProc(void);
  76. void AutosaveProc(void);
  77. void BellProc(void);
  78. void FlipViewProc(void);
  79. void OldSaveStyleProc(void);
  80. void QuietPlayProc(void);
  81. void ShowCoordsProc(void);
  82. void ShowThinkingProc(void);
  83. void UseGameListProc(void);
  84. void EditGameInfoProc(void);
  85. #define TOGGLE CHECKIT|MENUTOGGLE
  86. static struct NewMenu xboardNewMenu [] =
  87. { { NM_TITLE,   (STRPTR) "Project",              NULL,          0,        0,   NULL },
  88.   { NM_ITEM,    (STRPTR) "Reset Game",           (STRPTR) "r",  0,        0,   (APTR) ResetGameEvent },
  89.   { NM_ITEM,    (STRPTR) "Load Game",            (STRPTR) "g",  CHECKIT,  0,   (APTR) LoadGameProc },
  90.   { NM_ITEM,    (STRPTR) "Load Next Game",       (STRPTR) "N",  0,        0,   (APTR) LoadNextGameProc },
  91.   { NM_ITEM,    (STRPTR) "Load Previous Game",   (STRPTR) "P",  0,        0,   (APTR) LoadPrevGameProc },
  92.   { NM_ITEM,    (STRPTR) "Reload Same Game",     NULL,          0,        0,   (APTR) ReloadGameProc },
  93.   { NM_ITEM,    (STRPTR) "Load Position",        NULL,          0,        0,   (APTR) LoadPositionProc },
  94.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  95.   { NM_ITEM,    (STRPTR) "Save Game",            (STRPTR) "s",  0,        0,   (APTR) SaveGameProc },
  96.   { NM_ITEM,    (STRPTR) "Save Position",        NULL,          0,        0,   (APTR) SavePositionProc },
  97.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  98.   { NM_ITEM,    (STRPTR) "Mail Move",            NULL,          0,        0,   (APTR) MailMoveEvent },
  99.   { NM_ITEM,    (STRPTR) "Reload CMail Message", NULL,          0,        0,   (APTR) ReloadCmailGameProc },
  100.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  101.   { NM_ITEM,    (STRPTR) "About",                NULL,          0,        0,   (APTR) AboutProc },
  102.   { NM_ITEM,    (STRPTR) "Exit",                 (STRPTR) "q",  0,        0,   (APTR) QuitProc },
  103.   { NM_TITLE,   (STRPTR) "Mode",                 NULL,          0,        0,   NULL },
  104.   { NM_ITEM,    (STRPTR) "Pause",                (STRPTR) "p",  CHECKIT,  0,   (APTR) PauseEvent },
  105.   { NM_ITEM,    (STRPTR) "Edit Comment",         NULL,          0,        0,   (APTR) EditCommentEvent },
  106.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  107.   { NM_ITEM,    (STRPTR) "Machine White",        NULL,          CHECKIT,  496, (APTR) MachineWhiteEvent },
  108.   { NM_ITEM,    (STRPTR) "Machine Black",        NULL,          CHECKIT,  488, (APTR) MachineBlackEvent },
  109.   { NM_ITEM,    (STRPTR) "Two Machines",         NULL,          CHECKIT,  472, (APTR) TwoMachinesEvent },
  110.   { NM_ITEM,    (STRPTR) "ICS Client",           NULL,          CHECKIT,  440, (APTR) IcsClientEvent },
  111.   { NM_ITEM,    (STRPTR) "Edit Game",            NULL,          CHECKIT,  376, (APTR) EditGameEvent },
  112.   { NM_ITEM,    (STRPTR) "Edit Position",        NULL,          CHECKIT,  248, (APTR) EditPositionEvent },
  113.   { NM_TITLE,   (STRPTR) "Action",               NULL,          0,        0,   NULL },
  114.   { NM_ITEM,    (STRPTR) "Accept",               NULL,          0,        0,   (APTR) AcceptEvent },
  115.   { NM_ITEM,    (STRPTR) "Decline",              NULL,          0,        0,   (APTR) DeclineEvent },
  116.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  117.   { NM_ITEM,    (STRPTR) "Call Flag",            (STRPTR) "t",  0,        0,   (APTR) CallFlagEvent },
  118.   { NM_ITEM,    (STRPTR) "Draw",                 (STRPTR) "d",  0,        0,   (APTR) DrawEvent },
  119.   { NM_ITEM,    (STRPTR) "Adjourn",              NULL,          0,        0,   (APTR) AdjournEvent },
  120.   { NM_ITEM,    (STRPTR) "Abort",                NULL,          0,        0,   (APTR) AbortEvent },
  121.   { NM_ITEM,    (STRPTR) "Resign",               (STRPTR) "R",  0,        0,   (APTR) ResignEvent },
  122.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  123.   { NM_ITEM,    (STRPTR) "Stop Observing",       NULL,          0,        0,   (APTR) StopObservingEvent },
  124.   { NM_ITEM,    (STRPTR) "Stop Examining",       NULL,          0,        0,   (APTR) StopExaminingEvent },
  125.   { NM_TITLE,   (STRPTR) "Step",                 NULL,          0,        0,   NULL },
  126.   { NM_ITEM,    (STRPTR) "Backward",             (STRPTR) "b",  0,        0,   (APTR) BackwardEvent },
  127.   { NM_ITEM,    (STRPTR) "Forward",              (STRPTR) "f",  0,        0,   (APTR) ForwardEvent },
  128.   { NM_ITEM,    (STRPTR) "Back to Start",        (STRPTR) "B",  0,        0,   (APTR) ToStartEvent },
  129.   { NM_ITEM,    (STRPTR) "Forward to End",       (STRPTR) "F",  0,        0,   (APTR) ToEndEvent },
  130.   { NM_ITEM,    (STRPTR) "Revert",               NULL,          0,        0,   (APTR) RevertEvent },
  131.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  132.   { NM_ITEM,    (STRPTR) "Truncate Game",        NULL,          0,        0,   (APTR) TruncateGameEvent },
  133.   { NM_ITEM,    NM_BARLABEL,                     NULL,          0,        0,   NULL },
  134.   { NM_ITEM,    (STRPTR) "Move Now",             NULL,          0,        0,   (APTR) MoveNowEvent },
  135.   { NM_ITEM,    (STRPTR) "Retract Move",         NULL,          0,        0,   (APTR) RetractMoveEvent },
  136.   { NM_TITLE,   (STRPTR) "Options",              NULL,          0,        0,   NULL },
  137.   { NM_ITEM,    (STRPTR) "Always Queen",         NULL,          TOGGLE,   0,   (APTR) AlwaysQueenProc },
  138.   { NM_ITEM,    (STRPTR) "Auto Flag",            NULL,          TOGGLE,   0,   (APTR) AutoflagProc },
  139.   { NM_ITEM,    (STRPTR) "Auto Observe",         NULL,          TOGGLE,   0,   (APTR) AutoobsProc },
  140.   { NM_ITEM,    (STRPTR) "Auto Save",            NULL,          TOGGLE,   0,   (APTR) AutosaveProc },
  141.   { NM_ITEM,    (STRPTR) "Bell",                 NULL,          TOGGLE,   0,   (APTR) BellProc },
  142.   { NM_ITEM,    (STRPTR) "Flip View",            NULL,          TOGGLE,   0,   (APTR) FlipViewProc },
  143.   { NM_ITEM,    (STRPTR) "Old Save Style",       NULL,          TOGGLE,   0,   (APTR) OldSaveStyleProc },
  144.   { NM_ITEM,    (STRPTR) "Quiet Play",           NULL,          TOGGLE,   0,   (APTR) QuietPlayProc },
  145.   { NM_ITEM,    (STRPTR) "Show Coords",          NULL,          TOGGLE,   0,   (APTR) ShowCoordsProc },
  146.   { NM_ITEM,    (STRPTR) "Show Thinking",        NULL,          TOGGLE,   0,   (APTR) ShowThinkingProc },
  147.   { NM_ITEM,    (STRPTR) "Use game list",        NULL,          TOGGLE,   0,   (APTR) UseGameListProc },
  148.   { NM_TITLE,   (STRPTR) "Help",                 NULL,          0,        0,   NULL },
  149.   { NM_ITEM,    (STRPTR) "Hint",                 NULL,          0,        0,   (APTR) HintEvent },
  150.   { NM_ITEM,    (STRPTR) "Book",                 NULL,          0,        0,   (APTR) BookEvent },
  151.   { NM_ITEM,    (STRPTR) "About Game",           NULL,          0,        0,   (APTR) AboutGameEvent },
  152.   { NM_ITEM,    (STRPTR) "Edit Game Info",       NULL,          0,        0,   (APTR) EditGameInfoProc },
  153.   { NM_END,     NULL,                            NULL,          0,        0,   NULL }
  154. };
  155. /**/
  156.  
  157.  
  158. /***  Cleanup function
  159. ***/
  160. void Cleanup(void)
  161.  
  162. { if(xboardApp)
  163.   { MUI_DisposeObject(xboardApp);
  164.   }
  165.   TimeClose();
  166.   PipesClose();
  167.   MuiClassClose();
  168. }
  169. /**/
  170.  
  171.  
  172. /***  Argument section
  173. ***
  174. ***  The following macro consists of a repeated use of the macro
  175. ***  XBOARD_ARG, one for each possible argument. The macro's synopsis
  176. ***  is
  177. ***
  178. ***    XBOARD_ARG(argName, type, template, defaultVal, helpString);
  179. ***
  180. ***  Inputs:
  181. ***     argName - the arguments name; an entry of the struct AppData
  182. ***         (see common.h)
  183. ***     type - the argument type as defined by ParseArgs()
  184. ***     template - a template string that may be used by ReadArgs()
  185. ***     defaultVal - default value
  186. ***     helpString - string to be printed if the user requests help;
  187. ***         may be empty in case the argument should not be displayed
  188. ***         to the user. (Some arguments are present for source code
  189. ***         compatibility only.)
  190. ***
  191. ***  This file is used from xboard.c by including it repeatedly with
  192. ***  different definitions of XBOARD_ARG. For example, to get the
  193. ***  defaults we do the following:
  194. ***
  195. ***   #define XBOARD_ARG(argName, type, template, defaultVal, helpString) \
  196. ***     appData.argName = defaultVal;
  197. ***   XBOARD_ARGS
  198. ***
  199. ***************************************************************************/
  200. #define XBOARD_ARGS \
  201. XBOARD_ARG(appData.whitePieceColor,      PARSEARGS_TYPE_INTEGER, "WPP=WHITEPIECEPEN",       -1,                   "\twpp=whitePiecePen/K/N pennumber\n")\
  202. XBOARD_ARG(appData.blackPieceColor,      PARSEARGS_TYPE_INTEGER, "BPP=BLACKPIECEPEN",       -1,                   "\tbpp=blackPiecePen/K/N pennumber\n")\
  203. XBOARD_ARG(appData.lightSquareColor,     PARSEARGS_TYPE_INTEGER, "LSP=LIGHTSQUARECOLOR",    -1,                   "\tlsp=lightSquarePen/K/N pennumber\n")\
  204. XBOARD_ARG(appData.darkSquareColor,      PARSEARGS_TYPE_INTEGER, "DSP=DARKSQUARECOLOR",     -1,                   "\tdsp=darkSquarePen/K/N pennumber\n")\
  205. XBOARD_ARG(appData.movesPerSession,      PARSEARGS_TYPE_INTEGER, "MP=MOVESPERSESSION",      MOVES_PER_SESSION,    "\tmp=movesPerSession/K/N number\n")\
  206. XBOARD_ARG(appData.initString,           PARSEARGS_TYPE_STRING,  "INITSTRING",              INIT_STRING,          "")\
  207. XBOARD_ARG(appData.whiteString,          PARSEARGS_TYPE_STRING,  "WHITESTRING",             WHITE_STRING,         "")\
  208. XBOARD_ARG(appData.blackString,          PARSEARGS_TYPE_STRING,  "BLACKSTRING",             BLACK_STRING,         "")\
  209. XBOARD_ARG(appData.firstChessProgram,    PARSEARGS_TYPE_STRING,  "FCP=FIRSTCHESSPROGRAM",   FIRST_CHESS_PROGRAM,  "")\
  210. XBOARD_ARG(appData.secondChessProgram,   PARSEARGS_TYPE_STRING,  "SCP=SECONDCHESSPROGRAM",  SECOND_CHESS_PROGRAM, "")\
  211. XBOARD_ARG(appData.noChessProgram,       PARSEARGS_TYPE_BOOL,    "NCP=NOCHESSPROGRAM",      FALSE,                "\tncp=noChessProgram/T\n")\
  212. XBOARD_ARG(appData.firstHost,            PARSEARGS_TYPE_STRING,  "FIRSTHOST",               FIRST_HOST,           "")\
  213. XBOARD_ARG(appData.secondHost,           PARSEARGS_TYPE_STRING,  "SECONDHOST",              SECOND_HOST,          "")\
  214. XBOARD_ARG(appData.bitmapDirectory,      PARSEARGS_TYPE_STRING,  "BITMAPDIRECTORY",         NULL,                 "\tbmdir=bitmapDirectory/K dirname\n")\
  215. XBOARD_ARG(appData.remoteShell,          PARSEARGS_TYPE_STRING,  "REMOTESHELL",             "",                   "")\
  216. XBOARD_ARG(appData.remoteUser,           PARSEARGS_TYPE_STRING,  "REMOTEUSER",              "",                   "")\
  217. XBOARD_ARG(appData.timeDelay,            PARSEARGS_TYPE_FLOAT,   "TIMEDELAY",               TIME_DELAY,           "")\
  218. XBOARD_ARG(appData.timeControl,          PARSEARGS_TYPE_STRING,  "TIMECONTROL",             TIME_CONTROL,         "\ttc=timeControl/K\n")\
  219. XBOARD_ARG(appData.icsActive,            PARSEARGS_TYPE_BOOL,    "ICS=ICSACTIVE",           FALSE,                "\tics=icsActive/T\n")\
  220. XBOARD_ARG(appData.icsHost,              PARSEARGS_TYPE_STRING,  "ICSHOST",                 ICS_HOST,             "\ticsHost/K hostname\n")\
  221. XBOARD_ARG(appData.icsPort,              PARSEARGS_TYPE_INTEGER, "ICSPORT",                 ICS_PORT,             "\ticsPort/K/N portnumber\n")\
  222. XBOARD_ARG(appData.icsCommPort,          PARSEARGS_TYPE_STRING,  "ICSCOMMPORT",             ICS_COMM_PORT,        "")\
  223. XBOARD_ARG(appData.icsLogon,             PARSEARGS_TYPE_STRING,  "ICSLOGON",                ".icsrc",             "\ticsLogon/K scriptname\n")\
  224. XBOARD_ARG(appData.useTelnet,            PARSEARGS_TYPE_BOOL,    "USETELNET",               TRUE,                 "")\
  225. XBOARD_ARG(appData.telnetProgram,        PARSEARGS_TYPE_STRING,  "TELNETPROGRAM",           "AmiTCP:bin/telnet",  "\ttp=telnetProgram/K programpath\n")\
  226. XBOARD_ARG(appData.gateway,              PARSEARGS_TYPE_STRING,  "GATEWAY",                 "",                   "")\
  227. XBOARD_ARG(appData.loadGameFile,         PARSEARGS_TYPE_STRING,  "LGF=LOADGAMEFILE",        "",                   "\tlgf=loadGameFile/K filename\n")\
  228. XBOARD_ARG(appData.loadGameIndex,        PARSEARGS_TYPE_INTEGER, "LGI=LOADGAMEINDEX",       1,                    "\tlgi=loadGameIndex/K/N gamenumber\n")\
  229. XBOARD_ARG(appData.saveGameFile,         PARSEARGS_TYPE_STRING,  "SGF=SAVEGAMEFILE",        "",                   "\tsgf=saveGameFile/K filename\n")\
  230. XBOARD_ARG(appData.autoSaveGames,        PARSEARGS_TYPE_BOOL,    "AUTOSAVEGAMES",           FALSE,                "\tautoSaveGames/T\n")\
  231. XBOARD_ARG(appData.loadPositionFile,     PARSEARGS_TYPE_STRING,  "LPF=LOADPOSITIONFILE",    "",                   "\tlpf=loadPositionFile/K filename\n")\
  232. XBOARD_ARG(appData.loadPositionIndex,    PARSEARGS_TYPE_INTEGER, "LPI=LOADPOSITIONINDEX",   1,                    "\tlpi=loadPositionIndex/K/N positionnumber\n")\
  233. XBOARD_ARG(appData.savePositionFile,     PARSEARGS_TYPE_STRING,  "SPF=SAVEPOSITIONFILE",    "",                   "\tspf=savePositionFile/K filename\n")\
  234. XBOARD_ARG(appData.matchMode,            PARSEARGS_TYPE_BOOL,    "MM=MATCHMODE",            FALSE,                "\tmm=matchMode/T\n")\
  235. XBOARD_ARG(appData.monoMode,             PARSEARGS_TYPE_BOOL,    "MONO=MONOMODE",           FALSE,                "")\
  236. XBOARD_ARG(appData.debugMode,            PARSEARGS_TYPE_BOOL,    "DEBUG=DEBUGMODE",         FALSE,                "")\
  237. XBOARD_ARG(appData.clockMode,            PARSEARGS_TYPE_BOOL,    "CM=CLOCKMODE",            TRUE,                 "\tcm=clockMode/T\n")\
  238. XBOARD_ARG(appData.boardSize,            PARSEARGS_TYPE_STRING,  "SIZE=BOARDSIZE",          "",                   "\tsize=boardSize/K [small|medium|big]\n")\
  239. XBOARD_ARG(appData.Iconic,               PARSEARGS_TYPE_BOOL,    "ICONIC",                  FALSE,                "")\
  240. XBOARD_ARG(appData.searchTime,           PARSEARGS_TYPE_STRING,  "ST=SEARCHTIME",           "",                   "\tst=searchTime/K minutes:seconds\n")\
  241. XBOARD_ARG(appData.searchDepth,          PARSEARGS_TYPE_INTEGER, "SD=SEARCHDEPTH",          0,                    "\tsd=searchDepth/K/N number\n")\
  242. XBOARD_ARG(appData.showCoords,           PARSEARGS_TYPE_BOOL,    "COORDS=SHOWCOORDS",       FALSE,                "")\
  243. XBOARD_ARG(appData.clockFont,            PARSEARGS_TYPE_STRING,  "CLOCKFONT",               "",                   "")\
  244. XBOARD_ARG(appData.messageFont,          PARSEARGS_TYPE_STRING,  "MESSAGEFONT",             "",                   "")\
  245. XBOARD_ARG(appData.coordFont,            PARSEARGS_TYPE_STRING,  "COORDFONT",               "",                   "")\
  246. XBOARD_ARG(appData.ringBellAfterMoves,   PARSEARGS_TYPE_BOOL,    "BELL=RINGBELLAFTERMOVES", FALSE,                "\tbell=ringBellAfterMoves/T\n")\
  247. XBOARD_ARG(appData.autoCallFlag,         PARSEARGS_TYPE_BOOL,    "CALLFLAG",                FALSE,                "\tcallFlag/T\n")\
  248. XBOARD_ARG(appData.flipView,             PARSEARGS_TYPE_BOOL,    "FLIPVIEW",                FALSE,                "\tflipView/T\n")\
  249. XBOARD_ARG(appData.cmailGameName,        PARSEARGS_TYPE_STRING,  "CMAILGAMENAME",           "",                   "")\
  250. XBOARD_ARG(appData.alwaysPromoteToQueen, PARSEARGS_TYPE_BOOL,    "ALWAYSQUEEN",             FALSE,                "\talwaysQueen/T\n")\
  251. XBOARD_ARG(appData.oldSaveStyle,         PARSEARGS_TYPE_BOOL,    "OLDSAVESTYLE",            FALSE,                "")\
  252. XBOARD_ARG(appData.quietPlay,            PARSEARGS_TYPE_BOOL,    "QUIETPLAY",               FALSE,                "")\
  253. XBOARD_ARG(appData.showThinking,         PARSEARGS_TYPE_BOOL,    "SHOWTHINKING",            FALSE,                "\tshowThinking/T\n")\
  254. XBOARD_ARG(appData.autoObserve,          PARSEARGS_TYPE_BOOL,    "AUTOOBSERVE",             FALSE,                "\tobserve/T\n")\
  255. XBOARD_ARG(appData.borderXoffset,        PARSEARGS_TYPE_INTEGER, "BORDERXOFFSET",           FALSE,                "")\
  256. XBOARD_ARG(appData.borderYoffset,        PARSEARGS_TYPE_INTEGER, "BORDERYOFFSET",           FALSE,                "")\
  257. XBOARD_ARG(appData.titleInWindow,        PARSEARGS_TYPE_BOOL,    "TITLEINWINDOW",           TRUE,                 "")\
  258. XBOARD_ARG(appData.localEdit,            PARSEARGS_TYPE_BOOL,    "LOCALEDIT",               FALSE,                "")\
  259. XBOARD_ARG(appData.zippyTalk,            PARSEARGS_TYPE_BOOL,    "ZIPPYTALK",               FALSE,                "")\
  260. XBOARD_ARG(appData.zippyPlay,            PARSEARGS_TYPE_BOOL,    "ZIPPYPLAY",               FALSE,                "")\
  261. XBOARD_ARG(appData.useGameList,          PARSEARGS_TYPE_BOOL,    "USEGAMELIST",             TRUE,                 "")\
  262. XBOARD_ARG(amigaAppData.icsWindow,       PARSEARGS_TYPE_STRING,  "ICSWINDOW",               NULL,                 "")\
  263. XBOARD_ARG(amigaAppData.childPriority,   PARSEARGS_TYPE_INTEGER, "CHILDPRIORITY",           0,                    "\tchildPriority/K/N number\n")\
  264. XBOARD_ARG(amigaAppData.childStack,      PARSEARGS_TYPE_INTEGER, "CHILDSTACK",              100000,               "\tchildStack/K/N number\n")
  265.  
  266.  
  267.  
  268.  
  269. int ProcessArgs(int argc, char *argv[])
  270.  
  271. { static const Tag parseArgTags[] =
  272.   {
  273. #undef XBOARD_ARG
  274. #define XBOARD_ARG(argName, type, template, defaultVal, helpString) \
  275.     PARSEARGS_ARGNAME,    (Tag) template,        \
  276.     PARSEARGS_TYPE,       type,                  \
  277.     PARSEARGS_VALPTR,     (Tag) &argName,
  278.     XBOARD_ARGS
  279.  
  280. #undef XBOARD_ARG
  281. #define XBOARD_ARG(argName, type, template, defaultVal, helpString) \
  282.     helpString
  283.     PARSEARGS_HELPSTRING, (Tag) XBOARD_ARGS,
  284.  
  285.     PARSEARGS_PREFSFILE,  (Tag) "PROGDIR:lib/amyboard.prefs",
  286.     PARSEARGS_PREFSFILE,  (Tag) "PROGDIR:/lib/amyboard.prefs",
  287.     PARSEARGS_PREFSFILE,  (Tag) "ENV:amyboard.prefs",
  288.     TAG_DONE
  289.   };
  290.  
  291. #undef XBOARD_ARG
  292. #define XBOARD_ARG(argName, type, template, defaultVal, helpString) \
  293.     argName = defaultVal;
  294.   XBOARD_ARGS
  295.  
  296.   return(ParseArgsA(argc, argv, (struct TagItem *) parseArgTags));
  297. }
  298. /**/
  299.  
  300.  
  301. /***  ICSInitScript function
  302. ***/
  303. void ICSInitScript(void)
  304.  
  305. { FILE *fp = NULL;
  306.   char buf[MSG_SIZ];
  307.   char **ptr, *fileName;
  308.   static char *searchDirs[] =
  309.   { "",
  310.     "PROGDIR:",
  311.     "PROGDIR:lib",
  312.     "PROGDIR:/lib",
  313.     "ENV:",
  314.     NULL
  315.   };
  316.  
  317.   for (ptr = searchDirs;  *ptr;  ptr++)
  318.   { if (**ptr)
  319.     { strcpy(buf, *ptr);
  320.       AddPart((STRPTR) buf, (STRPTR) appData.icsLogon, sizeof(buf));
  321.       fileName = buf;
  322.     }
  323.     else
  324.     { fileName = appData.icsLogon;
  325.     }
  326.     if ((fp = fopen(fileName, "r")))
  327.     { break;
  328.     }
  329.   }
  330.  
  331.   if (fp)
  332.   { ProcessICSInitScript(fp);
  333.   }
  334. }
  335. /**/
  336.  
  337.  
  338. /***  main() function
  339. ***
  340. ***  Initializing and main loop.
  341. **/
  342. void CreateMUIApp(void);
  343. int main(int argc, char *argv[])
  344.  
  345. { ULONG signalmask;
  346.  
  347.   /**
  348.   ***  Get stderr, if running from Workbench.
  349.   **/
  350.   if (!argc)
  351.   { if (!freopen("CON:////amyboard stderr/AUTO", "w", stderr))
  352.     { exit(10);
  353.     }
  354.   }
  355.   debugFP = stderr;
  356.   toUserFP = stderr;
  357.  
  358.   if (atexit(Cleanup))
  359.   { exit(10);
  360.   }
  361.  
  362.   MuiClassInit();
  363.   PipesInit();
  364.   TimeInit();
  365.  
  366.  
  367.   if (!(ProcessArgs(argc, argv)))
  368.   { fprintf(stderr, "Error %ld while parsing arguments.\n", IoErr());
  369.     exit(10);
  370.   }
  371.  
  372.   InitBackEnd1();
  373.  
  374.   CreateMUIApp();
  375.  
  376.   InitBackEnd2();
  377.  
  378.   if (appData.icsActive)
  379.   { ICSInitScript();
  380.   }
  381.  
  382.   signalmask = timeSignals |
  383.            SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_C;
  384.  
  385.   for(;;)
  386.   { ULONG receivedsigs;
  387.     ULONG muisigs;
  388.     LONG id;
  389.  
  390.     while ((id = DoMethod(xboardApp, MUIM_Application_Input, &muisigs)))
  391.     { switch (id)
  392.       { case MUIV_Application_ReturnID_Quit:
  393.       ExitEvent(0);
  394.       break;
  395.       }
  396.     }
  397.  
  398.     receivedsigs = Wait(muisigs | pipeSignals | signalmask);
  399.  
  400.     if (receivedsigs & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D))
  401.     { ExitEvent(0);
  402.     }
  403.     if (receivedsigs & timeSignals)
  404.     { TimeCallback(receivedsigs);
  405.     }
  406.     if (receivedsigs & pipeSignals)
  407.     { DoInputCallback(receivedsigs);
  408.     }
  409.   }
  410. }
  411. #if defined(_DCC)
  412. int wbmain(struct WBStartup *wbs){return(main(0, (char **)wbs));}
  413. #endif
  414. /**/
  415.  
  416.  
  417. /***  ResetFrontEnd() function
  418. ***
  419. ***  Called from backend.
  420. **/
  421. void CommentPopDown(void);
  422. void EditCommentPopDown(void);
  423. APTR ProcToMenuitem(APTR);
  424. void ResetFrontEnd()
  425.  
  426. { CommentPopDown();
  427.   EditCommentPopDown();
  428.   DrawPosition(TRUE, NULL);
  429. }
  430. /**/
  431.  
  432.  
  433. /***  Menuitem section
  434. ***
  435. ***  The following structures define, which menuitems are enabled
  436. ***  or disabled in different program modes.
  437. **/
  438. typedef struct
  439. { APTR Proc;
  440.   Boolean value;
  441. } Sensitivity;
  442.  
  443.  
  444. APTR ProcToMenuitem(APTR proc)
  445.  
  446. { if (!proc)
  447.   { return(NULL);
  448.   }
  449.   return((APTR) DoMethod(xboardMenu, MUIM_FindUData, proc));
  450. }
  451.  
  452. void SetMenuSensitivity(Sensitivity *sens)
  453.  
  454. { APTR obj;
  455.  
  456.   while(sens->Proc != NULL)
  457.   { if ((obj = ProcToMenuitem(sens->Proc)))
  458.     { set(obj, MUIA_Menuitem_Enabled, sens->value);
  459.     }
  460.     ++sens;
  461.   }
  462. }
  463.  
  464. Sensitivity icsSensitivity[] =
  465. { { (APTR) MailMoveEvent,          FALSE },
  466.   { (APTR) ReloadCmailGameProc,    FALSE },
  467.   { (APTR) MachineBlackEvent,      FALSE },
  468.   { (APTR) MachineWhiteEvent,      FALSE },
  469.   { (APTR) TwoMachinesEvent,       FALSE },
  470. #ifndef ZIPPY
  471.   { (APTR) HintEvent,              FALSE },
  472.   { (APTR) BookEvent,              FALSE },
  473.   { (APTR) MoveNowEvent,           FALSE },
  474.   { (APTR) ShowThinkingProc,       FALSE },
  475. #endif
  476.   { NULL,                   FALSE }
  477. };
  478. void SetICSMode(void)
  479.  
  480. { SetMenuSensitivity(icsSensitivity);
  481. }
  482.  
  483.  
  484. Sensitivity ncpSensitivity[] =
  485. { { (APTR) MailMoveEvent,          FALSE },
  486.   { (APTR) ReloadCmailGameProc,    FALSE },
  487.   { (APTR) MachineBlackEvent,      FALSE },
  488.   { (APTR) MachineWhiteEvent,      FALSE },
  489.   { (APTR) TwoMachinesEvent,       FALSE },
  490.   { (APTR) IcsClientEvent,         FALSE },
  491.  
  492.   /**
  493.   ***  The original xboard has an
  494.  
  495.   { (APTR) ActionProc,             FALSE },
  496.  
  497.   ***  here. As this would require to separate between menuitems
  498.   ***  ans menustrips in SetMenuSensitivity(), we better disable
  499.   ***  any menuitem instead of the menustrip below.
  500.   **/
  501.   { (APTR) AcceptEvent,            FALSE },
  502.   { (APTR) DeclineEvent,           FALSE },
  503.   { (APTR) CallFlagEvent,          FALSE },
  504.   { (APTR) DrawEvent,              FALSE },
  505.   { (APTR) AdjournEvent,           FALSE },
  506.   { (APTR) AbortEvent,             FALSE },
  507.   { (APTR) ResignEvent,            FALSE },
  508.   { (APTR) StopObservingEvent,     FALSE },
  509.   { (APTR) StopExaminingEvent,     FALSE },
  510.  
  511.  
  512.   { (APTR) RevertEvent,            FALSE },
  513.   { (APTR) MoveNowEvent,           FALSE },
  514.   { (APTR) RetractMoveEvent,       FALSE },
  515.   { (APTR) AutoflagProc,           FALSE },
  516.   { (APTR) AutoobsProc,            FALSE },
  517.   { (APTR) BellProc,               FALSE },
  518.   { (APTR) QuietPlayProc,          FALSE },
  519.   { (APTR) ShowThinkingProc,       FALSE },
  520.   { (APTR) HintEvent,              FALSE },
  521.   { (APTR) BookEvent,              FALSE },
  522.   { NULL,                   FALSE }
  523. };
  524. void SetNCPMode(void)
  525.  
  526. { SetMenuSensitivity(ncpSensitivity);
  527. }
  528.  
  529.  
  530. Sensitivity gnuSensitivity[] =
  531. { { (APTR) IcsClientEvent,         FALSE },
  532.   { (APTR) AcceptEvent,            FALSE },
  533.   { (APTR) DeclineEvent,           FALSE },
  534.   { (APTR) DrawEvent,              FALSE },
  535.   { (APTR) AdjournEvent,           FALSE },
  536.   { (APTR) StopExaminingEvent,     FALSE },
  537.   { (APTR) StopObservingEvent,     FALSE },
  538.   { (APTR) RevertEvent,            FALSE },
  539.   { (APTR) AutoflagProc,           FALSE },
  540.   { (APTR) AutoobsProc,            FALSE },
  541.   { (APTR) QuietPlayProc,          FALSE },
  542.   { (APTR) MailMoveEvent,          FALSE },
  543.   { (APTR) ReloadCmailGameProc,    FALSE },
  544.   { NULL,                   FALSE }
  545. };
  546. void SetGNUMode(void)
  547.  
  548. { SetMenuSensitivity(gnuSensitivity);
  549. }
  550.  
  551.  
  552. Sensitivity cmailSensitivity[] =
  553. { /**
  554.   ***  The original xboard has an
  555.  
  556.   { (APTR) ActionProc,             TRUE },
  557.  
  558.   ***  here. As this would require to separate between menuitems
  559.   ***  ans menustrips in SetMenuSensitivity(), we better disable
  560.   ***  any menuitem instead of the menustrip below.
  561.   **/
  562.   { (APTR) AcceptEvent,            TRUE },
  563.   { (APTR) DeclineEvent,           TRUE },
  564.   { (APTR) CallFlagEvent,          FALSE },
  565.   { (APTR) DrawEvent,              FALSE },
  566.   { (APTR) AdjournEvent,           FALSE },
  567.   { (APTR) AbortEvent,             FALSE },
  568.   { (APTR) ResignEvent,            TRUE },
  569.   { (APTR) StopObservingEvent,     FALSE },
  570.   { (APTR) StopExaminingEvent,     FALSE },
  571.  
  572.   { (APTR) MailMoveEvent,          FALSE },
  573.   { (APTR) ReloadCmailGameProc,    FALSE },
  574.   { NULL,                   FALSE }
  575. };
  576. void SetCmailMode(void)
  577.  
  578. { SetMenuSensitivity(cmailSensitivity);
  579. }
  580. /**/
  581.  
  582.  
  583. /***  DrawPosition() function
  584. ***
  585. ***  takes advantage of the MUI chessboard gadget.
  586. **/
  587. void DrawPosition(int fullRedraw, Board board)
  588.  
  589. { static int oldFlipView = -1;
  590.  
  591.   if (flipView != oldFlipView)
  592.   { set(xboardChessboard, MUIA_XBoard_FlipView, flipView);
  593.     oldFlipView = flipView;
  594.     fullRedraw = TRUE;
  595.     set(ProcToMenuitem((APTR) FlipViewProc), MUIA_Menuitem_Checked, flipView);
  596.   }
  597.  
  598.   DoMethod(xboardChessboard, MUIM_XBoard_DrawPosition, fullRedraw, board);
  599. }
  600. /**/
  601.  
  602.  
  603. /***  ModeToObject() function
  604. ***
  605. ***  Converts gamemodes into functions that initialize them
  606. **/
  607. APTR *ModeToObject(GameMode mode)
  608.  
  609. { APTR proc;
  610.  
  611.   switch(mode)
  612.   { case BeginningOfGame:
  613.       if (appData.icsActive)
  614.       { proc = (APTR) IcsClientEvent;
  615.       }
  616.       else if (appData.noChessProgram  ||
  617.            *appData.cmailGameName != NULLCHAR)
  618.       { proc = (APTR) EditGameEvent;
  619.       }
  620.       else
  621.       { proc = (APTR) MachineBlackEvent;
  622.       }
  623.       break;
  624.     case MachinePlaysBlack:
  625.       proc = (APTR) MachineBlackEvent;
  626.       break;
  627.     case MachinePlaysWhite:
  628.       proc = (APTR) MachineWhiteEvent;
  629.       break;
  630.     case TwoMachinesPlay:
  631.       proc = (APTR) TwoMachinesEvent;
  632.       break;
  633.     case EditGame:
  634.       proc = (APTR) EditGameEvent;
  635.       break;
  636.     case PlayFromGameFile:
  637.       proc = (APTR) LoadGameProc;
  638.       break;
  639.     case EditPosition:
  640.       proc = (APTR) EditPositionEvent;
  641.       break;
  642.     case IcsPlayingWhite:
  643.     case IcsPlayingBlack:
  644.     case IcsObserving:
  645.     case IcsIdle:
  646.     case IcsExamining:
  647.       proc = (APTR) IcsClientEvent;
  648.       break;
  649.     default:
  650.       return(NULL);
  651.   }
  652.  
  653.   return(ProcToMenuitem(proc));
  654. }
  655. /**/
  656.  
  657.  
  658. /***  ModeHighlight() function
  659. ***
  660. **/
  661. void ModeHighlight(void)
  662.  
  663. { static int oldPausing = FALSE;
  664.   static int oldEditPositionMode = -1;
  665.   int editPositionMode;
  666.   static GameMode oldmode = (GameMode) -1;
  667.   APTR menuitemObject;
  668.  
  669.   if (pausing != oldPausing)
  670.   { menuitemObject = ProcToMenuitem((APTR) PauseEvent);
  671.     oldPausing = pausing;
  672.     if (menuitemObject)
  673.     { if (pausing)
  674.       { set(menuitemObject, MUIA_Menuitem_Checked, TRUE);
  675.       }
  676.       else
  677.       { set(menuitemObject, MUIA_Menuitem_Checkit, FALSE);
  678.       }
  679.     }
  680.   }
  681.  
  682.   if (oldmode != gameMode  &&  (menuitemObject = ModeToObject(oldmode)))
  683.   { set(menuitemObject, MUIA_Menuitem_Checked, FALSE);
  684.   }
  685.   if ((menuitemObject = ModeToObject(gameMode)))
  686.   { set(menuitemObject, MUIA_Menuitem_Checked, TRUE);
  687.   }
  688.   oldmode = gameMode;
  689.  
  690.   editPositionMode = (gameMode == EditPosition)  ||
  691.              (gameMode == IcsExamining);
  692.   if (editPositionMode != oldEditPositionMode)
  693.   { set(xboardChessboard, MUIA_XBoard_EditPosition, editPositionMode);
  694.     oldEditPositionMode = editPositionMode;
  695.   }
  696. }
  697. /**/
  698.  
  699.  
  700. /***  GameListPopUp() function
  701. ***
  702. ***  Brings up a requester with the list of games. Receives following
  703. ***  arguments:
  704. ***
  705. ***     proc    Function to call, if user has selected a game
  706. ***     fp      File to load the game from; will be closed, if the
  707. ***             user cancels.
  708. ***     title   title to display
  709. **/
  710. typedef int (*FileProc) (FILE *, int, char *, int);
  711. _HOOK_FUNC(VOID, gameListCallback, struct Hook *hook,
  712.                    Object *gameListWin,
  713.                    va_list args)
  714. { Object *listObj;
  715.   int index;
  716.   ListGame *lg;
  717.   FileProc proc;
  718.   FILE *fp;
  719.   char *fileName;
  720.  
  721.   fileName = va_arg(args, char *);
  722.   proc = va_arg(args, FileProc);
  723.   fp = va_arg(args, FILE *);
  724.   listObj = va_arg(args, APTR);
  725.  
  726.   if (listObj)
  727.   { get(listObj, MUIA_List_Active, &index);
  728.     if (index == MUIV_List_Active_Off)
  729.     { index = 0;
  730.     }
  731.  
  732.     DoMethod(listObj, MUIM_List_GetEntry, index, &lg);
  733.     if (lg == NULL)
  734.     { listObj = NULL;
  735.     }
  736.  
  737.   }
  738.  
  739.   /*  Awake the main window.  */
  740.   set(gameListWin, MUIA_Window_Open, FALSE);
  741.   set(xboardWindow, MUIA_Window_Sleep, FALSE);
  742.  
  743.   if (listObj)
  744.   { (*proc)(fp, lg->number, fileName, TRUE);
  745.   }
  746.   else
  747.   { fclose(fp);
  748.   }
  749.  
  750.   CloseMuiWindow(gameListWin);
  751.   gameListWin = NULL;
  752.   free(fileName);
  753. }
  754. struct Hook gameListCallbackHook =
  755. { { NULL, NULL },
  756.   (HOOKFUNC) gameListCallback,
  757.   NULL,
  758.   NULL
  759. };
  760.  
  761. _HOOK_FUNC(ULONG, gameListDisp, struct Hook *hook,  /*  Called to display  */
  762.                 char **strArray,    /*  one game           */
  763.                 ListGame *lg)
  764. { static char buf[20];
  765.  
  766.   sprintf(buf, "%d", lg->number);
  767.   *strArray++ = buf;
  768.   *strArray++ = lg->gameInfo.event;
  769.   *strArray++ = lg->gameInfo.white;
  770.   *strArray++ = lg->gameInfo.black;
  771.  
  772.   return(0);
  773. }
  774. struct Hook gameListDispHook =
  775. { { NULL, NULL },
  776.   (HOOKFUNC) gameListDisp,
  777.   NULL,
  778.   NULL
  779. };
  780.  
  781.  
  782. void GameListPopUp(FileProc proc, FILE *fp, char *fileName)
  783.  
  784. { APTR listObj, okButton, cancelButton;
  785.   APTR gameListWin;
  786.   char *file;
  787.   int success = FALSE;
  788.  
  789.   if (!(file = strdup(fileName)))
  790.   { DisplayError("Cannot open file.", 0);
  791.     return;
  792.   }
  793.  
  794.   /* Create window. */
  795.   gameListWin = WindowObject,
  796.             MUIA_Window_ID, MAKE_ID('G','L','S','T'),
  797.             MUIA_Window_Title, "Game list requester",
  798.             MUIA_Window_RefWindow, xboardWindow,
  799.             WindowContents, VGroup,
  800.             Child, listObj = ListviewObject,
  801.                 MUIA_Listview_List, ListObject,
  802.                 MUIA_List_DisplayHook, &gameListDispHook,
  803.                 /* Display 4 columns, the second one (event)
  804.                  * is the most important.
  805.                  */
  806.                 MUIA_List_Format, "WEIGHT=25,WEIGHT=200,WEIGHT=100,WEIGHT=100",
  807.                 InputListFrame,
  808.                 End,
  809.             End,
  810.             Child, HGroup,
  811.                 Child, okButton = MUI_MakeObject(MUIO_Button, "Ok"),
  812.                 Child, HSpace(0),
  813.                 Child, cancelButton = MUI_MakeObject(MUIO_Button, "Cancel"),
  814.             End,
  815.             End,
  816.         End;
  817.  
  818.   if (gameListWin)
  819.   { int open;
  820.  
  821.     DoMethod(xboardApp, OM_ADDMEMBER, gameListWin);
  822.  
  823.     /* Setup hooks to call, if user closes window, selects game or hits
  824.      * a button.
  825.      *
  826.      * Looks somewhat complicated, because we want to close the window
  827.      * from within the hook: We must ensure, that it isn't an object of
  828.      * the window, which calls the hook. Instead the object must tell
  829.      * the application object to call the hook.
  830.      */
  831.     DoMethod(gameListWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  832.          gameListWin, 6, MUIM_CallHook, &gameListCallbackHook,
  833.          /* Hook arguments */
  834.          file, proc, fp, NULL);
  835.     DoMethod(listObj, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  836.          gameListWin, 6, MUIM_CallHook, &gameListCallbackHook,
  837.          /* Hook arguments */
  838.          file, proc, fp, listObj);
  839.     DoMethod(okButton, MUIM_Notify, MUIA_Pressed, FALSE,
  840.          gameListWin, 6, MUIM_CallHook, &gameListCallbackHook,
  841.          /* Hook arguments */
  842.          file, proc, fp, listObj);
  843.     DoMethod(cancelButton, MUIM_Notify, MUIA_Pressed, FALSE,
  844.          gameListWin, 6, MUIM_CallHook, &gameListCallbackHook,
  845.          /* Hook arguments */
  846.          file, proc, fp, NULL);
  847.  
  848.  
  849.     set(listObj, MUIA_List_Quiet, TRUE);
  850.     { ListGame *lg;
  851.  
  852.       for (lg = (ListGame *) gameList.head;
  853.        lg->node.succ;
  854.        lg = (ListGame *) lg->node.succ)
  855.       { DoMethod(listObj, MUIM_List_InsertSingle, lg, MUIV_List_Insert_Bottom);
  856.       }
  857.     }
  858.     set(listObj, MUIA_List_Quiet, FALSE);
  859.     set(gameListWin, MUIA_Window_Open, TRUE);
  860.     get(gameListWin, MUIA_Window_Open, &open);
  861.  
  862.     if (open)
  863.     { success = TRUE;
  864.       /* Put main window to sleep. */
  865.       set(xboardWindow, MUIA_Window_Sleep, TRUE);
  866.     }
  867.     else
  868.     { DoMethod(xboardApp, OM_REMMEMBER, gameListWin);
  869.       MUI_DisposeObject(gameListWin);
  870.     }
  871.   }
  872.  
  873.   if (!success)
  874.   { DisplayError("Cannot open window: ", ENOMEM);
  875.   }
  876. }
  877. /**/
  878.  
  879.  
  880. /***  FileNameAction() function
  881. ***
  882. ***  Brings up a file requester.
  883. **/
  884. int LoadGamePopUp(FILE *, int, char *, int);
  885.  
  886. void FileNameAction(FileProc proc, char *openMode, char *filename)
  887.  
  888. { FILE *fp;
  889.   int index = 0;
  890.   char *p;
  891.  
  892.   if ((p = strchr(filename, ',')))
  893.   { index = atoi(p+1);
  894.     *p = NULLCHAR;
  895.   }
  896.   if (!(fp = fopen(filename, openMode)))
  897.   { DisplayError("Failed to open file", errno);
  898.   }
  899.   else
  900.   { if (index == 0)
  901.     { if (proc == LoadGamePopUp  &&  appData.useGameList)
  902.       { int error;
  903.  
  904.     if ((error = GameListBuild(fp)))
  905.     { DisplayError("Cannot build game list: ", error);
  906.     }
  907.     else
  908.     { GameListPopUp(proc, fp, filename);
  909.       return;
  910.     }
  911.       }
  912.       index = 1;
  913.     }
  914.  
  915.     (void) (*proc)(fp, index, filename, FALSE);
  916.   }
  917.   ModeHighlight();
  918. }
  919. /**/
  920.  
  921.  
  922. /***  FileNamePopUp() function
  923. ***
  924. ***  Creates an ASL requester.
  925. **/
  926. void FileNamePopUp(char *title, char *deflt, char *pattern,
  927.            FileProc proc, char *openMode)
  928.  
  929. { struct FileRequester *requester;
  930.   struct Window *window;
  931.   UBYTE parsedPattern[20];
  932.   char filename[MSG_SIZ];
  933.  
  934.   if (!(requester = (struct FileRequester *) MUI_AllocAslRequest(ASL_FileRequest, NULL)))
  935.   { return;
  936.   }
  937.   ParsePatternNoCase((UBYTE *) pattern, parsedPattern, sizeof(parsedPattern));
  938.   strcpy(filename, deflt);
  939.   *PathPart((STRPTR) filename) = NULLCHAR;
  940.  
  941.   get(xboardWindow, MUIA_Window_Window, &window);
  942.  
  943.   if (MUI_AslRequestTags(requester,
  944.              ASLFR_Window, window,
  945.              ASLFR_PrivateIDCMP, TRUE,
  946.              ASLFR_SleepWindow, TRUE,
  947.              ASLFR_TitleText, title,
  948.              ASLFR_InitialFile, FilePart((STRPTR) deflt),
  949.              ASLFR_InitialDrawer, filename,
  950.              ASLFR_InitialPattern, pattern,
  951.              ASLFR_DoSaveMode, strcmp(openMode, "w") == 0,
  952.              ASLFR_RejectIcons, TRUE,
  953.              ASLFR_AcceptPattern, parsedPattern,
  954.              TAG_DONE))
  955.   { if (*requester->fr_File != NULLCHAR)
  956.     { strcpy(filename, (char *) requester->fr_Drawer);
  957.       AddPart((STRPTR) filename, requester->fr_File, sizeof(filename));
  958.       FileNameAction(proc, openMode, filename);
  959.     }
  960.   }
  961.  
  962.   MUI_FreeAslRequest(requester);
  963. }
  964. /**/
  965.  
  966.  
  967. /***  Button/menu procedures
  968. **/
  969. void ResetProc(void)
  970.  
  971. { ResetGameEvent();
  972. }
  973.  
  974. int LoadGamePopUp(FILE *f, int gameNumber, char *title, int useList)
  975.  
  976. { cmailMsgLoaded = FALSE;
  977.   return(LoadGame(f, gameNumber, title, useList));
  978. }
  979.  
  980. void LoadGameProc(void)
  981.  
  982. { FileNamePopUp("Load game file name?", "",
  983.         appData.oldSaveStyle ? "#?.game" : "#?.pgn",
  984.         LoadGamePopUp, "r");
  985. }
  986.  
  987. void LoadNextGameProc(void)
  988.  
  989. { ReloadGame(1);
  990. }
  991.  
  992. void LoadPrevGameProc(void)
  993.  
  994. { ReloadGame(-1);
  995. }
  996.  
  997. void ReloadGameProc(void)
  998.  
  999. { ReloadGame(0);
  1000. }
  1001.  
  1002.  
  1003. void LoadPositionProc(void)
  1004.  
  1005. { FileNamePopUp("Load position file name?", "",
  1006.         appData.oldSaveStyle ? "#?.pos" : "#?.fen",
  1007.         LoadPosition, "r");
  1008. }
  1009.  
  1010. void SaveGameProc(void)
  1011.  
  1012. { FileNamePopUp("Save game file name?",
  1013.         DefaultFileName(appData.oldSaveStyle ? ".game" : ".pgn"),
  1014.         appData.oldSaveStyle ? "#?.game" : "#?.pgn",
  1015.         SaveGame, "a");
  1016. }
  1017.  
  1018. void AutoSaveGame(void)
  1019.  
  1020. { SaveGameProc();
  1021. }
  1022.  
  1023. void SavePositionProc(void)
  1024.  
  1025. { FileNamePopUp("Save position file name",
  1026.         DefaultFileName(appData.oldSaveStyle ? ".pos" : ".fen"),
  1027.         appData.oldSaveStyle ? "#?.pos" : "#?.fen",
  1028.         SavePosition, "a");
  1029. }
  1030.  
  1031. void ReloadCmailGameProc(void)
  1032.  
  1033. { ReloadCmailGameEvent(FALSE);
  1034. }
  1035.  
  1036. void QuitProc(void)
  1037.  
  1038. { ExitEvent(0);
  1039. }
  1040.  
  1041. void AlwaysQueenProc(void)
  1042.  
  1043. { APTR obj;
  1044.  
  1045.   if ((obj = ProcToMenuitem((APTR) AlwaysQueenProc)))
  1046.   { get(obj, MUIA_Menuitem_Checked, &appData.alwaysPromoteToQueen);
  1047.     set(xboardChessboard, MUIA_XBoard_AlwaysPromoteToQueen,
  1048.     appData.alwaysPromoteToQueen);
  1049.   }
  1050. }
  1051.  
  1052. void AutoflagProc(void)
  1053.  
  1054. { APTR obj;
  1055.  
  1056.   if ((obj = ProcToMenuitem((APTR) AutoflagProc)))
  1057.   { get(obj, MUIA_Menuitem_Checked, &appData.autoCallFlag);
  1058.   }
  1059. }
  1060.  
  1061. void AutoobsProc(void)
  1062.  
  1063. { APTR obj;
  1064.  
  1065.   if ((obj = ProcToMenuitem((APTR) AutoobsProc)))
  1066.   { get(obj, MUIA_Menuitem_Checked, &appData.autoObserve);
  1067.   }
  1068. }
  1069.  
  1070. void AutosaveProc(void)
  1071.  
  1072. { APTR obj;
  1073.  
  1074.   if ((obj = ProcToMenuitem((APTR) AutosaveProc)))
  1075.   { get(obj, MUIA_Menuitem_Checked, &appData.autoSaveGames);
  1076.   }
  1077. }
  1078.  
  1079. void BellProc(void)
  1080.  
  1081. { APTR obj;
  1082.  
  1083.   if ((obj = ProcToMenuitem((APTR) BellProc)))
  1084.   { get(obj, MUIA_Menuitem_Checked, &appData.ringBellAfterMoves);
  1085.   }
  1086. }
  1087.  
  1088. void FlipViewProc(void)
  1089.  
  1090. { APTR obj;
  1091.  
  1092.   if ((obj = ProcToMenuitem((APTR) FlipViewProc)))
  1093.   { get(obj, MUIA_Menuitem_Checked, &flipView);
  1094.     DrawPosition(TRUE, NULL);
  1095.   }
  1096. }
  1097.  
  1098. void OldSaveStyleProc(void)
  1099.  
  1100. { APTR obj;
  1101.  
  1102.   if ((obj = ProcToMenuitem((APTR) OldSaveStyleProc)))
  1103.   { get(obj, MUIA_Menuitem_Checked, &appData.oldSaveStyle);
  1104.   }
  1105. }
  1106.  
  1107. void QuietPlayProc(void)
  1108.  
  1109. { APTR obj;
  1110.  
  1111.   if ((obj = ProcToMenuitem((APTR) QuietPlayProc)))
  1112.   { get(obj, MUIA_Menuitem_Checked, appData.quietPlay);
  1113.   }
  1114. }
  1115.  
  1116. void ShowCoordsProc(void)
  1117.  
  1118. { APTR obj;
  1119.  
  1120.   if ((obj = ProcToMenuitem((APTR) ShowCoordsProc)))
  1121.   { get(obj, MUIA_Menuitem_Checked, &appData.showCoords);
  1122.     set(xboardChessboard, MUIA_XBoard_ShowCoords, appData.showCoords);
  1123.   }
  1124. }
  1125.  
  1126. void ShowThinkingProc(void)
  1127.  
  1128. { APTR obj;
  1129.  
  1130.   if ((obj = ProcToMenuitem((APTR) ShowThinkingProc)))
  1131.   { ULONG show;
  1132.  
  1133.     get(obj, MUIA_Menuitem_Checked, &show);
  1134.     ShowThinkingEvent(show);
  1135.   }
  1136. }
  1137.  
  1138. void UseGameListProc(void)
  1139.  
  1140. { APTR obj;
  1141.  
  1142.   if ((obj = ProcToMenuitem((APTR) UseGameListProc)))
  1143.   { ULONG show;
  1144.  
  1145.     get(obj, MUIA_Menuitem_Checked, &show);
  1146.     appData.useGameList = show;
  1147.   }
  1148. }
  1149.  
  1150.  
  1151. void ErrorPopUp(char *, char *);
  1152. void AboutProc(void)
  1153.  
  1154. { char buf[MSG_SIZ*2];
  1155.  
  1156.   sprintf(buf, "%s\n\n%s\n%s\n%s\n\n%s\n%s",
  1157.       programName,
  1158.       "Copyright 1991 Digital Equipment Corporation",
  1159.       "Enhancements Copyright 1992-94 Free Software Foundation",
  1160.       "Amiga version copyright 1995 Jochen Wiedmann",
  1161.       "This program is free software and carries NO WARRANTY;",
  1162.       "see the file COPYING for more information.");
  1163.   ErrorPopUp("About AmyBoard", buf);
  1164. }
  1165. /**/
  1166.  
  1167.  
  1168. /***  EditGameInfoProc() function
  1169. ***
  1170. ***  Allows the user to edit the game's info.
  1171. **/
  1172. _HOOK_FUNC(void, EditGameInfoCallback, struct Hook *hook,
  1173.                        Object *editGameInfoWin,
  1174.                        va_list args)
  1175. { Object *eventStr;
  1176.  
  1177.   eventStr = va_arg(args, Object *);
  1178.  
  1179.   if (eventStr)
  1180.   { char *ptr;
  1181.     int result, success = TRUE;
  1182.     GameInfo newGameInfo;
  1183.     Object *siteStr, *dateStr, *roundStr, *whiteStr, *blackStr;
  1184.     Object *resultCycle, *detailStr;
  1185.  
  1186.     siteStr = va_arg(args, Object *);
  1187.     dateStr = va_arg(args, Object *);
  1188.     roundStr = va_arg(args, Object *);
  1189.     whiteStr = va_arg(args, Object *);
  1190.     blackStr = va_arg(args, Object *);
  1191.     resultCycle = va_arg(args, Object *);
  1192.     detailStr = va_arg(args, Object *);
  1193.  
  1194.     GameListInitGameInfo(&newGameInfo);
  1195.  
  1196.     get(eventStr, MUIA_String_Contents, &ptr);
  1197.     if (*ptr && !(newGameInfo.event = StrSave(ptr))) success = FALSE;
  1198.     get(siteStr, MUIA_String_Contents, &ptr);
  1199.     if (*ptr && !(newGameInfo.site = StrSave(ptr))) success = FALSE;
  1200.     get(dateStr, MUIA_String_Contents, &ptr);
  1201.     if (*ptr && !(newGameInfo.date = StrSave(ptr))) success = FALSE;
  1202.     get(roundStr, MUIA_String_Contents, &ptr);
  1203.     if (*ptr && !(newGameInfo.round = StrSave(ptr))) success = FALSE;
  1204.     get(whiteStr, MUIA_String_Contents, &ptr);
  1205.     if (*ptr && !(newGameInfo.white = StrSave(ptr))) success = FALSE;
  1206.     get(blackStr, MUIA_String_Contents, &ptr);
  1207.     if (*ptr && !(newGameInfo.black = StrSave(ptr))) success = FALSE;
  1208.     get(detailStr, MUIA_String_Contents, &ptr);
  1209.     if (*ptr && !(newGameInfo.resultDetails = StrSave(ptr))) success = FALSE;
  1210.     get(resultCycle, MUIA_Cycle_Active, &result);
  1211.     switch(result)
  1212.     { case 0:
  1213.     newGameInfo.result = WhiteWins;
  1214.     break;
  1215.       case 1:
  1216.     newGameInfo.result = GameIsDrawn;
  1217.     break;
  1218.       case 2:
  1219.     newGameInfo.result = BlackWins;
  1220.     break;
  1221.       default:
  1222.     newGameInfo.result = GameUnfinished;
  1223.     break;
  1224.     }
  1225.  
  1226.     if (success)
  1227.     {
  1228.       ClearGameInfo(&gameInfo);
  1229. #if __STDC__
  1230.       gameInfo = newGameInfo;
  1231. #else
  1232.       memcpy(&gameInfo, &newGameInfo, sizeof(GameInfo));
  1233. #endif
  1234.     }
  1235.     else
  1236.     { DisplayError("Cannot init game info: ", ENOMEM);
  1237.     }
  1238.   }
  1239.  
  1240.   /* Awake the main window. */
  1241.   set(editGameInfoWin, MUIA_Window_Open, FALSE);
  1242.   set(xboardWindow, MUIA_Window_Sleep, FALSE); 
  1243.   CloseMuiWindow(editGameInfoWin);
  1244. }
  1245. struct Hook editGameInfoCallbackHook =
  1246. { { NULL, NULL },
  1247.   (HOOKFUNC) EditGameInfoCallback,
  1248.   NULL,
  1249.   NULL
  1250. };
  1251.  
  1252.  
  1253. void EditGameInfoProc(void)
  1254.  
  1255. { static char *resultStrings[] =
  1256.   { "White wins", "Drawn", "Black wins", "Unfinished", NULL
  1257.   };
  1258.   int result;
  1259.   Object *okButton, *cancelButton;
  1260.   Object *editGameInfoWin;
  1261.   Object *eventStr, *siteStr, *dateStr, *roundStr, *whiteStr, *blackStr;
  1262.   Object *resultCycle, *detailStr;
  1263.  
  1264.  
  1265.   switch (gameInfo.result)
  1266.   { case WhiteWins:
  1267.       result = 0;
  1268.       break;
  1269.     case BlackWins:
  1270.       result = 1;
  1271.       break;
  1272.     case GameIsDrawn:
  1273.       result = 2;
  1274.       break;
  1275.     default:
  1276.       result = 3;
  1277.       break;
  1278.   }
  1279.  
  1280.  
  1281.   /* Create window */
  1282.   editGameInfoWin = WindowObject,
  1283.               MUIA_Window_ID, MAKE_ID('I','N','F','E'),
  1284.               MUIA_Window_Title, "Edit Game Info",
  1285.               MUIA_Window_RefWindow, xboardWindow,
  1286.               WindowContents, VGroup,
  1287.               Child, ColGroup(2),
  1288.                   GroupFrameT("Game Info"),
  1289.                   Child, Label2("Event:"),
  1290.                   Child, eventStr = StringObject,
  1291.                   StringFrame,
  1292.                   MUIA_String_Contents, gameInfo.event,
  1293.                   MUIA_String_MaxLen, MSG_SIZ,
  1294.                   End,
  1295.                   Child, Label2("Site:"),
  1296.                   Child, siteStr = StringObject,
  1297.                   StringFrame,
  1298.                   MUIA_String_Contents, gameInfo.site,
  1299.                   MUIA_String_MaxLen, MSG_SIZ,
  1300.                   End,
  1301.                   Child, Label2("Date:"),
  1302.                   Child, dateStr = StringObject,
  1303.                   StringFrame,
  1304.                   MUIA_String_Contents, gameInfo.date,
  1305.                   MUIA_String_MaxLen, MSG_SIZ,
  1306.                   End,
  1307.                   Child, Label2("Round:"),
  1308.                   Child, roundStr = StringObject,
  1309.                   StringFrame,
  1310.                   MUIA_String_Contents, gameInfo.round,
  1311.                   MUIA_String_MaxLen, MSG_SIZ,
  1312.                   End,
  1313.                   Child, Label2("White:"),
  1314.                   Child, whiteStr = StringObject,
  1315.                   StringFrame,
  1316.                   MUIA_String_Contents, gameInfo.white,
  1317.                   MUIA_String_MaxLen, MSG_SIZ,
  1318.                   End,
  1319.                   Child, Label2("Black:"),
  1320.                   Child, blackStr = StringObject,
  1321.                   StringFrame,
  1322.                   MUIA_String_Contents, gameInfo.black,
  1323.                   MUIA_String_MaxLen, MSG_SIZ,
  1324.                   End,
  1325.                   Child, Label2("Result:"),
  1326.                   Child, resultCycle = MUI_MakeObject(MUIO_Cycle, NULL, resultStrings),
  1327.                   Child, Label2("Details:"),
  1328.                   Child, detailStr = StringObject,
  1329.                   StringFrame,
  1330.                   MUIA_String_Contents, gameInfo.resultDetails,
  1331.                   MUIA_String_MaxLen, MSG_SIZ,
  1332.                   End,
  1333.               End,
  1334.               Child, HGroup,
  1335.                   Child, okButton = MUI_MakeObject(MUIO_Button, "Ok"),
  1336.                   Child, HSpace(0),
  1337.                   Child, cancelButton = MUI_MakeObject(MUIO_Button, "Cancel"),
  1338.               End,
  1339.               End,
  1340.           End;
  1341.  
  1342.  
  1343.   if (editGameInfoWin)
  1344.   { int open;
  1345.  
  1346.     DoMethod(xboardApp, OM_ADDMEMBER, editGameInfoWin);
  1347.  
  1348.     /* Setup hooks to call, if user closes window or hits a button.
  1349.      */
  1350.     DoMethod(editGameInfoWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  1351.          editGameInfoWin, 3, MUIM_CallHook, &editGameInfoCallbackHook,
  1352.          /* Hookm arguments */
  1353.          NULL);
  1354.     DoMethod(cancelButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1355.          editGameInfoWin, 3, MUIM_CallHook, &editGameInfoCallbackHook,
  1356.          /* Hook arguments */
  1357.          NULL);
  1358.     DoMethod(okButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1359.          editGameInfoWin, 10, MUIM_CallHook, &editGameInfoCallbackHook,
  1360.          /* Hook arguments */
  1361.          eventStr, siteStr, dateStr, roundStr, whiteStr, blackStr,
  1362.          resultCycle, detailStr);
  1363.  
  1364.     DoMethod(editGameInfoWin, MUIM_Window_SetCycleChain, eventStr,
  1365.          siteStr, dateStr, roundStr, whiteStr, blackStr,
  1366.          resultCycle, detailStr, NULL);
  1367.     DoMethod(eventStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1368.          editGameInfoWin, 3,
  1369.          MUIM_Set, MUIA_Window_ActiveObject, siteStr);      
  1370.     DoMethod(siteStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1371.          editGameInfoWin, 3,
  1372.          MUIM_Set, MUIA_Window_ActiveObject, dateStr);
  1373.     DoMethod(dateStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1374.          editGameInfoWin, 3,
  1375.          MUIM_Set, MUIA_Window_ActiveObject, roundStr);
  1376.     DoMethod(roundStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1377.          editGameInfoWin, 3,
  1378.          MUIM_Set, MUIA_Window_ActiveObject, whiteStr);
  1379.     DoMethod(whiteStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1380.          editGameInfoWin, 3,
  1381.          MUIM_Set, MUIA_Window_ActiveObject, blackStr);
  1382.     DoMethod(blackStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1383.          editGameInfoWin, 3,
  1384.          MUIM_Set, MUIA_Window_ActiveObject, detailStr);
  1385.     DoMethod(detailStr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  1386.          editGameInfoWin, 3,
  1387.          MUIM_Set, MUIA_Window_ActiveObject, eventStr);
  1388.     set(editGameInfoWin, MUIA_Window_Open, TRUE);
  1389.     get(editGameInfoWin, MUIA_Window_Open, &open);
  1390.     if (open)
  1391.     { /* Put main window to sleep. */
  1392.       set(xboardWindow, MUIA_Window_Sleep, TRUE);
  1393.       return;
  1394.     }
  1395.  
  1396.  
  1397.     CloseMuiWindow(editGameInfoWin);
  1398.   }
  1399.  
  1400.   DisplayError("Cannot open window: ", ENOMEM);
  1401. }
  1402.  
  1403. /**/
  1404.  
  1405.      
  1406. /***  Display functions
  1407. ***
  1408. ***  Error messages and similar
  1409. **/
  1410. void ErrorPopUp(char *title, char *label)
  1411.  
  1412. { MUI_RequestA(xboardApp, xboardWindow, 0, title, "Ok", label, NULL);
  1413. }
  1414.  
  1415. void DisplayMessage(char *message, char *extMessage)
  1416.  
  1417. { set(xboardText, MUIA_Text_Contents, message);
  1418.   set(xboardExtText, MUIA_Floattext_Text, extMessage);
  1419. }
  1420.  
  1421. void DisplayTitle(char *text)
  1422.  
  1423. { char title[MSG_SIZ];
  1424.   char *icon;
  1425.  
  1426.   if (text == NULL)
  1427.   { text = "";
  1428.   }
  1429.  
  1430.   /*
  1431.   if (appData.titleInWindow)
  1432.   {
  1433.   }
  1434.   */
  1435.   if (*text != NULLCHAR)
  1436.   { sprintf(title, "%s: %s", programName, text);
  1437.   }
  1438.   else if (appData.icsActive)
  1439.   { sprintf(title, "%s: %s", programName, appData.icsHost);
  1440.   }
  1441.   else if (*appData.cmailGameName != NULLCHAR)
  1442.   { sprintf(title, "%s: CMail", programName);
  1443.   }
  1444.   else if (appData.noChessProgram)
  1445.   { sprintf(title, "%s", programName);
  1446.   }
  1447.   else
  1448.   { if (StrStr(appData.firstChessProgram, "gnuchess"))
  1449.     { sprintf(title, "%s: GNU Chess", programName);
  1450.     }
  1451.     else
  1452.     { sprintf(title, "%s: %s", programName,
  1453.           FilePart((STRPTR) appData.firstChessProgram));
  1454.     }
  1455.   }
  1456.  
  1457.   get(xboardWindow, MUIA_Window_Title, &icon);
  1458.   if (strcmp(title, icon) != 0)
  1459.   { if ((icon = strdup(title)))
  1460.     { set(xboardWindow, MUIA_Window_Title, icon);
  1461.     }
  1462.   }
  1463. }
  1464.  
  1465. void DisplayError(char *message, int error)
  1466.  
  1467. { extern char *sys_errlist[];
  1468.   char buf[MSG_SIZ];
  1469.  
  1470.   if (error == 0)
  1471.   { if (appData.debugMode || appData.matchMode)
  1472.     { fprintf(stderr, "%s: %s\n", programName, message);
  1473.     }
  1474.     ErrorPopUp("Error", message);
  1475.   }
  1476.   else
  1477.   { if (appData.debugMode  ||  appData.matchMode)
  1478.     { fprintf(stderr, "%s: %s: %s\n",
  1479.           programName, message, sys_errlist[error]);
  1480.     }
  1481.     sprintf(buf, "%s: %s", message, sys_errlist[error]);
  1482.     ErrorPopUp("Error", buf);
  1483.   }
  1484. }
  1485.  
  1486. void DisplayFatalError(char *message, int error, int status)
  1487.  
  1488. { extern char *sys_errlist[];
  1489.   char buf[MSG_SIZ];
  1490.  
  1491.   if (error == 0)
  1492.   { fprintf(stderr, "%s: %s\n", programName, message);
  1493.     ErrorPopUp("Fatal Error", message);
  1494.   }
  1495.   else
  1496.   { fprintf(stderr, "%s: %s: %s\n",
  1497.         programName, message, sys_errlist[error]);
  1498.     sprintf(buf, "%s: %s", message, sys_errlist[error]);
  1499.     ErrorPopUp("Fatal Error", buf);
  1500.   }
  1501.   ExitEvent(status);
  1502. }
  1503.  
  1504. void DisplayInformation(char *message)
  1505.  
  1506. { ErrorPopUp("Information", message);
  1507. }
  1508.  
  1509. void RingBell(void)
  1510.  
  1511. { struct Screen *scrn;
  1512.  
  1513.   get(xboardWindow, MUIA_Window_Screen, &scrn);
  1514.   DisplayBeep(scrn);
  1515. }
  1516.  
  1517. void EchoOn(void)
  1518.  
  1519. { /* not implemented */
  1520. }
  1521.  
  1522. void EchoOff(void)
  1523.  
  1524. { /* not implemented */
  1525. }
  1526.  
  1527. void Raw(void)
  1528.  
  1529. { /* not implemented */
  1530. }
  1531. /**/
  1532.  
  1533.  
  1534. /***  UserName() function
  1535. **/
  1536. char *UserName(void)
  1537.  
  1538. { char *ptr;
  1539.  
  1540.   if ((ptr = getenv("USERNAME")))
  1541.   { return(ptr);
  1542.   }
  1543.   return("Unknown user");
  1544. }
  1545. /**/
  1546.  
  1547.  
  1548. /***  HostName() function
  1549. ***/
  1550. char *HostName(void)
  1551.  
  1552. { char *ptr;
  1553.  
  1554.   if ((ptr = getenv("HOSTNAME")))
  1555.   { return(ptr);
  1556.   }
  1557.   return("Unknown host");
  1558. }
  1559. /**/
  1560.  
  1561.  
  1562. /***  CreateMUIApp() function
  1563. ***
  1564. ***  Creates the GUI.
  1565. **/
  1566. typedef void (*menuEventFunc) (void);
  1567. _HOOK_FUNC(VOID, menuCallback, struct Hook *hook,
  1568.                    Object *obj,
  1569.                    menuEventFunc *func)
  1570. { if (func)
  1571.   { (*func)();
  1572.   }
  1573. }
  1574.  
  1575. struct Hook menuCallbackHook =
  1576. { { NULL, NULL },
  1577.   (HOOKFUNC) menuCallback,
  1578.   NULL,
  1579.   NULL
  1580. };
  1581.  
  1582.  
  1583. void CreateMUIApp(void)
  1584.  
  1585. { int squareSize = 0;
  1586.   APTR lowerButton, llowerButton, higherButton, hhigherButton, pauseButton;
  1587.  
  1588.   if (StrCaseCmp((STRPTR) appData.boardSize, (STRPTR) "small") == 0)
  1589.   { squareSize = 40;
  1590.   }
  1591.   else if (StrCaseCmp((STRPTR) appData.boardSize, (STRPTR) "medium") == 0)
  1592.   { squareSize = 64;
  1593.   }
  1594.   else if (StrCaseCmp((STRPTR) appData.boardSize, (STRPTR) "large") == 0)
  1595.   { squareSize = 80;
  1596.   }
  1597.  
  1598.   xboardApp = ApplicationObject,
  1599.         MUIA_Application_Title,       "AmyBoard",
  1600.         MUIA_Application_Version,     VERSTAG,
  1601.         MUIA_Application_Copyright,   "© 1995, Jochen Wiedmann",
  1602.         MUIA_Application_Author,      "Jochen Wiedmann",
  1603.         MUIA_Application_Description, "The GNU chess interface for the Amiga",
  1604.         MUIA_Application_Base,        "AmyBoard",
  1605.         SubWindow, xboardWindow = WindowObject,
  1606.         MUIA_Window_Title,  programName,
  1607.         MUIA_Window_ID,     MAKE_ID('M','A','I','N'),
  1608.         MUIA_Window_Menustrip, xboardMenu = MUI_MakeObject(MUIO_MenustripNM, xboardNewMenu, 0),
  1609.         WindowContents, HGroup,
  1610.             Child, xboardChessboard = XBoardObject(
  1611.             MUIA_Frame, MUIV_Frame_InputList,
  1612.             MUIA_Weight, 400,
  1613.             MUIA_XBoard_SquareWidth, squareSize,
  1614.             MUIA_XBoard_SquareHeight, squareSize,
  1615.             MUIA_XBoard_FlipView, appData.flipView,
  1616.             MUIA_XBoard_ShowCoords, appData.showCoords,
  1617.             MUIA_XBoard_LightSquarePen, appData.lightSquareColor,
  1618.             MUIA_XBoard_DarkSquarePen, appData.darkSquareColor,
  1619.             MUIA_XBoard_WhitePiecePen, appData.whitePieceColor,
  1620.             MUIA_XBoard_BlackPiecePen, appData.blackPieceColor,
  1621.             MUIA_XBoard_BitmapDirectory, appData.bitmapDirectory,
  1622.             End,
  1623.             Child, VGroup,
  1624.             MUIA_Weight, 100,
  1625.             Child, HGroup,
  1626.                 Child, llowerButton = SimpleButton("<<"),
  1627.                 Child, lowerButton = KeyButton("<", "<"),
  1628.                 Child, pauseButton = KeyButton("P", "p"),
  1629.                 Child, higherButton = KeyButton(">", ">"),
  1630.                 Child, hhigherButton = SimpleButton(">>"),
  1631.             End,
  1632.             Child, xboardUpperTime = TextObject,
  1633.                 TextFrame,
  1634.             End,
  1635.             Child, HGroup,
  1636.                 Child, HSpace(0),
  1637.                 Child, TextObject,
  1638.                 MUIA_Text_Contents, ":",
  1639.                 End,
  1640.                 Child, HSpace(0),
  1641.             End,
  1642.             Child, xboardLowerTime = TextObject,
  1643.                 TextFrame,
  1644.             End,
  1645.             Child, xboardText = TextObject,
  1646.                 TextFrame,
  1647.             End,
  1648.             Child, xboardExtText = FloattextObject,
  1649.                 TextFrame,
  1650.             End,
  1651.             Child, VSpace(0),
  1652.             End,
  1653.         End,
  1654.         End,
  1655.     End;
  1656.  
  1657.   if (!xboardApp)
  1658.   { DisplayFatalError("Can't create application.", 0, 10);
  1659.   }
  1660.  
  1661.   set(ProcToMenuitem((APTR) AlwaysQueenProc), MUIA_Menuitem_Checked,
  1662.       appData.alwaysPromoteToQueen);
  1663.   set(ProcToMenuitem((APTR) AutoflagProc), MUIA_Menuitem_Checked,
  1664.       appData.autoCallFlag);
  1665.   set(ProcToMenuitem((APTR) AutoobsProc), MUIA_Menuitem_Checked,
  1666.       appData.autoObserve);
  1667.   set(ProcToMenuitem((APTR) AutosaveProc), MUIA_Menuitem_Checked,
  1668.       appData.autoSaveGames);
  1669.   set(ProcToMenuitem((APTR) BellProc), MUIA_Menuitem_Checked,
  1670.       appData.ringBellAfterMoves);
  1671.   set(ProcToMenuitem((APTR) OldSaveStyleProc), MUIA_Menuitem_Checked,
  1672.       appData.oldSaveStyle);
  1673.   set(ProcToMenuitem((APTR) QuietPlayProc), MUIA_Menuitem_Checked,
  1674.       appData.quietPlay);
  1675.   set(ProcToMenuitem((APTR) ShowCoordsProc), MUIA_Menuitem_Checked,
  1676.       appData.showCoords);
  1677.   set(ProcToMenuitem((APTR) ShowThinkingProc), MUIA_Menuitem_Checked,
  1678.       appData.showThinking);
  1679.   set(ProcToMenuitem((APTR) UseGameListProc), MUIA_Menuitem_Checked,
  1680.       appData.useGameList);
  1681.  
  1682.   { ULONG open;
  1683.  
  1684.     set(xboardWindow, MUIA_Window_Open, TRUE);
  1685.  
  1686.     get(xboardWindow, MUIA_Window_Open, &open);
  1687.     if (!open)
  1688.     { DisplayFatalError("Can't open window.", 0, 10);
  1689.     }
  1690.   }
  1691.  
  1692.   DoMethod(xboardWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  1693.        xboardApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  1694.   DoMethod(xboardWindow, MUIM_Notify, MUIA_Window_MenuAction, MUIV_EveryTime,
  1695.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, MUIV_TriggerValue);
  1696.   DoMethod(llowerButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1697.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, ToStartEvent);
  1698.   DoMethod(lowerButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1699.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, BackwardEvent);
  1700.   DoMethod(pauseButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1701.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, PauseEvent);
  1702.   DoMethod(higherButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1703.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, ForwardEvent);
  1704.   DoMethod(hhigherButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1705.        xboardApp, 3, MUIM_CallHook, &menuCallbackHook, ToEndEvent);
  1706.   DoMethod(xboardLowerTime, MUIM_Notify, MUIA_Pressed, FALSE,
  1707.        xboardApp, 3, MUIM_CallHook, &CallFlagEvent);
  1708.   DoMethod(xboardUpperTime, MUIM_Notify, MUIA_Pressed, FALSE,
  1709.        xboardApp, 3, MUIM_CallHook, &CallFlagEvent);
  1710. }
  1711. /**/
  1712.  
  1713.  
  1714. /***  Timer display functions
  1715. **/
  1716. void DisplayTimerLabel(Boolean white, LONG timer, int highlight)
  1717.  
  1718. { APTR obj;
  1719.   char buf[MSG_SIZ];
  1720.   char *ptr;
  1721.  
  1722.   if ((white && !flipView)  ||
  1723.       (!white  &&  flipView))
  1724.   { obj = xboardLowerTime;
  1725.   }
  1726.   else
  1727.   { obj = xboardUpperTime;
  1728.   }
  1729.  
  1730.   ptr = buf;
  1731.   if (highlight)
  1732.   { *ptr++ = '\033';
  1733.     *ptr++ = 'b';
  1734.   }
  1735.  
  1736.   if (appData.clockMode)
  1737.   { sprintf(ptr, "%s", TimeString(timer));
  1738.   }
  1739.   else
  1740.   { *ptr++ = '-';
  1741.     *ptr++ = NULLCHAR;
  1742.   }
  1743.   set(obj, MUIA_Text_Contents, buf);
  1744. }
  1745.  
  1746. void DisplayWhiteClock(LONG timeRemaining, int highlight)
  1747.  
  1748. { DisplayTimerLabel(TRUE, timeRemaining, highlight);
  1749. }
  1750.  
  1751. void DisplayBlackClock(LONG timeRemaining, int highlight)
  1752.  
  1753. { DisplayTimerLabel(FALSE, timeRemaining, highlight);
  1754. }
  1755. /**/
  1756.  
  1757.  
  1758. /***  Comment section
  1759. ***
  1760. ***  Functions to display and edit a comment.
  1761. ***
  1762. ***  We open a separate MUI window for comments and add it to the
  1763. ***  application object. Pressing a button within the window or
  1764. ***  closing it will result in calling a hook. (CommentCallback or
  1765. ***  EditCommentCallback, respectively.)
  1766. ***
  1767. **/
  1768. APTR CommentCreate(STRPTR name, STRPTR text,
  1769.            ULONG mutable, struct Hook *hook, ULONG index)
  1770.  
  1771. { APTR commentWindow;
  1772.   /* Suppress warnings on uninitialized variables. */
  1773.   APTR okButton = NULL, cancelButton = NULL, editButton = NULL,
  1774.        clearButton = NULL, textObject = NULL;
  1775.   STRPTR title;
  1776.  
  1777.   if (!(title = (STRPTR) strdup((char *) name)))
  1778.   { return(NULL);
  1779.   }
  1780.  
  1781.   if (mutable)
  1782.   { commentWindow = WindowObject,
  1783.         MUIA_Window_ID, MAKE_ID('C','M','N','T'),
  1784.         MUIA_Window_Title, title,
  1785.         WindowContents, VGroup,
  1786.         Child, textObject = String(text, 4096),
  1787.         Child, HGroup,
  1788.             Child, okButton = KeyButton("ok", "o"),
  1789.             Child, clearButton = KeyButton("clear", "c"),
  1790.             Child, cancelButton = KeyButton("abort", "a"),
  1791.         End,
  1792.         End,
  1793.     End;
  1794.   }
  1795.   else
  1796.   { commentWindow = WindowObject,
  1797.         MUIA_Window_ID, MAKE_ID('C','M','N','T'),
  1798.         MUIA_Window_Title, title,
  1799.         WindowContents, VGroup,
  1800.         Child, textObject = TextObject,
  1801.             MUIA_Text_Contents, text,
  1802.             TextFrame,
  1803.         End,
  1804.         Child, HGroup,
  1805.             Child, editButton = KeyButton("edit", "e"),
  1806.             Child, cancelButton = KeyButton("close", "c"),
  1807.         End,
  1808.         End,
  1809.     End;
  1810.   }
  1811.  
  1812.  
  1813.   if (commentWindow)
  1814.   { ULONG open;
  1815.  
  1816.     DoMethod(xboardApp, OM_ADDMEMBER, commentWindow);
  1817.     set(commentWindow, MUIA_Window_Open, TRUE);
  1818.     get(commentWindow, MUIA_Window_Open, &open);
  1819.     if (!open)
  1820.     { DoMethod(xboardApp, OM_REMMEMBER, commentWindow);
  1821.       MUI_DisposeObject(commentWindow);
  1822.       commentWindow = NULL;
  1823.     }
  1824.     else
  1825.     { DoMethod(commentWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  1826.            commentWindow, 3, MUIM_CallHook, hook, (LONG) 0);
  1827.       if (mutable)
  1828.       { DoMethod(okButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1829.          textObject, 4, MUIM_CallHook, hook, (LONG) 1, (ULONG) index);
  1830.     DoMethod(clearButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1831.          textObject, 3, MUIM_CallHook, hook, (LONG) -1);
  1832.     DoMethod(cancelButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1833.          textObject, 3, MUIM_CallHook, hook, (LONG) 0);
  1834.       }
  1835.       else
  1836.       { DoMethod(editButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1837.          commentWindow, 3, MUIM_CallHook, hook, (LONG) 1);
  1838.     DoMethod(cancelButton, MUIM_Notify, MUIA_Pressed, FALSE,
  1839.          commentWindow, 3, MUIM_CallHook, hook, (LONG) 0);
  1840.       }
  1841.     }
  1842.   }
  1843.  
  1844.   return(commentWindow);
  1845. }
  1846.  
  1847. _HOOK_FUNC(VOID, CommentCallback, struct Hook *Hook,
  1848.                   APTR obj,
  1849.                   va_list args)
  1850.  
  1851. { ULONG edit;
  1852.  
  1853.   edit = va_arg(args, ULONG);
  1854.   if (edit)
  1855.   { EditCommentEvent();
  1856.   }
  1857.   CommentPopDown();
  1858. }
  1859. const struct Hook commentCallbackHook =
  1860. { { NULL, NULL },
  1861.   (HOOKFUNC) CommentCallback,
  1862.   NULL,
  1863.   NULL
  1864. };
  1865.  
  1866. APTR commentWindow  = NULL;
  1867. void CommentPopUp(char *title, char *text)
  1868.  
  1869. { CommentPopDown();
  1870.   commentWindow = CommentCreate((STRPTR) title, (STRPTR) text, FALSE,
  1871.                 (struct Hook *) &commentCallbackHook, 0);
  1872. }
  1873.  
  1874. void CommentPopDown(void)
  1875.  
  1876. { if (commentWindow)
  1877.   { CloseMuiWindow(commentWindow);
  1878.     commentWindow = NULL;
  1879.   }
  1880. }
  1881.  
  1882. _HOOK_FUNC(VOID, EditCommentCallback, struct Hook *hook,
  1883.                       APTR obj,
  1884.                       va_list args)
  1885.  
  1886. { LONG done;
  1887.  
  1888.   done = va_arg(args, LONG);
  1889.   switch(done)
  1890.   { case 1:
  1891.       { STRPTR val;
  1892.     ULONG index;
  1893.  
  1894.     index = va_arg(args, ULONG);
  1895.     get(obj, MUIA_String_Contents, &val);
  1896.     ReplaceComment(index, (char *) val);
  1897.     EditCommentPopDown();
  1898.       }
  1899.       break;
  1900.     case -1:
  1901.       set(obj, MUIA_String_Contents, NULL);
  1902.       break;
  1903.     default:
  1904.       EditCommentPopDown();
  1905.       break;
  1906.   }
  1907. }
  1908. const struct Hook editCommentCallbackHook =
  1909. { { NULL, NULL },
  1910.   (HOOKFUNC) EditCommentCallback,
  1911.   NULL,
  1912.   NULL
  1913. };
  1914.  
  1915. APTR editCommentWindow  = NULL;
  1916. void EditCommentPopUp(int index, char *title, char *text)
  1917.  
  1918. { EditCommentPopDown();
  1919.   editCommentWindow = CommentCreate((STRPTR) title, (STRPTR) text, TRUE,
  1920.                     (struct Hook *) &editCommentCallbackHook,
  1921.                     index);
  1922. }
  1923.  
  1924. void EditCommentPopDown(void)
  1925.  
  1926. { if (editCommentWindow)
  1927.   { CloseMuiWindow(editCommentWindow);
  1928.     editCommentWindow = NULL;
  1929.   }
  1930. }
  1931. /**/
  1932.  
  1933.  
  1934. /*** CmailSigHandlerCallBack() function
  1935. **/
  1936. void CmailSigHandlerCallBack(InputSourceRef isr, char *message, int count, int error)
  1937.  
  1938. { ReloadCmailGameEvent(TRUE);
  1939. }
  1940. /**/
  1941.