2 * WinBoard.c -- Windows NT front end to XBoard
\r
4 * Copyright 1991 by Digital Equipment Corporation, Maynard,
\r
7 * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
\r
8 * 2007, 2008, 2009 Free Software Foundation, Inc.
\r
10 * Enhancements Copyright 2005 Alessandro Scotti
\r
12 * XBoard borrows its colors and the bitmaps.xchess bitmap set from XChess,
\r
13 * which was written and is copyrighted by Wayne Christopher.
\r
15 * The following terms apply to Digital Equipment Corporation's copyright
\r
16 * interest in XBoard:
\r
17 * ------------------------------------------------------------------------
\r
18 * All Rights Reserved
\r
20 * Permission to use, copy, modify, and distribute this software and its
\r
21 * documentation for any purpose and without fee is hereby granted,
\r
22 * provided that the above copyright notice appear in all copies and that
\r
23 * both that copyright notice and this permission notice appear in
\r
24 * supporting documentation, and that the name of Digital not be
\r
25 * used in advertising or publicity pertaining to distribution of the
\r
26 * software without specific, written prior permission.
\r
28 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
\r
29 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
\r
30 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
\r
31 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
\r
32 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
\r
33 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
\r
35 * ------------------------------------------------------------------------
\r
37 * The following terms apply to the enhanced version of XBoard
\r
38 * distributed by the Free Software Foundation:
\r
39 * ------------------------------------------------------------------------
\r
41 * GNU XBoard is free software: you can redistribute it and/or modify
\r
42 * it under the terms of the GNU General Public License as published by
\r
43 * the Free Software Foundation, either version 3 of the License, or (at
\r
44 * your option) any later version.
\r
46 * GNU XBoard is distributed in the hope that it will be useful, but
\r
47 * WITHOUT ANY WARRANTY; without even the implied warranty of
\r
48 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\r
49 * General Public License for more details.
\r
51 * You should have received a copy of the GNU General Public License
\r
52 * along with this program. If not, see http://www.gnu.org/licenses/. *
\r
54 *------------------------------------------------------------------------
\r
55 ** See the file ChangeLog for a revision history. */
\r
59 #include <windows.h>
\r
60 #include <winuser.h>
\r
61 #include <winsock.h>
\r
62 #include <commctrl.h>
\r
68 #include <sys/stat.h>
\r
71 #include <commdlg.h>
\r
73 #include <richedit.h>
\r
74 #include <mmsystem.h>
\r
83 #include "frontend.h"
\r
84 #include "backend.h"
\r
85 #include "winboard.h"
\r
87 #include "wclipbrd.h"
\r
88 #include "woptions.h"
\r
89 #include "wsockerr.h"
\r
90 #include "defaults.h"
\r
94 //void InitEngineUCI( const char * iniDir, ChessProgramState * cps );
\r
97 void mysrandom(unsigned int seed);
\r
99 extern int whiteFlag, blackFlag;
\r
100 Boolean flipClock = FALSE;
\r
101 extern HANDLE chatHandle[];
\r
102 extern int ics_type;
\r
104 void DisplayHoldingsCount(HDC hdc, int x, int y, int align, int copyNumber);
\r
105 VOID NewVariantPopup(HWND hwnd);
\r
106 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
\r
107 /*char*/int promoChar));
\r
108 void AnimateAtomicCapture(int fromX, int fromY, int toX, int toY, int nFrames);
\r
109 void DisplayMove P((int moveNumber));
\r
110 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
\r
111 void ChatPopUp P(());
\r
113 ChessSquare piece;
\r
114 POINT pos; /* window coordinates of current pos */
\r
115 POINT lastpos; /* window coordinates of last pos - used for clipping */
\r
116 POINT from; /* board coordinates of the piece's orig pos */
\r
117 POINT to; /* board coordinates of the piece's new pos */
\r
120 static AnimInfo animInfo = { EmptySquare, {-1,-1}, {-1,-1}, {-1,-1} };
\r
123 POINT start; /* window coordinates of start pos */
\r
124 POINT pos; /* window coordinates of current pos */
\r
125 POINT lastpos; /* window coordinates of last pos - used for clipping */
\r
126 POINT from; /* board coordinates of the piece's orig pos */
\r
129 static DragInfo dragInfo = { {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1} };
\r
132 POINT sq[2]; /* board coordinates of from, to squares */
\r
135 static HighlightInfo highlightInfo = { {{-1, -1}, {-1, -1}} };
\r
136 static HighlightInfo premoveHighlightInfo = { {{-1, -1}, {-1, -1}} };
\r
138 typedef struct { // [HGM] atomic
\r
139 int fromX, fromY, toX, toY, radius;
\r
142 static ExplodeInfo explodeInfo;
\r
144 /* Window class names */
\r
145 char szAppName[] = "WinBoard";
\r
146 char szConsoleName[] = "WBConsole";
\r
148 /* Title bar text */
\r
149 char szTitle[] = "WinBoard";
\r
150 char szConsoleTitle[] = "I C S Interaction";
\r
153 char *settingsFileName;
\r
154 Boolean saveSettingsOnExit;
\r
155 char installDir[MSG_SIZ];
\r
156 int errorExitStatus;
\r
158 BoardSize boardSize;
\r
159 Boolean chessProgram;
\r
160 //static int boardX, boardY;
\r
161 int minX, minY; // [HGM] placement: volatile limits on upper-left corner
\r
162 int squareSize, lineGap, minorSize;
\r
163 static int winW, winH;
\r
164 static RECT messageRect, whiteRect, blackRect, leftLogoRect, rightLogoRect; // [HGM] logo
\r
165 static int logoHeight = 0;
\r
166 static char messageText[MESSAGE_TEXT_MAX];
\r
167 static int clockTimerEvent = 0;
\r
168 static int loadGameTimerEvent = 0;
\r
169 static int analysisTimerEvent = 0;
\r
170 static DelayedEventCallback delayedTimerCallback;
\r
171 static int delayedTimerEvent = 0;
\r
172 static int buttonCount = 2;
\r
173 char *icsTextMenuString;
\r
175 char *firstChessProgramNames;
\r
176 char *secondChessProgramNames;
\r
178 #define PALETTESIZE 256
\r
180 HINSTANCE hInst; /* current instance */
\r
181 Boolean alwaysOnTop = FALSE;
\r
183 COLORREF lightSquareColor, darkSquareColor, whitePieceColor,
\r
184 blackPieceColor, highlightSquareColor, premoveHighlightColor;
\r
186 ColorClass currentColorClass;
\r
188 HWND hCommPort = NULL; /* currently open comm port */
\r
189 static HWND hwndPause; /* pause button */
\r
190 static HBITMAP pieceBitmap[3][(int) BlackPawn]; /* [HGM] nr of bitmaps referred to bP in stead of wK */
\r
191 static HBRUSH lightSquareBrush, darkSquareBrush,
\r
192 blackSquareBrush, /* [HGM] for band between board and holdings */
\r
193 explodeBrush, /* [HGM] atomic */
\r
194 markerBrush, /* [HGM] markers */
\r
195 whitePieceBrush, blackPieceBrush, iconBkgndBrush /*, outlineBrush*/;
\r
196 static POINT gridEndpoints[(BOARD_RANKS + BOARD_FILES + 2) * 2];
\r
197 static DWORD gridVertexCounts[BOARD_RANKS + BOARD_FILES + 2];
\r
198 static HPEN gridPen = NULL;
\r
199 static HPEN highlightPen = NULL;
\r
200 static HPEN premovePen = NULL;
\r
201 static NPLOGPALETTE pLogPal;
\r
202 static BOOL paletteChanged = FALSE;
\r
203 static HICON iconWhite, iconBlack, iconCurrent;
\r
204 static int doingSizing = FALSE;
\r
205 static int lastSizing = 0;
\r
206 static int prevStderrPort;
\r
207 static HBITMAP userLogo;
\r
209 static HBITMAP liteBackTexture = NULL;
\r
210 static HBITMAP darkBackTexture = NULL;
\r
211 static int liteBackTextureMode = BACK_TEXTURE_MODE_PLAIN;
\r
212 static int darkBackTextureMode = BACK_TEXTURE_MODE_PLAIN;
\r
213 static int backTextureSquareSize = 0;
\r
214 static struct { int x; int y; int mode; } backTextureSquareInfo[BOARD_RANKS][BOARD_FILES];
\r
216 #if __GNUC__ && !defined(_winmajor)
\r
217 #define oldDialog 0 /* cygwin doesn't define _winmajor; mingw does */
\r
219 #if defined(_winmajor)
\r
220 #define oldDialog (_winmajor < 4)
\r
222 #define oldDialog 0
\r
232 int cliWidth, cliHeight;
\r
235 SizeInfo sizeInfo[] =
\r
237 { "tiny", 21, 0, 1, 1, 0, 0 },
\r
238 { "teeny", 25, 1, 1, 1, 0, 0 },
\r
239 { "dinky", 29, 1, 1, 1, 0, 0 },
\r
240 { "petite", 33, 1, 1, 1, 0, 0 },
\r
241 { "slim", 37, 2, 1, 0, 0, 0 },
\r
242 { "small", 40, 2, 1, 0, 0, 0 },
\r
243 { "mediocre", 45, 2, 1, 0, 0, 0 },
\r
244 { "middling", 49, 2, 0, 0, 0, 0 },
\r
245 { "average", 54, 2, 0, 0, 0, 0 },
\r
246 { "moderate", 58, 3, 0, 0, 0, 0 },
\r
247 { "medium", 64, 3, 0, 0, 0, 0 },
\r
248 { "bulky", 72, 3, 0, 0, 0, 0 },
\r
249 { "large", 80, 3, 0, 0, 0, 0 },
\r
250 { "big", 87, 3, 0, 0, 0, 0 },
\r
251 { "huge", 95, 3, 0, 0, 0, 0 },
\r
252 { "giant", 108, 3, 0, 0, 0, 0 },
\r
253 { "colossal", 116, 4, 0, 0, 0, 0 },
\r
254 { "titanic", 129, 4, 0, 0, 0, 0 },
\r
255 { NULL, 0, 0, 0, 0, 0, 0 }
\r
258 #define MF(x) {x, {{0,}, 0. }, {0, }, 0}
\r
259 MyFont fontRec[NUM_SIZES][NUM_FONTS] =
\r
261 { MF(CLOCK_FONT_TINY), MF(MESSAGE_FONT_TINY), MF(COORD_FONT_TINY), MF(CONSOLE_FONT_TINY), MF(COMMENT_FONT_TINY), MF(EDITTAGS_FONT_TINY), MF(MOVEHISTORY_FONT_ALL) },
\r
262 { MF(CLOCK_FONT_TEENY), MF(MESSAGE_FONT_TEENY), MF(COORD_FONT_TEENY), MF(CONSOLE_FONT_TEENY), MF(COMMENT_FONT_TEENY), MF(EDITTAGS_FONT_TEENY), MF(MOVEHISTORY_FONT_ALL) },
\r
263 { MF(CLOCK_FONT_DINKY), MF(MESSAGE_FONT_DINKY), MF(COORD_FONT_DINKY), MF(CONSOLE_FONT_DINKY), MF(COMMENT_FONT_DINKY), MF(EDITTAGS_FONT_DINKY), MF(MOVEHISTORY_FONT_ALL) },
\r
264 { MF(CLOCK_FONT_PETITE), MF(MESSAGE_FONT_PETITE), MF(COORD_FONT_PETITE), MF(CONSOLE_FONT_PETITE), MF(COMMENT_FONT_PETITE), MF(EDITTAGS_FONT_PETITE), MF(MOVEHISTORY_FONT_ALL) },
\r
265 { MF(CLOCK_FONT_SLIM), MF(MESSAGE_FONT_SLIM), MF(COORD_FONT_SLIM), MF(CONSOLE_FONT_SLIM), MF(COMMENT_FONT_SLIM), MF(EDITTAGS_FONT_SLIM), MF(MOVEHISTORY_FONT_ALL) },
\r
266 { MF(CLOCK_FONT_SMALL), MF(MESSAGE_FONT_SMALL), MF(COORD_FONT_SMALL), MF(CONSOLE_FONT_SMALL), MF(COMMENT_FONT_SMALL), MF(EDITTAGS_FONT_SMALL), MF(MOVEHISTORY_FONT_ALL) },
\r
267 { MF(CLOCK_FONT_MEDIOCRE), MF(MESSAGE_FONT_MEDIOCRE), MF(COORD_FONT_MEDIOCRE), MF(CONSOLE_FONT_MEDIOCRE), MF(COMMENT_FONT_MEDIOCRE), MF(EDITTAGS_FONT_MEDIOCRE), MF(MOVEHISTORY_FONT_ALL) },
\r
268 { MF(CLOCK_FONT_MIDDLING), MF(MESSAGE_FONT_MIDDLING), MF(COORD_FONT_MIDDLING), MF(CONSOLE_FONT_MIDDLING), MF(COMMENT_FONT_MIDDLING), MF(EDITTAGS_FONT_MIDDLING), MF(MOVEHISTORY_FONT_ALL) },
\r
269 { MF(CLOCK_FONT_AVERAGE), MF(MESSAGE_FONT_AVERAGE), MF(COORD_FONT_AVERAGE), MF(CONSOLE_FONT_AVERAGE), MF(COMMENT_FONT_AVERAGE), MF(EDITTAGS_FONT_AVERAGE), MF(MOVEHISTORY_FONT_ALL) },
\r
270 { MF(CLOCK_FONT_MODERATE), MF(MESSAGE_FONT_MODERATE), MF(COORD_FONT_MODERATE), MF(CONSOLE_FONT_MODERATE), MF(COMMENT_FONT_MODERATE), MF(EDITTAGS_FONT_MODERATE), MF(MOVEHISTORY_FONT_ALL) },
\r
271 { MF(CLOCK_FONT_MEDIUM), MF(MESSAGE_FONT_MEDIUM), MF(COORD_FONT_MEDIUM), MF(CONSOLE_FONT_MEDIUM), MF(COMMENT_FONT_MEDIUM), MF(EDITTAGS_FONT_MEDIUM), MF(MOVEHISTORY_FONT_ALL) },
\r
272 { MF(CLOCK_FONT_BULKY), MF(MESSAGE_FONT_BULKY), MF(COORD_FONT_BULKY), MF(CONSOLE_FONT_BULKY), MF(COMMENT_FONT_BULKY), MF(EDITTAGS_FONT_BULKY), MF(MOVEHISTORY_FONT_ALL) },
\r
273 { MF(CLOCK_FONT_LARGE), MF(MESSAGE_FONT_LARGE), MF(COORD_FONT_LARGE), MF(CONSOLE_FONT_LARGE), MF(COMMENT_FONT_LARGE), MF(EDITTAGS_FONT_LARGE), MF(MOVEHISTORY_FONT_ALL) },
\r
274 { MF(CLOCK_FONT_BIG), MF(MESSAGE_FONT_BIG), MF(COORD_FONT_BIG), MF(CONSOLE_FONT_BIG), MF(COMMENT_FONT_BIG), MF(EDITTAGS_FONT_BIG), MF(MOVEHISTORY_FONT_ALL) },
\r
275 { MF(CLOCK_FONT_HUGE), MF(MESSAGE_FONT_HUGE), MF(COORD_FONT_HUGE), MF(CONSOLE_FONT_HUGE), MF(COMMENT_FONT_HUGE), MF(EDITTAGS_FONT_HUGE), MF(MOVEHISTORY_FONT_ALL) },
\r
276 { MF(CLOCK_FONT_GIANT), MF(MESSAGE_FONT_GIANT), MF(COORD_FONT_GIANT), MF(CONSOLE_FONT_GIANT), MF(COMMENT_FONT_GIANT), MF(EDITTAGS_FONT_GIANT), MF(MOVEHISTORY_FONT_ALL) },
\r
277 { MF(CLOCK_FONT_COLOSSAL), MF(MESSAGE_FONT_COLOSSAL), MF(COORD_FONT_COLOSSAL), MF(CONSOLE_FONT_COLOSSAL), MF(COMMENT_FONT_COLOSSAL), MF(EDITTAGS_FONT_COLOSSAL), MF(MOVEHISTORY_FONT_ALL) },
\r
278 { MF(CLOCK_FONT_TITANIC), MF(MESSAGE_FONT_TITANIC), MF(COORD_FONT_TITANIC), MF(CONSOLE_FONT_TITANIC), MF(COMMENT_FONT_TITANIC), MF(EDITTAGS_FONT_TITANIC), MF(MOVEHISTORY_FONT_ALL) },
\r
281 MyFont *font[NUM_SIZES][NUM_FONTS];
\r
290 #define BUTTON_WIDTH (tinyLayout ? 16 : 32)
\r
291 #define N_BUTTONS 5
\r
293 MyButtonDesc buttonDesc[N_BUTTONS] =
\r
295 {"<<", IDM_ToStart, NULL, NULL},
\r
296 {"<", IDM_Backward, NULL, NULL},
\r
297 {"P", IDM_Pause, NULL, NULL},
\r
298 {">", IDM_Forward, NULL, NULL},
\r
299 {">>", IDM_ToEnd, NULL, NULL},
\r
302 int tinyLayout = 0, smallLayout = 0;
\r
303 #define MENU_BAR_ITEMS 7
\r
304 char *menuBarText[2][MENU_BAR_ITEMS+1] = {
\r
305 { "&File", "&Mode", "&Action", "&Step", "&Options", "&Help", NULL },
\r
306 { "&F", "&M", "&A", "&S", "&O", "&H", NULL },
\r
310 MySound sounds[(int)NSoundClasses];
\r
311 MyTextAttribs textAttribs[(int)NColorClasses];
\r
313 MyColorizeAttribs colorizeAttribs[] = {
\r
314 { (COLORREF)0, 0, "Shout Text" },
\r
315 { (COLORREF)0, 0, "SShout/CShout" },
\r
316 { (COLORREF)0, 0, "Channel 1 Text" },
\r
317 { (COLORREF)0, 0, "Channel Text" },
\r
318 { (COLORREF)0, 0, "Kibitz Text" },
\r
319 { (COLORREF)0, 0, "Tell Text" },
\r
320 { (COLORREF)0, 0, "Challenge Text" },
\r
321 { (COLORREF)0, 0, "Request Text" },
\r
322 { (COLORREF)0, 0, "Seek Text" },
\r
323 { (COLORREF)0, 0, "Normal Text" },
\r
324 { (COLORREF)0, 0, "None" }
\r
329 static char *commentTitle;
\r
330 static char *commentText;
\r
331 static int commentIndex;
\r
332 static Boolean editComment = FALSE;
\r
335 char errorTitle[MSG_SIZ];
\r
336 char errorMessage[2*MSG_SIZ];
\r
337 HWND errorDialog = NULL;
\r
338 BOOLEAN moveErrorMessageUp = FALSE;
\r
339 BOOLEAN consoleEcho = TRUE;
\r
340 CHARFORMAT consoleCF;
\r
341 COLORREF consoleBackgroundColor;
\r
343 char *programVersion;
\r
349 typedef int CPKind;
\r
358 SOCKET sock2; /* stderr socket for OpenRcmd */
\r
361 #define INPUT_SOURCE_BUF_SIZE 4096
\r
363 typedef struct _InputSource {
\r
370 char buf[INPUT_SOURCE_BUF_SIZE];
\r
374 InputCallback func;
\r
375 struct _InputSource *second; /* for stderr thread on CPRcmd */
\r
379 InputSource *consoleInputSource;
\r
384 VOID ConsoleOutput(char* data, int length, int forceVisible);
\r
385 VOID ConsoleCreate();
\r
387 ConsoleWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
\r
388 VOID ColorizeTextPopup(HWND hwnd, ColorClass cc);
\r
389 VOID PrintCommSettings(FILE *f, char *name, DCB *dcb);
\r
390 VOID ParseCommSettings(char *arg, DCB *dcb);
\r
392 StartupDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
\r
393 VOID APIENTRY MenuPopup(HWND hwnd, POINT pt, HMENU hmenu, UINT def);
\r
394 void ParseIcsTextMenu(char *icsTextMenuString);
\r
395 VOID PopUpMoveDialog(char firstchar);
\r
396 VOID PopUpNameDialog(char firstchar);
\r
397 VOID UpdateSampleText(HWND hDlg, int id, MyColorizeAttribs *mca);
\r
401 int GameListOptions();
\r
403 int dummy; // [HGM] for obsolete args
\r
405 HWND hwndMain = NULL; /* root window*/
\r
406 HWND hwndConsole = NULL;
\r
407 HWND commentDialog = NULL;
\r
408 HWND moveHistoryDialog = NULL;
\r
409 HWND evalGraphDialog = NULL;
\r
410 HWND engineOutputDialog = NULL;
\r
411 HWND gameListDialog = NULL;
\r
412 HWND editTagsDialog = NULL;
\r
414 int commentUp = FALSE;
\r
416 WindowPlacement wpMain;
\r
417 WindowPlacement wpConsole;
\r
418 WindowPlacement wpComment;
\r
419 WindowPlacement wpMoveHistory;
\r
420 WindowPlacement wpEvalGraph;
\r
421 WindowPlacement wpEngineOutput;
\r
422 WindowPlacement wpGameList;
\r
423 WindowPlacement wpTags;
\r
425 VOID EngineOptionsPopup(); // [HGM] settings
\r
427 VOID GothicPopUp(char *title, VariantClass variant);
\r
429 * Setting "frozen" should disable all user input other than deleting
\r
430 * the window. We do this while engines are initializing themselves.
\r
432 static int frozen = 0;
\r
433 static int oldMenuItemState[MENU_BAR_ITEMS];
\r
439 if (frozen) return;
\r
441 hmenu = GetMenu(hwndMain);
\r
442 for (i=0; i<MENU_BAR_ITEMS; i++) {
\r
443 oldMenuItemState[i] = EnableMenuItem(hmenu, i, MF_BYPOSITION|MF_GRAYED);
\r
445 DrawMenuBar(hwndMain);
\r
448 /* Undo a FreezeUI */
\r
454 if (!frozen) return;
\r
456 hmenu = GetMenu(hwndMain);
\r
457 for (i=0; i<MENU_BAR_ITEMS; i++) {
\r
458 EnableMenuItem(hmenu, i, MF_BYPOSITION|oldMenuItemState[i]);
\r
460 DrawMenuBar(hwndMain);
\r
463 /*static*/ int fromX = -1, fromY = -1, toX, toY; // [HGM] moved upstream, so JAWS can use them
\r
465 /* JAWS preparation patch (WinBoard for the sight impaired). Define required insertions as empty */
\r
471 #define JAWS_ALT_INTERCEPT
\r
472 #define JAWS_KB_NAVIGATION
\r
473 #define JAWS_MENU_ITEMS
\r
474 #define JAWS_SILENCE
\r
475 #define JAWS_REPLAY
\r
477 #define JAWS_COPYRIGHT
\r
478 #define JAWS_DELETE(X) X
\r
479 #define SAYMACHINEMOVE()
\r
483 /*---------------------------------------------------------------------------*\
\r
487 \*---------------------------------------------------------------------------*/
\r
490 WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
\r
491 LPSTR lpCmdLine, int nCmdShow)
\r
494 HANDLE hAccelMain, hAccelNoAlt, hAccelNoICS;
\r
495 // INITCOMMONCONTROLSEX ex;
\r
499 LoadLibrary("RICHED32.DLL");
\r
500 consoleCF.cbSize = sizeof(CHARFORMAT);
\r
502 if (!InitApplication(hInstance)) {
\r
505 if (!InitInstance(hInstance, nCmdShow, lpCmdLine)) {
\r
511 // InitCommonControlsEx(&ex);
\r
512 InitCommonControls();
\r
514 hAccelMain = LoadAccelerators (hInstance, szAppName);
\r
515 hAccelNoAlt = LoadAccelerators (hInstance, "NO_ALT");
\r
516 hAccelNoICS = LoadAccelerators( hInstance, "NO_ICS"); /* [AS] No Ctrl-V on ICS!!! */
\r
518 /* Acquire and dispatch messages until a WM_QUIT message is received. */
\r
520 while (GetMessage(&msg, /* message structure */
\r
521 NULL, /* handle of window receiving the message */
\r
522 0, /* lowest message to examine */
\r
523 0)) /* highest message to examine */
\r
526 if(msg.message == WM_CHAR && msg.wParam == '\t') {
\r
527 // [HGM] navigate: switch between all windows with tab
\r
528 HWND e1 = NULL, e2 = NULL, mh = NULL, hInput = NULL, hText = NULL;
\r
529 int i, currentElement = 0;
\r
531 // first determine what element of the chain we come from (if any)
\r
532 if(appData.icsActive) {
\r
533 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
534 hText = GetDlgItem(hwndConsole, OPT_ConsoleText);
\r
536 if(engineOutputDialog && EngineOutputIsUp()) {
\r
537 e1 = GetDlgItem(engineOutputDialog, IDC_EngineMemo1);
\r
538 e2 = GetDlgItem(engineOutputDialog, IDC_EngineMemo2);
\r
540 if(moveHistoryDialog && MoveHistoryIsUp()) {
\r
541 mh = GetDlgItem(moveHistoryDialog, IDC_MoveHistory);
\r
543 if(msg.hwnd == hwndMain) currentElement = 7 ; else
\r
544 if(msg.hwnd == engineOutputDialog) currentElement = 2; else
\r
545 if(msg.hwnd == e1) currentElement = 2; else
\r
546 if(msg.hwnd == e2) currentElement = 3; else
\r
547 if(msg.hwnd == moveHistoryDialog) currentElement = 4; else
\r
548 if(msg.hwnd == mh) currentElement = 4; else
\r
549 if(msg.hwnd == evalGraphDialog) currentElement = 6; else
\r
550 if(msg.hwnd == hText) currentElement = 5; else
\r
551 if(msg.hwnd == hInput) currentElement = 6; else
\r
552 for (i = 0; i < N_BUTTONS; i++) {
\r
553 if (buttonDesc[i].hwnd == msg.hwnd) { currentElement = 1; break; }
\r
556 // determine where to go to
\r
557 if(currentElement) { HWND h = NULL; int direction = GetKeyState(VK_SHIFT) < 0 ? -1 : 1;
\r
559 currentElement = (currentElement + direction) % 7;
\r
560 switch(currentElement) {
\r
562 h = hwndMain; break; // passing this case always makes the loop exit
\r
564 h = buttonDesc[0].hwnd; break; // could be NULL
\r
566 if(!EngineOutputIsUp()) continue; // skip closed auxiliary windows
\r
569 if(!EngineOutputIsUp()) continue;
\r
572 if(!MoveHistoryIsUp()) continue;
\r
574 // case 6: // input to eval graph does not seem to get here!
\r
575 // if(!EvalGraphIsUp()) continue;
\r
576 // h = evalGraphDialog; break;
\r
578 if(!appData.icsActive) continue;
\r
582 if(!appData.icsActive) continue;
\r
588 if(currentElement > 4 && IsIconic(hwndConsole)) ShowWindow(hwndConsole, SW_RESTORE);
\r
589 if(currentElement < 5 && IsIconic(hwndMain)) ShowWindow(hwndMain, SW_RESTORE); // all open together
\r
592 continue; // this message now has been processed
\r
596 if (!(commentDialog && IsDialogMessage(commentDialog, &msg)) &&
\r
597 !(moveHistoryDialog && IsDialogMessage(moveHistoryDialog, &msg)) &&
\r
598 !(evalGraphDialog && IsDialogMessage(evalGraphDialog, &msg)) &&
\r
599 !(engineOutputDialog && IsDialogMessage(engineOutputDialog, &msg)) &&
\r
600 !(editTagsDialog && IsDialogMessage(editTagsDialog, &msg)) &&
\r
601 !(gameListDialog && IsDialogMessage(gameListDialog, &msg)) &&
\r
602 !(errorDialog && IsDialogMessage(errorDialog, &msg)) &&
\r
603 !(!frozen && TranslateAccelerator(hwndMain, hAccelMain, &msg)) && JAWS_ACCEL
\r
604 !(!hwndConsole && TranslateAccelerator(hwndMain, hAccelNoICS, &msg)) &&
\r
605 !(!hwndConsole && TranslateAccelerator(hwndMain, hAccelNoAlt, &msg))) {
\r
606 int done = 0, i; // [HGM] chat: dispatch cat-box messages
\r
607 for(i=0; i<MAX_CHAT; i++)
\r
608 if(chatHandle[i] && IsDialogMessage(chatHandle[i], &msg)) {
\r
611 if(done) continue; // [HGM] chat: end patch
\r
612 TranslateMessage(&msg); /* Translates virtual key codes */
\r
613 DispatchMessage(&msg); /* Dispatches message to window */
\r
618 return (msg.wParam); /* Returns the value from PostQuitMessage */
\r
621 /*---------------------------------------------------------------------------*\
\r
623 * Initialization functions
\r
625 \*---------------------------------------------------------------------------*/
\r
629 { // update user logo if necessary
\r
630 static char oldUserName[MSG_SIZ], *curName;
\r
632 if(appData.autoLogo) {
\r
633 curName = UserName();
\r
634 if(strcmp(curName, oldUserName)) {
\r
635 sprintf(oldUserName, "logos\\%s.bmp", curName);
\r
636 userLogo = LoadImage( 0, oldUserName, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
637 strcpy(oldUserName, curName);
\r
643 InitApplication(HINSTANCE hInstance)
\r
647 /* Fill in window class structure with parameters that describe the */
\r
650 wc.style = CS_HREDRAW | CS_VREDRAW; /* Class style(s). */
\r
651 wc.lpfnWndProc = (WNDPROC)WndProc; /* Window Procedure */
\r
652 wc.cbClsExtra = 0; /* No per-class extra data. */
\r
653 wc.cbWndExtra = 0; /* No per-window extra data. */
\r
654 wc.hInstance = hInstance; /* Owner of this class */
\r
655 wc.hIcon = LoadIcon(hInstance, "icon_white");
\r
656 wc.hCursor = LoadCursor(NULL, IDC_ARROW); /* Cursor */
\r
657 wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); /* Default color */
\r
658 wc.lpszMenuName = szAppName; /* Menu name from .RC */
\r
659 wc.lpszClassName = szAppName; /* Name to register as */
\r
661 /* Register the window class and return success/failure code. */
\r
662 if (!RegisterClass(&wc)) return FALSE;
\r
664 wc.style = CS_HREDRAW | CS_VREDRAW;
\r
665 wc.lpfnWndProc = (WNDPROC)ConsoleWndProc;
\r
667 wc.cbWndExtra = DLGWINDOWEXTRA;
\r
668 wc.hInstance = hInstance;
\r
669 wc.hIcon = LoadIcon(hInstance, "icon_white");
\r
670 wc.hCursor = LoadCursor(NULL, IDC_ARROW);
\r
671 wc.hbrBackground = (HBRUSH)(COLOR_MENU+1);
\r
672 wc.lpszMenuName = NULL;
\r
673 wc.lpszClassName = szConsoleName;
\r
675 if (!RegisterClass(&wc)) return FALSE;
\r
680 /* Set by InitInstance, used by EnsureOnScreen */
\r
681 int screenHeight, screenWidth;
\r
684 EnsureOnScreen(int *x, int *y, int minX, int minY)
\r
686 // int gap = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYCAPTION);
\r
687 /* Be sure window at (x,y) is not off screen (or even mostly off screen) */
\r
688 if (*x > screenWidth - 32) *x = 0;
\r
689 if (*y > screenHeight - 32) *y = 0;
\r
690 if (*x < minX) *x = minX;
\r
691 if (*y < minY) *y = minY;
\r
695 InitInstance(HINSTANCE hInstance, int nCmdShow, LPSTR lpCmdLine)
\r
697 HWND hwnd; /* Main window handle. */
\r
699 WINDOWPLACEMENT wp;
\r
702 hInst = hInstance; /* Store instance handle in our global variable */
\r
703 programName = szAppName;
\r
705 if (SearchPath(NULL, "WinBoard.exe", NULL, MSG_SIZ, installDir, &filepart)) {
\r
706 *filepart = NULLCHAR;
\r
708 GetCurrentDirectory(MSG_SIZ, installDir);
\r
710 gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] won't have open window otherwise
\r
711 screenWidth = screenHeight = 1000; // [HGM] placement: kludge to allow calling EnsureOnScreen from InitAppData
\r
712 InitAppData(lpCmdLine); /* Get run-time parameters */
\r
713 /* xboard, and older WinBoards, controlled the move sound with the
\r
714 appData.ringBellAfterMoves option. In the current WinBoard, we
\r
715 always turn the option on (so that the backend will call us),
\r
716 then let the user turn the sound off by setting it to silence if
\r
717 desired. To accommodate old winboard.ini files saved by old
\r
718 versions of WinBoard, we also turn off the sound if the option
\r
719 was initially set to false. [HGM] taken out of InitAppData */
\r
720 if (!appData.ringBellAfterMoves) {
\r
721 sounds[(int)SoundMove].name = strdup("");
\r
722 appData.ringBellAfterMoves = TRUE;
\r
724 if (appData.debugMode) {
\r
725 debugFP = fopen(appData.nameOfDebugFile, "w");
\r
726 setbuf(debugFP, NULL);
\r
731 // InitEngineUCI( installDir, &first ); // [HGM] incorporated in InitBackEnd1()
\r
732 // InitEngineUCI( installDir, &second );
\r
734 /* Create a main window for this application instance. */
\r
735 hwnd = CreateWindow(szAppName, szTitle,
\r
736 (WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX),
\r
737 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
\r
738 NULL, NULL, hInstance, NULL);
\r
741 /* If window could not be created, return "failure" */
\r
746 /* [HGM] logo: Load logos if specified (must be done before InitDrawingSizes) */
\r
747 if( appData.firstLogo && appData.firstLogo[0] != NULLCHAR) {
\r
748 first.programLogo = LoadImage( 0, appData.firstLogo, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
750 if (first.programLogo == NULL && appData.debugMode) {
\r
751 fprintf( debugFP, "Unable to load logo bitmap '%s'\n", appData.firstLogo );
\r
753 } else if(appData.autoLogo) {
\r
754 if(appData.firstDirectory && appData.firstDirectory[0]) {
\r
756 sprintf(buf, "%s/logo.bmp", appData.firstDirectory);
\r
757 first.programLogo = LoadImage( 0, buf, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
761 if( appData.secondLogo && appData.secondLogo[0] != NULLCHAR) {
\r
762 second.programLogo = LoadImage( 0, appData.secondLogo, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
764 if (second.programLogo == NULL && appData.debugMode) {
\r
765 fprintf( debugFP, "Unable to load logo bitmap '%s'\n", appData.secondLogo );
\r
767 } else if(appData.autoLogo) {
\r
769 if(appData.icsActive) { // [HGM] logo: in ICS mode second can be used for ICS
\r
770 sprintf(buf, "logos\\%s.bmp", appData.icsHost);
\r
771 second.programLogo = LoadImage( 0, buf, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
773 if(appData.secondDirectory && appData.secondDirectory[0]) {
\r
774 sprintf(buf, "%s\\logo.bmp", appData.secondDirectory);
\r
775 second.programLogo = LoadImage( 0, buf, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
781 iconWhite = LoadIcon(hInstance, "icon_white");
\r
782 iconBlack = LoadIcon(hInstance, "icon_black");
\r
783 iconCurrent = iconWhite;
\r
784 InitDrawingColors();
\r
785 screenHeight = GetSystemMetrics(SM_CYSCREEN);
\r
786 screenWidth = GetSystemMetrics(SM_CXSCREEN);
\r
787 for (ibs = (int) NUM_SIZES - 1; ibs >= 0; ibs--) {
\r
788 /* Compute window size for each board size, and use the largest
\r
789 size that fits on this screen as the default. */
\r
790 InitDrawingSizes((BoardSize)(ibs+1000), 0);
\r
791 if (boardSize == (BoardSize)-1 &&
\r
792 winH <= screenHeight
\r
793 - GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYCAPTION) - 10
\r
794 && winW <= screenWidth) {
\r
795 boardSize = (BoardSize)ibs;
\r
799 InitDrawingSizes(boardSize, 0);
\r
801 buttonCount = GetSystemMetrics(SM_CMOUSEBUTTONS);
\r
803 /* [AS] Load textures if specified */
\r
804 ZeroMemory( &backTextureSquareInfo, sizeof(backTextureSquareInfo) );
\r
806 if( appData.liteBackTextureFile && appData.liteBackTextureFile[0] != NULLCHAR && appData.liteBackTextureFile[0] != '*' ) {
\r
807 liteBackTexture = LoadImage( 0, appData.liteBackTextureFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
808 liteBackTextureMode = appData.liteBackTextureMode;
\r
810 if (liteBackTexture == NULL && appData.debugMode) {
\r
811 fprintf( debugFP, "Unable to load lite texture bitmap '%s'\n", appData.liteBackTextureFile );
\r
815 if( appData.darkBackTextureFile && appData.darkBackTextureFile[0] != NULLCHAR && appData.darkBackTextureFile[0] != '*' ) {
\r
816 darkBackTexture = LoadImage( 0, appData.darkBackTextureFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
\r
817 darkBackTextureMode = appData.darkBackTextureMode;
\r
819 if (darkBackTexture == NULL && appData.debugMode) {
\r
820 fprintf( debugFP, "Unable to load dark texture bitmap '%s'\n", appData.darkBackTextureFile );
\r
824 mysrandom( (unsigned) time(NULL) );
\r
826 /* [AS] Restore layout */
\r
827 if( wpMoveHistory.visible ) {
\r
828 MoveHistoryPopUp();
\r
831 if( wpEvalGraph.visible ) {
\r
835 if( wpEngineOutput.visible ) {
\r
836 EngineOutputPopUp();
\r
841 /* Make the window visible; update its client area; and return "success" */
\r
842 EnsureOnScreen(&wpMain.x, &wpMain.y, minX, minY);
\r
843 wp.length = sizeof(WINDOWPLACEMENT);
\r
845 wp.showCmd = nCmdShow;
\r
846 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
847 wp.rcNormalPosition.left = wpMain.x;
\r
848 wp.rcNormalPosition.right = wpMain.x + wpMain.width;
\r
849 wp.rcNormalPosition.top = wpMain.y;
\r
850 wp.rcNormalPosition.bottom = wpMain.y + wpMain.height;
\r
851 SetWindowPlacement(hwndMain, &wp);
\r
853 if(!appData.noGUI) SetWindowPos(hwndMain, alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
\r
854 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
\r
858 SetWindowPos(hwndConsole, alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
\r
859 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
\r
861 ShowWindow(hwndConsole, nCmdShow);
\r
863 if(!appData.noGUI) UpdateWindow(hwnd); else ShowWindow(hwnd, SW_MINIMIZE);
\r
864 if(gameListDialog) SetFocus(gameListDialog); // [HGM] jaws: for if we clicked multi-game game file
\r
873 HMENU hmenu = GetMenu(hwndMain);
\r
875 (void) EnableMenuItem(hmenu, IDM_CommPort,
\r
876 MF_BYCOMMAND|((appData.icsActive &&
\r
877 *appData.icsCommPort != NULLCHAR) ?
\r
878 MF_ENABLED : MF_GRAYED));
\r
879 (void) CheckMenuItem(hmenu, IDM_SaveSettingsOnExit,
\r
880 MF_BYCOMMAND|(saveSettingsOnExit ?
\r
881 MF_CHECKED : MF_UNCHECKED));
\r
884 //---------------------------------------------------------------------------------------------------------
\r
886 #define ICS_TEXT_MENU_SIZE (IDM_CommandXLast - IDM_CommandX + 1)
\r
887 #define XBOARD FALSE
\r
889 #define OPTCHAR "/"
\r
890 #define SEPCHAR "="
\r
894 // front-end part of option handling
\r
897 LFfromMFP(LOGFONT* lf, MyFontParams *mfp)
\r
899 HDC hdc = CreateDC("DISPLAY", NULL, NULL, NULL);
\r
900 lf->lfHeight = -(int)(mfp->pointSize * GetDeviceCaps(hdc, LOGPIXELSY) / 72.0 + 0.5);
\r
903 lf->lfEscapement = 0;
\r
904 lf->lfOrientation = 0;
\r
905 lf->lfWeight = mfp->bold ? FW_BOLD : FW_NORMAL;
\r
906 lf->lfItalic = mfp->italic;
\r
907 lf->lfUnderline = mfp->underline;
\r
908 lf->lfStrikeOut = mfp->strikeout;
\r
909 lf->lfCharSet = mfp->charset;
\r
910 lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
\r
911 lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
\r
912 lf->lfQuality = DEFAULT_QUALITY;
\r
913 lf->lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE;
\r
914 strcpy(lf->lfFaceName, mfp->faceName);
\r
918 CreateFontInMF(MyFont *mf)
\r
920 LFfromMFP(&mf->lf, &mf->mfp);
\r
921 if (mf->hf) DeleteObject(mf->hf);
\r
922 mf->hf = CreateFontIndirect(&mf->lf);
\r
925 // [HGM] This platform-dependent table provides the location for storing the color info
\r
927 colorVariable[] = {
\r
932 &highlightSquareColor,
\r
933 &premoveHighlightColor,
\r
935 &consoleBackgroundColor,
\r
936 &appData.fontForeColorWhite,
\r
937 &appData.fontBackColorWhite,
\r
938 &appData.fontForeColorBlack,
\r
939 &appData.fontBackColorBlack,
\r
940 &appData.evalHistColorWhite,
\r
941 &appData.evalHistColorBlack,
\r
942 &appData.highlightArrowColor,
\r
945 /* Command line font name parser. NULL name means do nothing.
\r
946 Syntax like "Courier New:10.0 bi" or "Arial:10" or "Arial:10b"
\r
947 For backward compatibility, syntax without the colon is also
\r
948 accepted, but font names with digits in them won't work in that case.
\r
951 ParseFontName(char *name, MyFontParams *mfp)
\r
954 if (name == NULL) return;
\r
956 q = strchr(p, ':');
\r
958 if (q - p >= sizeof(mfp->faceName))
\r
959 ExitArgError("Font name too long:", name);
\r
960 memcpy(mfp->faceName, p, q - p);
\r
961 mfp->faceName[q - p] = NULLCHAR;
\r
965 while (*p && !isdigit(*p)) {
\r
967 if (q - mfp->faceName >= sizeof(mfp->faceName))
\r
968 ExitArgError("Font name too long:", name);
\r
970 while (q > mfp->faceName && q[-1] == ' ') q--;
\r
973 if (!*p) ExitArgError("Font point size missing:", name);
\r
974 mfp->pointSize = (float) atof(p);
\r
975 mfp->bold = (strchr(p, 'b') != NULL);
\r
976 mfp->italic = (strchr(p, 'i') != NULL);
\r
977 mfp->underline = (strchr(p, 'u') != NULL);
\r
978 mfp->strikeout = (strchr(p, 's') != NULL);
\r
979 mfp->charset = DEFAULT_CHARSET;
\r
980 q = strchr(p, 'c');
\r
982 mfp->charset = (BYTE) atoi(q+1);
\r
986 ParseFont(char *name, int number)
\r
987 { // wrapper to shield back-end from 'font'
\r
988 ParseFontName(name, &font[boardSize][number]->mfp);
\r
993 { // in WB we have a 2D array of fonts; this initializes their description
\r
995 /* Point font array elements to structures and
\r
996 parse default font names */
\r
997 for (i=0; i<NUM_FONTS; i++) {
\r
998 for (j=0; j<NUM_SIZES; j++) {
\r
999 font[j][i] = &fontRec[j][i];
\r
1000 ParseFontName(font[j][i]->def, &font[j][i]->mfp);
\r
1007 { // here we create the actual fonts from the selected descriptions
\r
1009 for (i=0; i<NUM_FONTS; i++) {
\r
1010 for (j=0; j<NUM_SIZES; j++) {
\r
1011 CreateFontInMF(font[j][i]);
\r
1015 /* Color name parser.
\r
1016 X version accepts X color names, but this one
\r
1017 handles only the #rrggbb form (hex) or rrr,ggg,bbb (decimal) */
\r
1019 ParseColorName(char *name)
\r
1021 int red, green, blue, count;
\r
1022 char buf[MSG_SIZ];
\r
1024 count = sscanf(name, "#%2x%2x%2x", &red, &green, &blue);
\r
1026 count = sscanf(name, "%3d%*[^0-9]%3d%*[^0-9]%3d",
\r
1027 &red, &green, &blue);
\r
1030 sprintf(buf, "Can't parse color name %s", name);
\r
1031 DisplayError(buf, 0);
\r
1032 return RGB(0, 0, 0);
\r
1034 return PALETTERGB(red, green, blue);
\r
1038 ParseColor(int n, char *name)
\r
1039 { // for WinBoard the color is an int, which needs to be derived from the string
\r
1040 if(colorVariable[n]) *(int*)colorVariable[n] = ParseColorName(name);
\r
1044 ParseAttribs(COLORREF *color, int *effects, char* argValue)
\r
1046 char *e = argValue;
\r
1050 if (*e == 'b') eff |= CFE_BOLD;
\r
1051 else if (*e == 'i') eff |= CFE_ITALIC;
\r
1052 else if (*e == 'u') eff |= CFE_UNDERLINE;
\r
1053 else if (*e == 's') eff |= CFE_STRIKEOUT;
\r
1054 else if (*e == '#' || isdigit(*e)) break;
\r
1058 *color = ParseColorName(e);
\r
1062 ParseTextAttribs(ColorClass cc, char *s)
\r
1063 { // [HGM] front-end wrapper that does the platform-dependent call
\r
1064 // for XBoard we would set (&appData.colorShout)[cc] = strdup(s);
\r
1065 ParseAttribs(&textAttribs[cc].color, &textAttribs[cc].effects, s);
\r
1069 ParseBoardSize(void *addr, char *name)
\r
1070 { // [HGM] rewritten with return-value ptr to shield back-end from BoardSize
\r
1071 BoardSize bs = SizeTiny;
\r
1072 while (sizeInfo[bs].name != NULL) {
\r
1073 if (StrCaseCmp(name, sizeInfo[bs].name) == 0) {
\r
1074 *(BoardSize *)addr = bs;
\r
1079 ExitArgError("Unrecognized board size value", name);
\r
1084 { // [HGM] import name from appData first
\r
1087 for (cc = (ColorClass)0; cc < ColorNormal; cc++) {
\r
1088 textAttribs[cc].sound.name = strdup((&appData.soundShout)[cc]);
\r
1089 textAttribs[cc].sound.data = NULL;
\r
1090 MyLoadSound(&textAttribs[cc].sound);
\r
1092 for (cc = ColorNormal; cc < NColorClasses; cc++) {
\r
1093 textAttribs[cc].sound.name = strdup("");
\r
1094 textAttribs[cc].sound.data = NULL;
\r
1096 for (sc = (SoundClass)0; sc < NSoundClasses; sc++) {
\r
1097 sounds[sc].name = strdup((&appData.soundMove)[sc]);
\r
1098 sounds[sc].data = NULL;
\r
1099 MyLoadSound(&sounds[sc]);
\r
1104 SetCommPortDefaults()
\r
1106 memset(&dcb, 0, sizeof(DCB)); // required by VS 2002 +
\r
1107 dcb.DCBlength = sizeof(DCB);
\r
1108 dcb.BaudRate = 9600;
\r
1109 dcb.fBinary = TRUE;
\r
1110 dcb.fParity = FALSE;
\r
1111 dcb.fOutxCtsFlow = FALSE;
\r
1112 dcb.fOutxDsrFlow = FALSE;
\r
1113 dcb.fDtrControl = DTR_CONTROL_ENABLE;
\r
1114 dcb.fDsrSensitivity = FALSE;
\r
1115 dcb.fTXContinueOnXoff = TRUE;
\r
1116 dcb.fOutX = FALSE;
\r
1118 dcb.fNull = FALSE;
\r
1119 dcb.fRtsControl = RTS_CONTROL_ENABLE;
\r
1120 dcb.fAbortOnError = FALSE;
\r
1122 dcb.Parity = SPACEPARITY;
\r
1123 dcb.StopBits = ONESTOPBIT;
\r
1126 // [HGM] args: these three cases taken out to stay in front-end
\r
1128 SaveFontArg(FILE *f, ArgDescriptor *ad)
\r
1129 { // in WinBoard every board size has its own font, and the "argLoc" identifies the table,
\r
1130 // while the curent board size determines the element. This system should be ported to XBoard.
\r
1131 // What the table contains pointers to, and how to print the font description, remains platform-dependent
\r
1133 for (bs=0; bs<NUM_SIZES; bs++) {
\r
1134 MyFontParams *mfp = &font[bs][(int) ad->argLoc]->mfp;
\r
1135 fprintf(f, "/size=%s ", sizeInfo[bs].name);
\r
1136 fprintf(f, "/%s=\"%s:%g%s%s%s%s%sc%d\"\n",
\r
1137 ad->argName, mfp->faceName, mfp->pointSize,
\r
1138 mfp->bold || mfp->italic || mfp->underline || mfp->strikeout ? " " : "",
\r
1139 mfp->bold ? "b" : "",
\r
1140 mfp->italic ? "i" : "",
\r
1141 mfp->underline ? "u" : "",
\r
1142 mfp->strikeout ? "s" : "",
\r
1143 (int)mfp->charset);
\r
1149 { // [HGM] copy the names from the internal WB variables to appData
\r
1152 for (cc = (ColorClass)0; cc < ColorNormal; cc++)
\r
1153 (&appData.soundShout)[cc] = textAttribs[cc].sound.name;
\r
1154 for (sc = (SoundClass)0; sc < NSoundClasses; sc++)
\r
1155 (&appData.soundMove)[sc] = sounds[sc].name;
\r
1159 SaveAttribsArg(FILE *f, ArgDescriptor *ad)
\r
1160 { // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
\r
1161 MyTextAttribs* ta = &textAttribs[(ColorClass)ad->argLoc];
\r
1162 fprintf(f, "/%s=\"%s%s%s%s%s#%02lx%02lx%02lx\"\n", ad->argName,
\r
1163 (ta->effects & CFE_BOLD) ? "b" : "",
\r
1164 (ta->effects & CFE_ITALIC) ? "i" : "",
\r
1165 (ta->effects & CFE_UNDERLINE) ? "u" : "",
\r
1166 (ta->effects & CFE_STRIKEOUT) ? "s" : "",
\r
1167 (ta->effects) ? " " : "",
\r
1168 ta->color&0xff, (ta->color >> 8)&0xff, (ta->color >> 16)&0xff);
\r
1172 SaveColor(FILE *f, ArgDescriptor *ad)
\r
1173 { // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
\r
1174 COLORREF color = *(COLORREF *)colorVariable[(int)ad->argLoc];
\r
1175 fprintf(f, "/%s=#%02lx%02lx%02lx\n", ad->argName,
\r
1176 color&0xff, (color>>8)&0xff, (color>>16)&0xff);
\r
1180 SaveBoardSize(FILE *f, char *name, void *addr)
\r
1181 { // wrapper to shield back-end from BoardSize & sizeInfo
\r
1182 fprintf(f, "/%s=%s\n", name, sizeInfo[*(BoardSize *)addr].name);
\r
1186 ParseCommPortSettings(char *s)
\r
1187 { // wrapper to keep dcb from back-end
\r
1188 ParseCommSettings(s, &dcb);
\r
1193 { // wrapper to shield use of window handles from back-end (make addressible by number?)
\r
1194 GetActualPlacement(hwndMain, &wpMain);
\r
1195 GetActualPlacement(hwndConsole, &wpConsole);
\r
1196 GetActualPlacement(commentDialog, &wpComment);
\r
1197 GetActualPlacement(editTagsDialog, &wpTags);
\r
1198 GetActualPlacement(gameListDialog, &wpGameList);
\r
1199 GetActualPlacement(moveHistoryDialog, &wpMoveHistory);
\r
1200 GetActualPlacement(evalGraphDialog, &wpEvalGraph);
\r
1201 GetActualPlacement(engineOutputDialog, &wpEngineOutput);
\r
1205 PrintCommPortSettings(FILE *f, char *name)
\r
1206 { // wrapper to shield back-end from DCB
\r
1207 PrintCommSettings(f, name, &dcb);
\r
1211 MySearchPath(char *installDir, char *name, char *fullname)
\r
1214 return (int) SearchPath(installDir, name, NULL, MSG_SIZ, fullname, &dummy);
\r
1218 MyGetFullPathName(char *name, char *fullname)
\r
1221 return (int) GetFullPathName(name, MSG_SIZ, fullname, &dummy);
\r
1226 { // [HGM] args: allows testing if main window is realized from back-end
\r
1227 return hwndMain != NULL;
\r
1231 PopUpStartupDialog()
\r
1235 lpProc = MakeProcInstance((FARPROC)StartupDialog, hInst);
\r
1236 DialogBox(hInst, MAKEINTRESOURCE(DLG_Startup), NULL, (DLGPROC)lpProc);
\r
1237 FreeProcInstance(lpProc);
\r
1240 /*---------------------------------------------------------------------------*\
\r
1242 * GDI board drawing routines
\r
1244 \*---------------------------------------------------------------------------*/
\r
1246 /* [AS] Draw square using background texture */
\r
1247 static void DrawTile( int dx, int dy, int dw, int dh, HDC dst, HDC src, int mode, int sx, int sy )
\r
1252 return; /* Should never happen! */
\r
1255 SetGraphicsMode( dst, GM_ADVANCED );
\r
1262 /* X reflection */
\r
1267 x.eDx = (FLOAT) dw + dx - 1;
\r
1270 SetWorldTransform( dst, &x );
\r
1273 /* Y reflection */
\r
1279 x.eDy = (FLOAT) dh + dy - 1;
\r
1281 SetWorldTransform( dst, &x );
\r
1289 x.eDx = (FLOAT) dx;
\r
1290 x.eDy = (FLOAT) dy;
\r
1293 SetWorldTransform( dst, &x );
\r
1297 BitBlt( dst, dx, dy, dw, dh, src, sx, sy, SRCCOPY );
\r
1305 SetWorldTransform( dst, &x );
\r
1307 ModifyWorldTransform( dst, 0, MWT_IDENTITY );
\r
1310 /* [AS] [HGM] Make room for more piece types, so all pieces can be different */
\r
1312 PM_WP = (int) WhitePawn,
\r
1313 PM_WN = (int) WhiteKnight,
\r
1314 PM_WB = (int) WhiteBishop,
\r
1315 PM_WR = (int) WhiteRook,
\r
1316 PM_WQ = (int) WhiteQueen,
\r
1317 PM_WF = (int) WhiteFerz,
\r
1318 PM_WW = (int) WhiteWazir,
\r
1319 PM_WE = (int) WhiteAlfil,
\r
1320 PM_WM = (int) WhiteMan,
\r
1321 PM_WO = (int) WhiteCannon,
\r
1322 PM_WU = (int) WhiteUnicorn,
\r
1323 PM_WH = (int) WhiteNightrider,
\r
1324 PM_WA = (int) WhiteAngel,
\r
1325 PM_WC = (int) WhiteMarshall,
\r
1326 PM_WAB = (int) WhiteCardinal,
\r
1327 PM_WD = (int) WhiteDragon,
\r
1328 PM_WL = (int) WhiteLance,
\r
1329 PM_WS = (int) WhiteCobra,
\r
1330 PM_WV = (int) WhiteFalcon,
\r
1331 PM_WSG = (int) WhiteSilver,
\r
1332 PM_WG = (int) WhiteGrasshopper,
\r
1333 PM_WK = (int) WhiteKing,
\r
1334 PM_BP = (int) BlackPawn,
\r
1335 PM_BN = (int) BlackKnight,
\r
1336 PM_BB = (int) BlackBishop,
\r
1337 PM_BR = (int) BlackRook,
\r
1338 PM_BQ = (int) BlackQueen,
\r
1339 PM_BF = (int) BlackFerz,
\r
1340 PM_BW = (int) BlackWazir,
\r
1341 PM_BE = (int) BlackAlfil,
\r
1342 PM_BM = (int) BlackMan,
\r
1343 PM_BO = (int) BlackCannon,
\r
1344 PM_BU = (int) BlackUnicorn,
\r
1345 PM_BH = (int) BlackNightrider,
\r
1346 PM_BA = (int) BlackAngel,
\r
1347 PM_BC = (int) BlackMarshall,
\r
1348 PM_BG = (int) BlackGrasshopper,
\r
1349 PM_BAB = (int) BlackCardinal,
\r
1350 PM_BD = (int) BlackDragon,
\r
1351 PM_BL = (int) BlackLance,
\r
1352 PM_BS = (int) BlackCobra,
\r
1353 PM_BV = (int) BlackFalcon,
\r
1354 PM_BSG = (int) BlackSilver,
\r
1355 PM_BK = (int) BlackKing
\r
1358 static HFONT hPieceFont = NULL;
\r
1359 static HBITMAP hPieceMask[(int) EmptySquare];
\r
1360 static HBITMAP hPieceFace[(int) EmptySquare];
\r
1361 static int fontBitmapSquareSize = 0;
\r
1362 static char pieceToFontChar[(int) EmptySquare] =
\r
1363 { 'p', 'n', 'b', 'r', 'q',
\r
1364 'n', 'b', 'p', 'n', 'b', 'r', 'b', 'r', 'q', 'k',
\r
1365 'k', 'o', 'm', 'v', 't', 'w',
\r
1366 'v', 't', 'o', 'm', 'v', 't', 'v', 't', 'w', 'l',
\r
1369 extern BOOL SetCharTable( char *table, const char * map );
\r
1370 /* [HGM] moved to backend.c */
\r
1372 static void SetPieceBackground( HDC hdc, COLORREF color, int mode )
\r
1375 BYTE r1 = GetRValue( color );
\r
1376 BYTE g1 = GetGValue( color );
\r
1377 BYTE b1 = GetBValue( color );
\r
1383 /* Create a uniform background first */
\r
1384 hbrush = CreateSolidBrush( color );
\r
1385 SetRect( &rc, 0, 0, squareSize, squareSize );
\r
1386 FillRect( hdc, &rc, hbrush );
\r
1387 DeleteObject( hbrush );
\r
1390 /* Vertical gradient, good for pawn, knight and rook, less for queen and king */
\r
1391 int steps = squareSize / 2;
\r
1394 for( i=0; i<steps; i++ ) {
\r
1395 BYTE r = r1 - (r1-r2) * i / steps;
\r
1396 BYTE g = g1 - (g1-g2) * i / steps;
\r
1397 BYTE b = b1 - (b1-b2) * i / steps;
\r
1399 hbrush = CreateSolidBrush( RGB(r,g,b) );
\r
1400 SetRect( &rc, i + squareSize - steps, 0, i + squareSize - steps + 1, squareSize );
\r
1401 FillRect( hdc, &rc, hbrush );
\r
1402 DeleteObject(hbrush);
\r
1405 else if( mode == 2 ) {
\r
1406 /* Diagonal gradient, good more or less for every piece */
\r
1407 POINT triangle[3];
\r
1408 HPEN hpen = SelectObject( hdc, GetStockObject(NULL_PEN) );
\r
1409 HBRUSH hbrush_old;
\r
1410 int steps = squareSize;
\r
1413 triangle[0].x = squareSize - steps;
\r
1414 triangle[0].y = squareSize;
\r
1415 triangle[1].x = squareSize;
\r
1416 triangle[1].y = squareSize;
\r
1417 triangle[2].x = squareSize;
\r
1418 triangle[2].y = squareSize - steps;
\r
1420 for( i=0; i<steps; i++ ) {
\r
1421 BYTE r = r1 - (r1-r2) * i / steps;
\r
1422 BYTE g = g1 - (g1-g2) * i / steps;
\r
1423 BYTE b = b1 - (b1-b2) * i / steps;
\r
1425 hbrush = CreateSolidBrush( RGB(r,g,b) );
\r
1426 hbrush_old = SelectObject( hdc, hbrush );
\r
1427 Polygon( hdc, triangle, 3 );
\r
1428 SelectObject( hdc, hbrush_old );
\r
1429 DeleteObject(hbrush);
\r
1434 SelectObject( hdc, hpen );
\r
1439 [AS] The method I use to create the bitmaps it a bit tricky, but it
\r
1440 seems to work ok. The main problem here is to find the "inside" of a chess
\r
1441 piece: follow the steps as explained below.
\r
1443 static void CreatePieceMaskFromFont( HDC hdc_window, HDC hdc, int index )
\r
1447 COLORREF chroma = RGB(0xFF,0x00,0xFF);
\r
1451 int backColor = whitePieceColor;
\r
1452 int foreColor = blackPieceColor;
\r
1454 if( index < (int)BlackPawn && appData.fontBackColorWhite != appData.fontForeColorWhite ) {
\r
1455 backColor = appData.fontBackColorWhite;
\r
1456 foreColor = appData.fontForeColorWhite;
\r
1458 else if( index >= (int)BlackPawn && appData.fontBackColorBlack != appData.fontForeColorBlack ) {
\r
1459 backColor = appData.fontBackColorBlack;
\r
1460 foreColor = appData.fontForeColorBlack;
\r
1464 hbm = CreateCompatibleBitmap( hdc_window, squareSize, squareSize );
\r
1466 hbm_old = SelectObject( hdc, hbm );
\r
1470 rc.right = squareSize;
\r
1471 rc.bottom = squareSize;
\r
1473 /* Step 1: background is now black */
\r
1474 FillRect( hdc, &rc, GetStockObject(BLACK_BRUSH) );
\r
1476 GetTextExtentPoint32( hdc, &pieceToFontChar[index], 1, &sz );
\r
1478 pt.x = (squareSize - sz.cx) / 2;
\r
1479 pt.y = (squareSize - sz.cy) / 2;
\r
1481 SetBkMode( hdc, TRANSPARENT );
\r
1482 SetTextColor( hdc, chroma );
\r
1483 /* Step 2: the piece has been drawn in purple, there are now black and purple in this bitmap */
\r
1484 TextOut( hdc, pt.x, pt.y, &pieceToFontChar[appData.allWhite && index >= (int)BlackPawn ? index - (int)BlackPawn : index], 1 );
\r
1486 SelectObject( hdc, GetStockObject(WHITE_BRUSH) );
\r
1487 /* Step 3: the area outside the piece is filled with white */
\r
1488 // FloodFill( hdc, 0, 0, chroma );
\r
1489 ExtFloodFill( hdc, 0, 0, 0, FLOODFILLSURFACE );
\r
1490 ExtFloodFill( hdc, 0, squareSize-1, 0, FLOODFILLSURFACE ); // [HGM] fill from all 4 corners, for if piece too big
\r
1491 ExtFloodFill( hdc, squareSize-1, 0, 0, FLOODFILLSURFACE );
\r
1492 ExtFloodFill( hdc, squareSize-1, squareSize-1, 0, FLOODFILLSURFACE );
\r
1493 SelectObject( hdc, GetStockObject(BLACK_BRUSH) );
\r
1495 Step 4: this is the tricky part, the area inside the piece is filled with black,
\r
1496 but if the start point is not inside the piece we're lost!
\r
1497 There should be a better way to do this... if we could create a region or path
\r
1498 from the fill operation we would be fine for example.
\r
1500 // FloodFill( hdc, squareSize / 2, squareSize / 2, RGB(0xFF,0xFF,0xFF) );
\r
1501 ExtFloodFill( hdc, squareSize / 2, squareSize / 2, RGB(0xFF,0xFF,0xFF), FLOODFILLBORDER );
\r
1503 { /* [HGM] shave off edges of mask, in an attempt to correct for the fact that FloodFill does not work correctly under Win XP */
\r
1504 HDC dc2 = CreateCompatibleDC( hdc_window );
\r
1505 HBITMAP bm2 = CreateCompatibleBitmap( hdc_window, squareSize, squareSize );
\r
1507 SelectObject( dc2, bm2 );
\r
1508 BitBlt( dc2, 0, 0, squareSize, squareSize, hdc, 0, 0, SRCCOPY ); // make copy
\r
1509 BitBlt( hdc, 0, 1, squareSize-2, squareSize-2, dc2, 1, 1, SRCPAINT );
\r
1510 BitBlt( hdc, 2, 1, squareSize-2, squareSize-2, dc2, 1, 1, SRCPAINT );
\r
1511 BitBlt( hdc, 1, 0, squareSize-2, squareSize-2, dc2, 1, 1, SRCPAINT );
\r
1512 BitBlt( hdc, 1, 2, squareSize-2, squareSize-2, dc2, 1, 1, SRCPAINT );
\r
1515 DeleteObject( bm2 );
\r
1518 SetTextColor( hdc, 0 );
\r
1520 Step 5: some fonts have "disconnected" areas that are skipped by the fill:
\r
1521 draw the piece again in black for safety.
\r
1523 TextOut( hdc, pt.x, pt.y, &pieceToFontChar[appData.allWhite && index >= (int)BlackPawn ? index - (int)BlackPawn : index], 1 );
\r
1525 SelectObject( hdc, hbm_old );
\r
1527 if( hPieceMask[index] != NULL ) {
\r
1528 DeleteObject( hPieceMask[index] );
\r
1531 hPieceMask[index] = hbm;
\r
1534 hbm = CreateCompatibleBitmap( hdc_window, squareSize, squareSize );
\r
1536 SelectObject( hdc, hbm );
\r
1539 HDC dc1 = CreateCompatibleDC( hdc_window );
\r
1540 HDC dc2 = CreateCompatibleDC( hdc_window );
\r
1541 HBITMAP bm2 = CreateCompatibleBitmap( hdc_window, squareSize, squareSize );
\r
1543 SelectObject( dc1, hPieceMask[index] );
\r
1544 SelectObject( dc2, bm2 );
\r
1545 FillRect( dc2, &rc, GetStockObject(WHITE_BRUSH) );
\r
1546 BitBlt( dc2, 0, 0, squareSize, squareSize, dc1, 0, 0, SRCINVERT );
\r
1549 Now dc2 contains the inverse of the piece mask, i.e. a mask that preserves
\r
1550 the piece background and deletes (makes transparent) the rest.
\r
1551 Thanks to that mask, we are free to paint the background with the greates
\r
1552 freedom, as we'll be able to mask off the unwanted parts when finished.
\r
1553 We use this, to make gradients and give the pieces a "roundish" look.
\r
1555 SetPieceBackground( hdc, backColor, 2 );
\r
1556 BitBlt( hdc, 0, 0, squareSize, squareSize, dc2, 0, 0, SRCAND );
\r
1560 DeleteObject( bm2 );
\r
1563 SetTextColor( hdc, foreColor );
\r
1564 TextOut( hdc, pt.x, pt.y, &pieceToFontChar[appData.allWhite && index >= (int)BlackPawn ? index - (int)BlackPawn : index], 1 );
\r
1566 SelectObject( hdc, hbm_old );
\r
1568 if( hPieceFace[index] != NULL ) {
\r
1569 DeleteObject( hPieceFace[index] );
\r
1572 hPieceFace[index] = hbm;
\r
1575 static int TranslatePieceToFontPiece( int piece )
\r
1605 case BlackMarshall:
\r
1609 case BlackNightrider:
\r
1615 case BlackUnicorn:
\r
1619 case BlackGrasshopper:
\r
1631 case BlackCardinal:
\r
1638 case WhiteMarshall:
\r
1642 case WhiteNightrider:
\r
1648 case WhiteUnicorn:
\r
1652 case WhiteGrasshopper:
\r
1664 case WhiteCardinal:
\r
1673 void CreatePiecesFromFont()
\r
1676 HDC hdc_window = NULL;
\r
1682 if( fontBitmapSquareSize < 0 ) {
\r
1683 /* Something went seriously wrong in the past: do not try to recreate fonts! */
\r
1687 if( appData.renderPiecesWithFont == NULL || appData.renderPiecesWithFont[0] == NULLCHAR || appData.renderPiecesWithFont[0] == '*' ) {
\r
1688 fontBitmapSquareSize = -1;
\r
1692 if( fontBitmapSquareSize != squareSize ) {
\r
1693 hdc_window = GetDC( hwndMain );
\r
1694 hdc = CreateCompatibleDC( hdc_window );
\r
1696 if( hPieceFont != NULL ) {
\r
1697 DeleteObject( hPieceFont );
\r
1700 for( i=0; i<=(int)BlackKing; i++ ) {
\r
1701 hPieceMask[i] = NULL;
\r
1702 hPieceFace[i] = NULL;
\r
1708 if( appData.fontPieceSize >= 50 && appData.fontPieceSize <= 150 ) {
\r
1709 fontHeight = appData.fontPieceSize;
\r
1712 fontHeight = (fontHeight * squareSize) / 100;
\r
1714 lf.lfHeight = -MulDiv( fontHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72 );
\r
1716 lf.lfEscapement = 0;
\r
1717 lf.lfOrientation = 0;
\r
1718 lf.lfWeight = FW_NORMAL;
\r
1720 lf.lfUnderline = 0;
\r
1721 lf.lfStrikeOut = 0;
\r
1722 lf.lfCharSet = DEFAULT_CHARSET;
\r
1723 lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
\r
1724 lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
\r
1725 lf.lfQuality = PROOF_QUALITY;
\r
1726 lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
\r
1727 strncpy( lf.lfFaceName, appData.renderPiecesWithFont, sizeof(lf.lfFaceName) );
\r
1728 lf.lfFaceName[ sizeof(lf.lfFaceName) - 1 ] = '\0';
\r
1730 hPieceFont = CreateFontIndirect( &lf );
\r
1732 if( hPieceFont == NULL ) {
\r
1733 fontBitmapSquareSize = -2;
\r
1736 /* Setup font-to-piece character table */
\r
1737 if( ! SetCharTable(pieceToFontChar, appData.fontToPieceTable) ) {
\r
1738 /* No (or wrong) global settings, try to detect the font */
\r
1739 if( strstr(lf.lfFaceName,"Alpha") != NULL ) {
\r
1741 SetCharTable(pieceToFontChar, "phbrqkojntwl");
\r
1743 else if( strstr(lf.lfFaceName,"DiagramTT") != NULL ) {
\r
1744 /* DiagramTT* family */
\r
1745 SetCharTable(pieceToFontChar, "PNLRQKpnlrqk");
\r
1747 else if( strstr(lf.lfFaceName,"WinboardF") != NULL ) {
\r
1748 /* Fairy symbols */
\r
1749 SetCharTable(pieceToFontChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
\r
1751 else if( strstr(lf.lfFaceName,"GC2004D") != NULL ) {
\r
1752 /* Good Companion (Some characters get warped as literal :-( */
\r
1753 char s[] = "1cmWG0??S??oYI23wgQU";
\r
1754 s[0]=0xB9; s[1]=0xA9; s[6]=0xB1; s[11]=0xBB; s[12]=0xAB; s[17]=0xB3;
\r
1755 SetCharTable(pieceToFontChar, s);
\r
1758 /* Cases, Condal, Leipzig, Lucena, Marroquin, Merida, Usual */
\r
1759 SetCharTable(pieceToFontChar, "pnbrqkomvtwl");
\r
1763 /* Create bitmaps */
\r
1764 hfont_old = SelectObject( hdc, hPieceFont );
\r
1765 for(i=(int)WhitePawn; i<(int)EmptySquare; i++) /* [HGM] made a loop for this */
\r
1766 if(PieceToChar((ChessSquare)i) != '.') /* skip unused pieces */
\r
1767 CreatePieceMaskFromFont( hdc_window, hdc, i );
\r
1769 SelectObject( hdc, hfont_old );
\r
1771 fontBitmapSquareSize = squareSize;
\r
1775 if( hdc != NULL ) {
\r
1779 if( hdc_window != NULL ) {
\r
1780 ReleaseDC( hwndMain, hdc_window );
\r
1785 DoLoadBitmap(HINSTANCE hinst, char *piece, int squareSize, char *suffix)
\r
1789 sprintf(name, "%s%d%s", piece, squareSize, suffix);
\r
1790 if (gameInfo.event &&
\r
1791 strcmp(gameInfo.event, "Easter Egg Hunt") == 0 &&
\r
1792 strcmp(name, "k80s") == 0) {
\r
1793 strcpy(name, "tim");
\r
1795 return LoadBitmap(hinst, name);
\r
1799 /* Insert a color into the program's logical palette
\r
1800 structure. This code assumes the given color is
\r
1801 the result of the RGB or PALETTERGB macro, and it
\r
1802 knows how those macros work (which is documented).
\r
1805 InsertInPalette(COLORREF color)
\r
1807 LPPALETTEENTRY pe = &(pLogPal->palPalEntry[pLogPal->palNumEntries]);
\r
1809 if (pLogPal->palNumEntries++ >= PALETTESIZE) {
\r
1810 DisplayFatalError("Too many colors", 0, 1);
\r
1811 pLogPal->palNumEntries--;
\r
1815 pe->peFlags = (char) 0;
\r
1816 pe->peRed = (char) (0xFF & color);
\r
1817 pe->peGreen = (char) (0xFF & (color >> 8));
\r
1818 pe->peBlue = (char) (0xFF & (color >> 16));
\r
1824 InitDrawingColors()
\r
1826 if (pLogPal == NULL) {
\r
1827 /* Allocate enough memory for a logical palette with
\r
1828 * PALETTESIZE entries and set the size and version fields
\r
1829 * of the logical palette structure.
\r
1831 pLogPal = (NPLOGPALETTE)
\r
1832 LocalAlloc(LMEM_FIXED, (sizeof(LOGPALETTE) +
\r
1833 (sizeof(PALETTEENTRY) * (PALETTESIZE))));
\r
1834 pLogPal->palVersion = 0x300;
\r
1836 pLogPal->palNumEntries = 0;
\r
1838 InsertInPalette(lightSquareColor);
\r
1839 InsertInPalette(darkSquareColor);
\r
1840 InsertInPalette(whitePieceColor);
\r
1841 InsertInPalette(blackPieceColor);
\r
1842 InsertInPalette(highlightSquareColor);
\r
1843 InsertInPalette(premoveHighlightColor);
\r
1845 /* create a logical color palette according the information
\r
1846 * in the LOGPALETTE structure.
\r
1848 hPal = CreatePalette((LPLOGPALETTE) pLogPal);
\r
1850 lightSquareBrush = CreateSolidBrush(lightSquareColor);
\r
1851 blackSquareBrush = CreateSolidBrush(blackPieceColor);
\r
1852 darkSquareBrush = CreateSolidBrush(darkSquareColor);
\r
1853 whitePieceBrush = CreateSolidBrush(whitePieceColor);
\r
1854 blackPieceBrush = CreateSolidBrush(blackPieceColor);
\r
1855 iconBkgndBrush = CreateSolidBrush(GetSysColor(COLOR_BACKGROUND));
\r
1856 explodeBrush = CreateSolidBrush(highlightSquareColor); // [HGM] atomic
\r
1857 markerBrush = CreateSolidBrush(premoveHighlightColor); // [HGM] markers
\r
1858 /* [AS] Force rendering of the font-based pieces */
\r
1859 if( fontBitmapSquareSize > 0 ) {
\r
1860 fontBitmapSquareSize = 0;
\r
1866 BoardWidth(int boardSize, int n)
\r
1867 { /* [HGM] argument n added to allow different width and height */
\r
1868 int lineGap = sizeInfo[boardSize].lineGap;
\r
1870 if( appData.overrideLineGap >= 0 && appData.overrideLineGap <= 5 ) {
\r
1871 lineGap = appData.overrideLineGap;
\r
1874 return (n + 1) * lineGap +
\r
1875 n * sizeInfo[boardSize].squareSize;
\r
1878 /* Respond to board resize by dragging edge */
\r
1880 ResizeBoard(int newSizeX, int newSizeY, int flags)
\r
1882 BoardSize newSize = NUM_SIZES - 1;
\r
1883 static int recurse = 0;
\r
1884 if (IsIconic(hwndMain)) return;
\r
1885 if (recurse > 0) return;
\r
1887 while (newSize > 0) {
\r
1888 InitDrawingSizes(newSize+1000, 0); // [HGM] kludge to update sizeInfo without visible effects
\r
1889 if(newSizeX >= sizeInfo[newSize].cliWidth &&
\r
1890 newSizeY >= sizeInfo[newSize].cliHeight) break;
\r
1893 boardSize = newSize;
\r
1894 InitDrawingSizes(boardSize, flags);
\r
1901 InitDrawingSizes(BoardSize boardSize, int flags)
\r
1903 int i, boardWidth, boardHeight; /* [HGM] height treated separately */
\r
1904 ChessSquare piece;
\r
1905 static int oldBoardSize = -1, oldTinyLayout = 0;
\r
1907 SIZE clockSize, messageSize;
\r
1909 char buf[MSG_SIZ];
\r
1911 HMENU hmenu = GetMenu(hwndMain);
\r
1912 RECT crect, wrect, oldRect;
\r
1914 LOGBRUSH logbrush;
\r
1916 int suppressVisibleEffects = 0; // [HGM] kludge to request updating sizeInfo only
\r
1917 if((int)boardSize >= 1000 ) { boardSize -= 1000; suppressVisibleEffects = 1; }
\r
1919 /* [HGM] call with -2 uses old size (for if nr of files, ranks changes) */
\r
1920 if(boardSize == (BoardSize)(-2) ) boardSize = oldBoardSize;
\r
1922 oldRect.left = wpMain.x; //[HGM] placement: remember previous window params
\r
1923 oldRect.top = wpMain.y;
\r
1924 oldRect.right = wpMain.x + wpMain.width;
\r
1925 oldRect.bottom = wpMain.y + wpMain.height;
\r
1927 tinyLayout = sizeInfo[boardSize].tinyLayout;
\r
1928 smallLayout = sizeInfo[boardSize].smallLayout;
\r
1929 squareSize = sizeInfo[boardSize].squareSize;
\r
1930 lineGap = sizeInfo[boardSize].lineGap;
\r
1931 minorSize = 0; /* [HGM] Kludge to see if demagnified pieces need to be shifted */
\r
1933 if( appData.overrideLineGap >= 0 && appData.overrideLineGap <= 5 ) {
\r
1934 lineGap = appData.overrideLineGap;
\r
1937 if (tinyLayout != oldTinyLayout) {
\r
1938 long style = GetWindowLong(hwndMain, GWL_STYLE);
\r
1940 style &= ~WS_SYSMENU;
\r
1941 InsertMenu(hmenu, IDM_Exit, MF_BYCOMMAND, IDM_Minimize,
\r
1942 "&Minimize\tCtrl+F4");
\r
1944 style |= WS_SYSMENU;
\r
1945 RemoveMenu(hmenu, IDM_Minimize, MF_BYCOMMAND);
\r
1947 SetWindowLong(hwndMain, GWL_STYLE, style);
\r
1949 for (i=0; menuBarText[tinyLayout][i]; i++) {
\r
1950 ModifyMenu(hmenu, i, MF_STRING|MF_BYPOSITION|MF_POPUP,
\r
1951 (UINT)GetSubMenu(hmenu, i), menuBarText[tinyLayout][i]);
\r
1953 DrawMenuBar(hwndMain);
\r
1956 boardWidth = BoardWidth(boardSize, BOARD_WIDTH);
\r
1957 boardHeight = BoardWidth(boardSize, BOARD_HEIGHT);
\r
1959 /* Get text area sizes */
\r
1960 hdc = GetDC(hwndMain);
\r
1961 if (appData.clockMode) {
\r
1962 sprintf(buf, "White: %s", TimeString(23*60*60*1000L));
\r
1964 sprintf(buf, "White");
\r
1966 oldFont = SelectObject(hdc, font[boardSize][CLOCK_FONT]->hf);
\r
1967 GetTextExtentPoint(hdc, buf, strlen(buf), &clockSize);
\r
1968 SelectObject(hdc, font[boardSize][MESSAGE_FONT]->hf);
\r
1969 str = "We only care about the height here";
\r
1970 GetTextExtentPoint(hdc, str, strlen(str), &messageSize);
\r
1971 SelectObject(hdc, oldFont);
\r
1972 ReleaseDC(hwndMain, hdc);
\r
1974 /* Compute where everything goes */
\r
1975 if((first.programLogo || second.programLogo) && !tinyLayout) {
\r
1976 /* [HGM] logo: if either logo is on, reserve space for it */
\r
1977 logoHeight = 2*clockSize.cy;
\r
1978 leftLogoRect.left = OUTER_MARGIN;
\r
1979 leftLogoRect.right = leftLogoRect.left + 4*clockSize.cy;
\r
1980 leftLogoRect.top = OUTER_MARGIN;
\r
1981 leftLogoRect.bottom = OUTER_MARGIN + logoHeight;
\r
1983 rightLogoRect.right = OUTER_MARGIN + boardWidth;
\r
1984 rightLogoRect.left = rightLogoRect.right - 4*clockSize.cy;
\r
1985 rightLogoRect.top = OUTER_MARGIN;
\r
1986 rightLogoRect.bottom = OUTER_MARGIN + logoHeight;
\r
1989 whiteRect.left = leftLogoRect.right;
\r
1990 whiteRect.right = OUTER_MARGIN + boardWidth/2 - INNER_MARGIN/2;
\r
1991 whiteRect.top = OUTER_MARGIN;
\r
1992 whiteRect.bottom = whiteRect.top + logoHeight;
\r
1994 blackRect.right = rightLogoRect.left;
\r
1995 blackRect.left = whiteRect.right + INNER_MARGIN;
\r
1996 blackRect.top = whiteRect.top;
\r
1997 blackRect.bottom = whiteRect.bottom;
\r
1999 whiteRect.left = OUTER_MARGIN;
\r
2000 whiteRect.right = whiteRect.left + boardWidth/2 - INNER_MARGIN/2;
\r
2001 whiteRect.top = OUTER_MARGIN;
\r
2002 whiteRect.bottom = whiteRect.top + clockSize.cy;
\r
2004 blackRect.left = whiteRect.right + INNER_MARGIN;
\r
2005 blackRect.right = blackRect.left + boardWidth/2 - 1;
\r
2006 blackRect.top = whiteRect.top;
\r
2007 blackRect.bottom = whiteRect.bottom;
\r
2009 logoHeight = 0; // [HGM] logo: suppress logo after change to tiny layout!
\r
2012 messageRect.left = OUTER_MARGIN + MESSAGE_LINE_LEFTMARGIN;
\r
2013 if (appData.showButtonBar) {
\r
2014 messageRect.right = OUTER_MARGIN + boardWidth // [HGM] logo: expressed independent of clock placement
\r
2015 - N_BUTTONS*BUTTON_WIDTH - MESSAGE_LINE_LEFTMARGIN;
\r
2017 messageRect.right = OUTER_MARGIN + boardWidth;
\r
2019 messageRect.top = whiteRect.bottom + INNER_MARGIN;
\r
2020 messageRect.bottom = messageRect.top + messageSize.cy;
\r
2022 boardRect.left = OUTER_MARGIN;
\r
2023 boardRect.right = boardRect.left + boardWidth;
\r
2024 boardRect.top = messageRect.bottom + INNER_MARGIN;
\r
2025 boardRect.bottom = boardRect.top + boardHeight;
\r
2027 sizeInfo[boardSize].cliWidth = boardRect.right + OUTER_MARGIN;
\r
2028 sizeInfo[boardSize].cliHeight = boardRect.bottom + OUTER_MARGIN;
\r
2029 oldBoardSize = boardSize;
\r
2030 oldTinyLayout = tinyLayout;
\r
2031 winW = 2 * GetSystemMetrics(SM_CXFRAME) + boardRect.right + OUTER_MARGIN;
\r
2032 winH = 2 * GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYMENU) +
\r
2033 GetSystemMetrics(SM_CYCAPTION) + boardRect.bottom + OUTER_MARGIN;
\r
2034 if(suppressVisibleEffects) return; // [HGM] when called for filling sizeInfo only
\r
2035 wpMain.width = winW; // [HGM] placement: set through temporary which can used by initial sizing choice
\r
2036 wpMain.height = winH; // without disturbing window attachments
\r
2037 GetWindowRect(hwndMain, &wrect);
\r
2038 SetWindowPos(hwndMain, NULL, 0, 0, wpMain.width, wpMain.height,
\r
2039 SWP_NOCOPYBITS|SWP_NOZORDER|SWP_NOMOVE);
\r
2041 // [HGM] placement: let attached windows follow size change.
\r
2042 ReattachAfterSize( &oldRect, wpMain.width, wpMain.height, moveHistoryDialog, &wpMoveHistory );
\r
2043 ReattachAfterSize( &oldRect, wpMain.width, wpMain.height, evalGraphDialog, &wpEvalGraph );
\r
2044 ReattachAfterSize( &oldRect, wpMain.width, wpMain.height, engineOutputDialog, &wpEngineOutput );
\r
2045 ReattachAfterSize( &oldRect, wpMain.width, wpMain.height, gameListDialog, &wpGameList );
\r
2046 ReattachAfterSize( &oldRect, wpMain.width, wpMain.height, hwndConsole, &wpConsole );
\r
2048 /* compensate if menu bar wrapped */
\r
2049 GetClientRect(hwndMain, &crect);
\r
2050 offby = boardRect.bottom + OUTER_MARGIN - crect.bottom;
\r
2051 wpMain.height += offby;
\r
2053 case WMSZ_TOPLEFT:
\r
2054 SetWindowPos(hwndMain, NULL,
\r
2055 wrect.right - wpMain.width, wrect.bottom - wpMain.height,
\r
2056 wpMain.width, wpMain.height, SWP_NOCOPYBITS|SWP_NOZORDER);
\r
2059 case WMSZ_TOPRIGHT:
\r
2061 SetWindowPos(hwndMain, NULL,
\r
2062 wrect.left, wrect.bottom - wpMain.height,
\r
2063 wpMain.width, wpMain.height, SWP_NOCOPYBITS|SWP_NOZORDER);
\r
2066 case WMSZ_BOTTOMLEFT:
\r
2068 SetWindowPos(hwndMain, NULL,
\r
2069 wrect.right - wpMain.width, wrect.top,
\r
2070 wpMain.width, wpMain.height, SWP_NOCOPYBITS|SWP_NOZORDER);
\r
2073 case WMSZ_BOTTOMRIGHT:
\r
2077 SetWindowPos(hwndMain, NULL, 0, 0, wpMain.width, wpMain.height,
\r
2078 SWP_NOCOPYBITS|SWP_NOZORDER|SWP_NOMOVE);
\r
2083 for (i = 0; i < N_BUTTONS; i++) {
\r
2084 if (buttonDesc[i].hwnd != NULL) {
\r
2085 DestroyWindow(buttonDesc[i].hwnd);
\r
2086 buttonDesc[i].hwnd = NULL;
\r
2088 if (appData.showButtonBar) {
\r
2089 buttonDesc[i].hwnd =
\r
2090 CreateWindow("BUTTON", buttonDesc[i].label,
\r
2091 WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
\r
2092 boardRect.right - BUTTON_WIDTH*(N_BUTTONS-i),
\r
2093 messageRect.top, BUTTON_WIDTH, messageSize.cy, hwndMain,
\r
2094 (HMENU) buttonDesc[i].id,
\r
2095 (HINSTANCE) GetWindowLong(hwndMain, GWL_HINSTANCE), NULL);
\r
2097 SendMessage(buttonDesc[i].hwnd, WM_SETFONT,
\r
2098 (WPARAM)font[boardSize][MESSAGE_FONT]->hf,
\r
2099 MAKELPARAM(FALSE, 0));
\r
2101 if (buttonDesc[i].id == IDM_Pause)
\r
2102 hwndPause = buttonDesc[i].hwnd;
\r
2103 buttonDesc[i].wndproc = (WNDPROC)
\r
2104 SetWindowLong(buttonDesc[i].hwnd, GWL_WNDPROC, (LONG) ButtonProc);
\r
2107 if (gridPen != NULL) DeleteObject(gridPen);
\r
2108 if (highlightPen != NULL) DeleteObject(highlightPen);
\r
2109 if (premovePen != NULL) DeleteObject(premovePen);
\r
2110 if (lineGap != 0) {
\r
2111 logbrush.lbStyle = BS_SOLID;
\r
2112 logbrush.lbColor = RGB(0, 0, 0); /* grid pen color = black */
\r
2114 ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_MITER,
\r
2115 lineGap, &logbrush, 0, NULL);
\r
2116 logbrush.lbColor = highlightSquareColor;
\r
2118 ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_MITER,
\r
2119 lineGap, &logbrush, 0, NULL);
\r
2121 logbrush.lbColor = premoveHighlightColor;
\r
2123 ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_MITER,
\r
2124 lineGap, &logbrush, 0, NULL);
\r
2126 /* [HGM] Loop had to be split in part for vert. and hor. lines */
\r
2127 for (i = 0; i < BOARD_HEIGHT + 1; i++) {
\r
2128 gridEndpoints[i*2].x = boardRect.left + lineGap / 2;
\r
2129 gridEndpoints[i*2].y = gridEndpoints[i*2 + 1].y =
\r
2130 boardRect.top + lineGap / 2 + (i * (squareSize + lineGap));
\r
2131 gridEndpoints[i*2 + 1].x = boardRect.left + lineGap / 2 +
\r
2132 BOARD_WIDTH * (squareSize + lineGap);
\r
2133 gridVertexCounts[i*2] = gridVertexCounts[i*2 + 1] = 2;
\r
2135 for (i = 0; i < BOARD_WIDTH + 1; i++) {
\r
2136 gridEndpoints[i*2 + BOARD_HEIGHT*2 + 2].y = boardRect.top + lineGap / 2;
\r
2137 gridEndpoints[i*2 + BOARD_HEIGHT*2 + 2].x =
\r
2138 gridEndpoints[i*2 + 1 + BOARD_HEIGHT*2 + 2].x = boardRect.left +
\r
2139 lineGap / 2 + (i * (squareSize + lineGap));
\r
2140 gridEndpoints[i*2 + 1 + BOARD_HEIGHT*2 + 2].y =
\r
2141 boardRect.top + BOARD_HEIGHT * (squareSize + lineGap);
\r
2142 gridVertexCounts[i*2] = gridVertexCounts[i*2 + 1] = 2;
\r
2146 /* [HGM] Licensing requirement */
\r
2148 if(gameInfo.variant == VariantGothic) GothicPopUp( GOTHIC, VariantGothic); else
\r
2151 if(gameInfo.variant == VariantFalcon) GothicPopUp( FALCON, VariantFalcon); else
\r
2153 GothicPopUp( "", VariantNormal);
\r
2156 /* if (boardSize == oldBoardSize) return; [HGM] variant might have changed */
\r
2158 /* Load piece bitmaps for this board size */
\r
2159 for (i=0; i<=2; i++) {
\r
2160 for (piece = WhitePawn;
\r
2161 (int) piece < (int) BlackPawn;
\r
2162 piece = (ChessSquare) ((int) piece + 1)) {
\r
2163 if (pieceBitmap[i][piece] != NULL)
\r
2164 DeleteObject(pieceBitmap[i][piece]);
\r
2168 fontBitmapSquareSize = 0; /* [HGM] render: make sure pieces will be recreated, as we might need others now */
\r
2169 // Orthodox Chess pieces
\r
2170 pieceBitmap[0][WhitePawn] = DoLoadBitmap(hInst, "p", squareSize, "s");
\r
2171 pieceBitmap[0][WhiteKnight] = DoLoadBitmap(hInst, "n", squareSize, "s");
\r
2172 pieceBitmap[0][WhiteBishop] = DoLoadBitmap(hInst, "b", squareSize, "s");
\r
2173 pieceBitmap[0][WhiteRook] = DoLoadBitmap(hInst, "r", squareSize, "s");
\r
2174 pieceBitmap[0][WhiteKing] = DoLoadBitmap(hInst, "k", squareSize, "s");
\r
2175 pieceBitmap[1][WhitePawn] = DoLoadBitmap(hInst, "p", squareSize, "o");
\r
2176 pieceBitmap[1][WhiteKnight] = DoLoadBitmap(hInst, "n", squareSize, "o");
\r
2177 pieceBitmap[1][WhiteBishop] = DoLoadBitmap(hInst, "b", squareSize, "o");
\r
2178 pieceBitmap[1][WhiteRook] = DoLoadBitmap(hInst, "r", squareSize, "o");
\r
2179 pieceBitmap[1][WhiteKing] = DoLoadBitmap(hInst, "k", squareSize, "o");
\r
2180 pieceBitmap[2][WhitePawn] = DoLoadBitmap(hInst, "p", squareSize, "w");
\r
2181 pieceBitmap[2][WhiteKnight] = DoLoadBitmap(hInst, "n", squareSize, "w");
\r
2182 pieceBitmap[2][WhiteBishop] = DoLoadBitmap(hInst, "b", squareSize, "w");
\r
2183 pieceBitmap[2][WhiteRook] = DoLoadBitmap(hInst, "r", squareSize, "w");
\r
2184 pieceBitmap[2][WhiteKing] = DoLoadBitmap(hInst, "k", squareSize, "w");
\r
2185 if( !strcmp(appData.variant, "shogi") && (squareSize==72 || squareSize==49)) {
\r
2186 // in Shogi, Hijack the unused Queen for Lance
\r
2187 pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "s");
\r
2188 pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "o");
\r
2189 pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "w");
\r
2191 pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "s");
\r
2192 pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "o");
\r
2193 pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "w");
\r
2196 if(squareSize <= 72 && squareSize >= 33) {
\r
2197 /* A & C are available in most sizes now */
\r
2198 if(squareSize != 49 && squareSize != 72 && squareSize != 33) { // Vortex-like
\r
2199 pieceBitmap[0][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "s");
\r
2200 pieceBitmap[1][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "o");
\r
2201 pieceBitmap[2][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "w");
\r
2202 pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "s");
\r
2203 pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "o");
\r
2204 pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "w");
\r
2205 pieceBitmap[0][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "s");
\r
2206 pieceBitmap[1][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "o");
\r
2207 pieceBitmap[2][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "w");
\r
2208 pieceBitmap[0][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "s");
\r
2209 pieceBitmap[1][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "o");
\r
2210 pieceBitmap[2][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "w");
\r
2211 } else { // Smirf-like
\r
2212 pieceBitmap[0][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "s");
\r
2213 pieceBitmap[1][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "o");
\r
2214 pieceBitmap[2][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "w");
\r
2216 if(gameInfo.variant == VariantGothic) { // Vortex-like
\r
2217 pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "s");
\r
2218 pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "o");
\r
2219 pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "w");
\r
2220 } else { // WinBoard standard
\r
2221 pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "s");
\r
2222 pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "o");
\r
2223 pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "w");
\r
2228 if(squareSize==72 || squareSize==49 || squareSize==33) { /* experiment with some home-made bitmaps */
\r
2229 pieceBitmap[0][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "s");
\r
2230 pieceBitmap[1][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "o");
\r
2231 pieceBitmap[2][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "w");
\r
2232 pieceBitmap[0][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "s");
\r
2233 pieceBitmap[1][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "o");
\r
2234 pieceBitmap[2][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "w");
\r
2235 pieceBitmap[0][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "s");
\r
2236 pieceBitmap[1][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "o");
\r
2237 pieceBitmap[2][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "w");
\r
2238 pieceBitmap[0][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "s");
\r
2239 pieceBitmap[1][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "o");
\r
2240 pieceBitmap[2][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "w");
\r
2241 pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "s");
\r
2242 pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "o");
\r
2243 pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "w");
\r
2244 pieceBitmap[0][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "s");
\r
2245 pieceBitmap[1][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "o");
\r
2246 pieceBitmap[2][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "w");
\r
2247 pieceBitmap[0][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "s");
\r
2248 pieceBitmap[1][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "o");
\r
2249 pieceBitmap[2][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "w");
\r
2250 pieceBitmap[0][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "s");
\r
2251 pieceBitmap[1][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "o");
\r
2252 pieceBitmap[2][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "w");
\r
2253 pieceBitmap[0][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "s");
\r
2254 pieceBitmap[1][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "o");
\r
2255 pieceBitmap[2][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "w");
\r
2256 pieceBitmap[0][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "s");
\r
2257 pieceBitmap[1][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "o");
\r
2258 pieceBitmap[2][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "w");
\r
2260 if(gameInfo.variant == VariantShogi) { /* promoted Gold represemtations */
\r
2261 pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "wp", squareSize, "s");
\r
2262 pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "wp", squareSize, "o");
\r
2263 pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "w", squareSize, "w");
\r
2264 pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "s");
\r
2265 pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "o");
\r
2266 pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "w", squareSize, "w");
\r
2267 pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "s");
\r
2268 pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "o");
\r
2269 pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "w", squareSize, "w");
\r
2270 pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "s");
\r
2271 pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "o");
\r
2272 pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "w", squareSize, "w");
\r
2274 pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "s");
\r
2275 pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "o");
\r
2276 pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "w");
\r
2277 pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "s");
\r
2278 pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "o");
\r
2279 pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "w");
\r
2280 pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "s");
\r
2281 pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "o");
\r
2282 pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "w");
\r
2283 pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "s");
\r
2284 pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "o");
\r
2285 pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "w");
\r
2288 } else { /* other size, no special bitmaps available. Use smaller symbols */
\r
2289 if((int)boardSize < 2) minorSize = sizeInfo[0].squareSize;
\r
2290 else minorSize = sizeInfo[(int)boardSize - 2].squareSize;
\r
2291 pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "s");
\r
2292 pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "o");
\r
2293 pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "w");
\r
2294 pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "s");
\r
2295 pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "o");
\r
2296 pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "w");
\r
2297 pieceBitmap[0][WhiteDragon] = DoLoadBitmap(hInst, "r", minorSize, "s");
\r
2298 pieceBitmap[1][WhiteDragon] = DoLoadBitmap(hInst, "r", minorSize, "o");
\r
2299 pieceBitmap[2][WhiteDragon] = DoLoadBitmap(hInst, "r", minorSize, "w");
\r
2300 pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "s");
\r
2301 pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "o");
\r
2302 pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "w");
\r
2306 if(gameInfo.variant == VariantShogi && squareSize == 58)
\r
2307 /* special Shogi support in this size */
\r
2308 { for (i=0; i<=2; i++) { /* replace all bitmaps */
\r
2309 for (piece = WhitePawn;
\r
2310 (int) piece < (int) BlackPawn;
\r
2311 piece = (ChessSquare) ((int) piece + 1)) {
\r
2312 if (pieceBitmap[i][piece] != NULL)
\r
2313 DeleteObject(pieceBitmap[i][piece]);
\r
2316 pieceBitmap[0][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "o");
\r
2317 pieceBitmap[0][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "o");
\r
2318 pieceBitmap[0][WhiteBishop] = DoLoadBitmap(hInst, "sb", squareSize, "o");
\r
2319 pieceBitmap[0][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "o");
\r
2320 pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "o");
\r
2321 pieceBitmap[0][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "o");
\r
2322 pieceBitmap[0][WhiteFerz] = DoLoadBitmap(hInst, "sf", squareSize, "o");
\r
2323 pieceBitmap[0][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "o");
\r
2324 pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "su", squareSize, "o");
\r
2325 pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "sh", squareSize, "o");
\r
2326 pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "sa", squareSize, "o");
\r
2327 pieceBitmap[0][WhiteDragon] = DoLoadBitmap(hInst, "sc", squareSize, "o");
\r
2328 pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "sg", squareSize, "o");
\r
2329 pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "ss", squareSize, "o");
\r
2330 pieceBitmap[1][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "o");
\r
2331 pieceBitmap[1][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "o");
\r
2332 pieceBitmap[1][WhiteBishop] = DoLoadBitmap(hInst, "sb", squareSize, "o");
\r
2333 pieceBitmap[1][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "o");
\r
2334 pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "o");
\r
2335 pieceBitmap[1][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "o");
\r
2336 pieceBitmap[1][WhiteFerz] = DoLoadBitmap(hInst, "sf", squareSize, "o");
\r
2337 pieceBitmap[1][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "o");
\r
2338 pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "su", squareSize, "o");
\r
2339 pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "sh", squareSize, "o");
\r
2340 pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "sa", squareSize, "o");
\r
2341 pieceBitmap[1][WhiteDragon] = DoLoadBitmap(hInst, "sc", squareSize, "o");
\r
2342 pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "sg", squareSize, "o");
\r
2343 pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "ss", squareSize, "o");
\r
2344 pieceBitmap[2][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "w");
\r
2345 pieceBitmap[2][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "w");
\r
2346 pieceBitmap[2][WhiteBishop] = DoLoadBitmap(hInst, "sr", squareSize, "w");
\r
2347 pieceBitmap[2][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "w");
\r
2348 pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "w");
\r
2349 pieceBitmap[2][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "w");
\r
2350 pieceBitmap[2][WhiteFerz] = DoLoadBitmap(hInst, "sw", squareSize, "w");
\r
2351 pieceBitmap[2][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "w");
\r
2352 pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "sp", squareSize, "w");
\r
2353 pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "sn", squareSize, "w");
\r
2354 pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "sr", squareSize, "w");
\r
2355 pieceBitmap[2][WhiteDragon] = DoLoadBitmap(hInst, "sr", squareSize, "w");
\r
2356 pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "sl", squareSize, "w");
\r
2357 pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "sw", squareSize, "w");
\r
2363 PieceBitmap(ChessSquare p, int kind)
\r
2365 if ((int) p >= (int) BlackPawn)
\r
2366 p = (ChessSquare) ((int) p - (int) BlackPawn + (int) WhitePawn);
\r
2368 return pieceBitmap[kind][(int) p];
\r
2371 /***************************************************************/
\r
2373 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
\r
2374 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
\r
2376 #define MIN3(a,b,c) (((a) < (b) && (a) < (c)) ? (a) : (((b) < (a) && (b) < (c)) ? (b) : (c)))
\r
2377 #define MAX3(a,b,c) (((a) > (b) && (a) > (c)) ? (a) : (((b) > (a) && (b) > (c)) ? (b) : (c)))
\r
2381 SquareToPos(int row, int column, int * x, int * y)
\r
2384 *x = boardRect.left + lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
\r
2385 *y = boardRect.top + lineGap + row * (squareSize + lineGap);
\r
2387 *x = boardRect.left + lineGap + column * (squareSize + lineGap);
\r
2388 *y = boardRect.top + lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
\r
2393 DrawCoordsOnDC(HDC hdc)
\r
2395 static char files[24] = {'0', '1','2','3','4','5','6','7','8','9','0','1','1','0','9','8','7','6','5','4','3','2','1','0'};
\r
2396 static char ranks[24] = {'l', 'k','j','i','h','g','f','e','d','c','b','a','a','b','c','d','e','f','g','h','i','j','k','l'};
\r
2397 char str[2] = { NULLCHAR, NULLCHAR };
\r
2398 int oldMode, oldAlign, x, y, start, i;
\r
2402 if (!appData.showCoords)
\r
2405 start = flipView ? 1-(ONE!='1') : 23+(ONE!='1')-BOARD_HEIGHT;
\r
2407 oldBrush = SelectObject(hdc, GetStockObject(BLACK_BRUSH));
\r
2408 oldMode = SetBkMode(hdc, (appData.monoMode ? OPAQUE : TRANSPARENT));
\r
2409 oldAlign = GetTextAlign(hdc);
\r
2410 oldFont = SelectObject(hdc, font[boardSize][COORD_FONT]->hf);
\r
2412 y = boardRect.top + lineGap;
\r
2413 x = boardRect.left + lineGap + gameInfo.holdingsWidth*(squareSize + lineGap);
\r
2415 SetTextAlign(hdc, TA_LEFT|TA_TOP);
\r
2416 for (i = 0; i < BOARD_HEIGHT; i++) {
\r
2417 str[0] = files[start + i];
\r
2418 ExtTextOut(hdc, x + 2, y + 1, 0, NULL, str, 1, NULL);
\r
2419 y += squareSize + lineGap;
\r
2422 start = flipView ? 12-(BOARD_RGHT-BOARD_LEFT) : 12;
\r
2424 SetTextAlign(hdc, TA_RIGHT|TA_BOTTOM);
\r
2425 for (i = 0; i < BOARD_RGHT - BOARD_LEFT; i++) {
\r
2426 str[0] = ranks[start + i];
\r
2427 ExtTextOut(hdc, x + squareSize - 2, y - 1, 0, NULL, str, 1, NULL);
\r
2428 x += squareSize + lineGap;
\r
2431 SelectObject(hdc, oldBrush);
\r
2432 SetBkMode(hdc, oldMode);
\r
2433 SetTextAlign(hdc, oldAlign);
\r
2434 SelectObject(hdc, oldFont);
\r
2438 DrawGridOnDC(HDC hdc)
\r
2442 if (lineGap != 0) {
\r
2443 oldPen = SelectObject(hdc, gridPen);
\r
2444 PolyPolyline(hdc, gridEndpoints, gridVertexCounts, BOARD_WIDTH+BOARD_HEIGHT + 2);
\r
2445 SelectObject(hdc, oldPen);
\r
2449 #define HIGHLIGHT_PEN 0
\r
2450 #define PREMOVE_PEN 1
\r
2453 DrawHighlightOnDC(HDC hdc, BOOLEAN on, int x, int y, int pen)
\r
2456 HPEN oldPen, hPen;
\r
2457 if (lineGap == 0) return;
\r
2459 x1 = boardRect.left +
\r
2460 lineGap/2 + ((BOARD_WIDTH-1)-x) * (squareSize + lineGap);
\r
2461 y1 = boardRect.top +
\r
2462 lineGap/2 + y * (squareSize + lineGap);
\r
2464 x1 = boardRect.left +
\r
2465 lineGap/2 + x * (squareSize + lineGap);
\r
2466 y1 = boardRect.top +
\r
2467 lineGap/2 + ((BOARD_HEIGHT-1)-y) * (squareSize + lineGap);
\r
2469 hPen = pen ? premovePen : highlightPen;
\r
2470 oldPen = SelectObject(hdc, on ? hPen : gridPen);
\r
2471 MoveToEx(hdc, x1, y1, NULL);
\r
2472 LineTo(hdc, x1 + squareSize + lineGap, y1);
\r
2473 LineTo(hdc, x1 + squareSize + lineGap, y1 + squareSize + lineGap);
\r
2474 LineTo(hdc, x1, y1 + squareSize + lineGap);
\r
2475 LineTo(hdc, x1, y1);
\r
2476 SelectObject(hdc, oldPen);
\r
2480 DrawHighlightsOnDC(HDC hdc)
\r
2483 for (i=0; i<2; i++) {
\r
2484 if (highlightInfo.sq[i].x >= 0 && highlightInfo.sq[i].y >= 0)
\r
2485 DrawHighlightOnDC(hdc, TRUE,
\r
2486 highlightInfo.sq[i].x, highlightInfo.sq[i].y,
\r
2489 for (i=0; i<2; i++) {
\r
2490 if (premoveHighlightInfo.sq[i].x >= 0 &&
\r
2491 premoveHighlightInfo.sq[i].y >= 0) {
\r
2492 DrawHighlightOnDC(hdc, TRUE,
\r
2493 premoveHighlightInfo.sq[i].x,
\r
2494 premoveHighlightInfo.sq[i].y,
\r
2500 /* Note: sqcolor is used only in monoMode */
\r
2501 /* Note that this code is largely duplicated in woptions.c,
\r
2502 function DrawSampleSquare, so that needs to be updated too */
\r
2504 DrawPieceOnDC(HDC hdc, ChessSquare piece, int color, int sqcolor, int x, int y, HDC tmphdc)
\r
2506 HBITMAP oldBitmap;
\r
2510 if (appData.blindfold) return;
\r
2512 /* [AS] Use font-based pieces if needed */
\r
2513 if( fontBitmapSquareSize >= 0 && squareSize > 32 ) {
\r
2514 /* Create piece bitmaps, or do nothing if piece set is up to date */
\r
2515 CreatePiecesFromFont();
\r
2517 if( fontBitmapSquareSize == squareSize ) {
\r
2518 int index = TranslatePieceToFontPiece(piece);
\r
2520 SelectObject( tmphdc, hPieceMask[ index ] );
\r
2524 squareSize, squareSize,
\r
2529 SelectObject( tmphdc, hPieceFace[ index ] );
\r
2533 squareSize, squareSize,
\r
2542 if (appData.monoMode) {
\r
2543 SelectObject(tmphdc, PieceBitmap(piece,
\r
2544 color == sqcolor ? OUTLINE_PIECE : SOLID_PIECE));
\r
2545 BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0,
\r
2546 sqcolor ? SRCCOPY : NOTSRCCOPY);
\r
2548 tmpSize = squareSize;
\r
2550 ((piece >= (int)WhiteNightrider && piece <= WhiteGrasshopper) ||
\r
2551 (piece >= (int)BlackNightrider && piece <= BlackGrasshopper)) ) {
\r
2552 /* [HGM] no bitmap available for promoted pieces in Crazyhouse */
\r
2553 /* Bitmaps of smaller size are substituted, but we have to align them */
\r
2554 x += (squareSize - minorSize)>>1;
\r
2555 y += squareSize - minorSize - 2;
\r
2556 tmpSize = minorSize;
\r
2558 if (color || appData.allWhite ) {
\r
2559 oldBitmap = SelectObject(tmphdc, PieceBitmap(piece, WHITE_PIECE));
\r
2561 oldBrush = SelectObject(hdc, whitePieceBrush);
\r
2562 else oldBrush = SelectObject(hdc, blackPieceBrush);
\r
2563 if(appData.upsideDown && color==flipView)
\r
2564 StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, 0x00B8074A);
\r
2566 BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
\r
2567 /* Use black for outline of white pieces */
\r
2568 SelectObject(tmphdc, PieceBitmap(piece, OUTLINE_PIECE));
\r
2569 if(appData.upsideDown && color==flipView)
\r
2570 StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, SRCAND);
\r
2572 BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, SRCAND);
\r
2574 /* Use square color for details of black pieces */
\r
2575 oldBitmap = SelectObject(tmphdc, PieceBitmap(piece, SOLID_PIECE));
\r
2576 oldBrush = SelectObject(hdc, blackPieceBrush);
\r
2577 if(appData.upsideDown && !flipView)
\r
2578 StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, 0x00B8074A);
\r
2580 BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
\r
2582 SelectObject(hdc, oldBrush);
\r
2583 SelectObject(tmphdc, oldBitmap);
\r
2587 /* [AS] Compute a drawing mode for a square, based on specified settings (see DrawTile) */
\r
2588 int GetBackTextureMode( int algo )
\r
2590 int result = BACK_TEXTURE_MODE_DISABLED;
\r
2594 case BACK_TEXTURE_MODE_PLAIN:
\r
2595 result = 1; /* Always use identity map */
\r
2597 case BACK_TEXTURE_MODE_FULL_RANDOM:
\r
2598 result = 1 + (myrandom() % 3); /* Pick a transformation at random */
\r
2606 [AS] Compute and save texture drawing info, otherwise we may not be able
\r
2607 to handle redraws cleanly (as random numbers would always be different).
\r
2609 VOID RebuildTextureSquareInfo()
\r
2619 ZeroMemory( &backTextureSquareInfo, sizeof(backTextureSquareInfo) );
\r
2621 if( liteBackTexture != NULL ) {
\r
2622 if( GetObject( liteBackTexture, sizeof(bi), &bi ) > 0 ) {
\r
2623 lite_w = bi.bmWidth;
\r
2624 lite_h = bi.bmHeight;
\r
2628 if( darkBackTexture != NULL ) {
\r
2629 if( GetObject( darkBackTexture, sizeof(bi), &bi ) > 0 ) {
\r
2630 dark_w = bi.bmWidth;
\r
2631 dark_h = bi.bmHeight;
\r
2635 for( row=0; row<BOARD_HEIGHT; row++ ) {
\r
2636 for( col=0; col<BOARD_WIDTH; col++ ) {
\r
2637 if( (col + row) & 1 ) {
\r
2639 if( lite_w >= squareSize && lite_h >= squareSize ) {
\r
2640 backTextureSquareInfo[row][col].x = col * (lite_w - squareSize) / (BOARD_WIDTH-1); /* [HGM] divide by size-1 in stead of size! */
\r
2641 backTextureSquareInfo[row][col].y = (BOARD_HEIGHT-1-row) * (lite_h - squareSize) / (BOARD_HEIGHT-1);
\r
2642 backTextureSquareInfo[row][col].mode = GetBackTextureMode(liteBackTextureMode);
\r
2647 if( dark_w >= squareSize && dark_h >= squareSize ) {
\r
2648 backTextureSquareInfo[row][col].x = col * (dark_w - squareSize) / (BOARD_WIDTH-1);
\r
2649 backTextureSquareInfo[row][col].y = (BOARD_HEIGHT-1-row) * (dark_h - squareSize) / (BOARD_HEIGHT-1);
\r
2650 backTextureSquareInfo[row][col].mode = GetBackTextureMode(darkBackTextureMode);
\r
2657 /* [AS] Arrow highlighting support */
\r
2659 static int A_WIDTH = 5; /* Width of arrow body */
\r
2661 #define A_HEIGHT_FACTOR 6 /* Length of arrow "point", relative to body width */
\r
2662 #define A_WIDTH_FACTOR 3 /* Width of arrow "point", relative to body width */
\r
2664 static double Sqr( double x )
\r
2669 static int Round( double x )
\r
2671 return (int) (x + 0.5);
\r
2674 /* Draw an arrow between two points using current settings */
\r
2675 VOID DrawArrowBetweenPoints( HDC hdc, int s_x, int s_y, int d_x, int d_y )
\r
2678 double dx, dy, j, k, x, y;
\r
2680 if( d_x == s_x ) {
\r
2681 int h = (d_y > s_y) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
\r
2683 arrow[0].x = s_x + A_WIDTH;
\r
2686 arrow[1].x = s_x + A_WIDTH;
\r
2687 arrow[1].y = d_y - h;
\r
2689 arrow[2].x = s_x + A_WIDTH*A_WIDTH_FACTOR;
\r
2690 arrow[2].y = d_y - h;
\r
2695 arrow[4].x = s_x - A_WIDTH*A_WIDTH_FACTOR;
\r
2696 arrow[4].y = d_y - h;
\r
2698 arrow[5].x = s_x - A_WIDTH;
\r
2699 arrow[5].y = d_y - h;
\r
2701 arrow[6].x = s_x - A_WIDTH;
\r
2704 else if( d_y == s_y ) {
\r
2705 int w = (d_x > s_x) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
\r
2708 arrow[0].y = s_y + A_WIDTH;
\r
2710 arrow[1].x = d_x - w;
\r
2711 arrow[1].y = s_y + A_WIDTH;
\r
2713 arrow[2].x = d_x - w;
\r
2714 arrow[2].y = s_y + A_WIDTH*A_WIDTH_FACTOR;
\r
2719 arrow[4].x = d_x - w;
\r
2720 arrow[4].y = s_y - A_WIDTH*A_WIDTH_FACTOR;
\r
2722 arrow[5].x = d_x - w;
\r
2723 arrow[5].y = s_y - A_WIDTH;
\r
2726 arrow[6].y = s_y - A_WIDTH;
\r
2729 /* [AS] Needed a lot of paper for this! :-) */
\r
2730 dy = (double) (d_y - s_y) / (double) (d_x - s_x);
\r
2731 dx = (double) (s_x - d_x) / (double) (s_y - d_y);
\r
2733 j = sqrt( Sqr(A_WIDTH) / (1.0 + Sqr(dx)) );
\r
2735 k = sqrt( Sqr(A_WIDTH*A_HEIGHT_FACTOR) / (1.0 + Sqr(dy)) );
\r
2740 arrow[0].x = Round(x - j);
\r
2741 arrow[0].y = Round(y + j*dx);
\r
2743 arrow[1].x = Round(x + j);
\r
2744 arrow[1].y = Round(y - j*dx);
\r
2747 x = (double) d_x - k;
\r
2748 y = (double) d_y - k*dy;
\r
2751 x = (double) d_x + k;
\r
2752 y = (double) d_y + k*dy;
\r
2755 arrow[2].x = Round(x + j);
\r
2756 arrow[2].y = Round(y - j*dx);
\r
2758 arrow[3].x = Round(x + j*A_WIDTH_FACTOR);
\r
2759 arrow[3].y = Round(y - j*A_WIDTH_FACTOR*dx);
\r
2764 arrow[5].x = Round(x - j*A_WIDTH_FACTOR);
\r
2765 arrow[5].y = Round(y + j*A_WIDTH_FACTOR*dx);
\r
2767 arrow[6].x = Round(x - j);
\r
2768 arrow[6].y = Round(y + j*dx);
\r
2771 Polygon( hdc, arrow, 7 );
\r
2774 /* [AS] Draw an arrow between two squares */
\r
2775 VOID DrawArrowBetweenSquares( HDC hdc, int s_col, int s_row, int d_col, int d_row )
\r
2777 int s_x, s_y, d_x, d_y;
\r
2784 if( s_col == d_col && s_row == d_row ) {
\r
2788 /* Get source and destination points */
\r
2789 SquareToPos( s_row, s_col, &s_x, &s_y);
\r
2790 SquareToPos( d_row, d_col, &d_x, &d_y);
\r
2793 d_y += squareSize / 4;
\r
2795 else if( d_y < s_y ) {
\r
2796 d_y += 3 * squareSize / 4;
\r
2799 d_y += squareSize / 2;
\r
2803 d_x += squareSize / 4;
\r
2805 else if( d_x < s_x ) {
\r
2806 d_x += 3 * squareSize / 4;
\r
2809 d_x += squareSize / 2;
\r
2812 s_x += squareSize / 2;
\r
2813 s_y += squareSize / 2;
\r
2815 /* Adjust width */
\r
2816 A_WIDTH = squareSize / 14;
\r
2819 stLB.lbStyle = BS_SOLID;
\r
2820 stLB.lbColor = appData.highlightArrowColor;
\r
2823 hpen = CreatePen( PS_SOLID, 2, RGB(0x00,0x00,0x00) );
\r
2824 holdpen = SelectObject( hdc, hpen );
\r
2825 hbrush = CreateBrushIndirect( &stLB );
\r
2826 holdbrush = SelectObject( hdc, hbrush );
\r
2828 DrawArrowBetweenPoints( hdc, s_x, s_y, d_x, d_y );
\r
2830 SelectObject( hdc, holdpen );
\r
2831 SelectObject( hdc, holdbrush );
\r
2832 DeleteObject( hpen );
\r
2833 DeleteObject( hbrush );
\r
2836 BOOL HasHighlightInfo()
\r
2838 BOOL result = FALSE;
\r
2840 if( highlightInfo.sq[0].x >= 0 && highlightInfo.sq[0].y >= 0 &&
\r
2841 highlightInfo.sq[1].x >= 0 && highlightInfo.sq[1].y >= 0 )
\r
2849 BOOL IsDrawArrowEnabled()
\r
2851 BOOL result = FALSE;
\r
2853 if( appData.highlightMoveWithArrow && squareSize >= 32 ) {
\r
2860 VOID DrawArrowHighlight( HDC hdc )
\r
2862 if( IsDrawArrowEnabled() && HasHighlightInfo() ) {
\r
2863 DrawArrowBetweenSquares( hdc,
\r
2864 highlightInfo.sq[0].x, highlightInfo.sq[0].y,
\r
2865 highlightInfo.sq[1].x, highlightInfo.sq[1].y );
\r
2869 HRGN GetArrowHighlightClipRegion( HDC hdc )
\r
2871 HRGN result = NULL;
\r
2873 if( HasHighlightInfo() ) {
\r
2874 int x1, y1, x2, y2;
\r
2875 int sx, sy, dx, dy;
\r
2877 SquareToPos(highlightInfo.sq[0].y, highlightInfo.sq[0].x, &x1, &y1 );
\r
2878 SquareToPos(highlightInfo.sq[1].y, highlightInfo.sq[1].x, &x2, &y2 );
\r
2880 sx = MIN( x1, x2 );
\r
2881 sy = MIN( y1, y2 );
\r
2882 dx = MAX( x1, x2 ) + squareSize;
\r
2883 dy = MAX( y1, y2 ) + squareSize;
\r
2885 result = CreateRectRgn( sx, sy, dx, dy );
\r
2892 Warning: this function modifies the behavior of several other functions.
\r
2894 Basically, Winboard is optimized to avoid drawing the whole board if not strictly
\r
2895 needed. Unfortunately, the decision whether or not to perform a full or partial
\r
2896 repaint is scattered all over the place, which is not good for features such as
\r
2897 "arrow highlighting" that require a full repaint of the board.
\r
2899 So, I've tried to patch the code where I thought it made sense (e.g. after or during
\r
2900 user interaction, when speed is not so important) but especially to avoid errors
\r
2901 in the displayed graphics.
\r
2903 In such patched places, I always try refer to this function so there is a single
\r
2904 place to maintain knowledge.
\r
2906 To restore the original behavior, just return FALSE unconditionally.
\r
2908 BOOL IsFullRepaintPreferrable()
\r
2910 BOOL result = FALSE;
\r
2912 if( (appData.highlightLastMove || appData.highlightDragging) && IsDrawArrowEnabled() ) {
\r
2913 /* Arrow may appear on the board */
\r
2921 This function is called by DrawPosition to know whether a full repaint must
\r
2924 Only DrawPosition may directly call this function, which makes use of
\r
2925 some state information. Other function should call DrawPosition specifying
\r
2926 the repaint flag, and can use IsFullRepaintPreferrable if needed.
\r
2928 BOOL DrawPositionNeedsFullRepaint()
\r
2930 BOOL result = FALSE;
\r
2933 Probably a slightly better policy would be to trigger a full repaint
\r
2934 when animInfo.piece changes state (i.e. empty -> non-empty and viceversa),
\r
2935 but animation is fast enough that it's difficult to notice.
\r
2937 if( animInfo.piece == EmptySquare ) {
\r
2938 if( (appData.highlightLastMove || appData.highlightDragging) && IsDrawArrowEnabled() /*&& HasHighlightInfo()*/ ) {
\r
2947 DrawBoardOnDC(HDC hdc, Board board, HDC tmphdc)
\r
2949 int row, column, x, y, square_color, piece_color;
\r
2950 ChessSquare piece;
\r
2952 HDC texture_hdc = NULL;
\r
2954 /* [AS] Initialize background textures if needed */
\r
2955 if( liteBackTexture != NULL || darkBackTexture != NULL ) {
\r
2956 static int backTextureBoardSize; /* [HGM] boardsize: also new texture if board format changed */
\r
2957 if( backTextureSquareSize != squareSize
\r
2958 || backTextureBoardSize != BOARD_WIDTH+BOARD_FILES*BOARD_HEIGHT) {
\r
2959 backTextureBoardSize = BOARD_WIDTH+BOARD_FILES*BOARD_HEIGHT;
\r
2960 backTextureSquareSize = squareSize;
\r
2961 RebuildTextureSquareInfo();
\r
2964 texture_hdc = CreateCompatibleDC( hdc );
\r
2967 for (row = 0; row < BOARD_HEIGHT; row++) {
\r
2968 for (column = 0; column < BOARD_WIDTH; column++) {
\r
2970 SquareToPos(row, column, &x, &y);
\r
2972 piece = board[row][column];
\r
2974 square_color = ((column + row) % 2) == 1;
\r
2975 if( gameInfo.variant == VariantXiangqi ) {
\r
2976 square_color = !InPalace(row, column);
\r
2977 if(BOARD_HEIGHT&1) { if(row==BOARD_HEIGHT/2) square_color ^= 1; }
\r
2978 else if(row < BOARD_HEIGHT/2) square_color ^= 1;
\r
2980 piece_color = (int) piece < (int) BlackPawn;
\r
2983 /* [HGM] holdings file: light square or black */
\r
2984 if(column == BOARD_LEFT-2) {
\r
2985 if( row > BOARD_HEIGHT - gameInfo.holdingsSize - 1 )
\r
2988 DisplayHoldingsCount(hdc, x, y, 0, 0); /* black out */
\r
2992 if(column == BOARD_RGHT + 1 ) {
\r
2993 if( row < gameInfo.holdingsSize )
\r
2996 DisplayHoldingsCount(hdc, x, y, 0, 0);
\r
3000 if(column == BOARD_LEFT-1 ) /* left align */
\r
3001 DisplayHoldingsCount(hdc, x, y, flipView, (int) board[row][column]);
\r
3002 else if( column == BOARD_RGHT) /* right align */
\r
3003 DisplayHoldingsCount(hdc, x, y, !flipView, (int) board[row][column]);
\r
3005 if (appData.monoMode) {
\r
3006 if (piece == EmptySquare) {
\r
3007 BitBlt(hdc, x, y, squareSize, squareSize, 0, 0, 0,
\r
3008 square_color ? WHITENESS : BLACKNESS);
\r
3010 DrawPieceOnDC(hdc, piece, piece_color, square_color, x, y, tmphdc);
\r
3013 else if( backTextureSquareInfo[row][column].mode > 0 ) {
\r
3014 /* [AS] Draw the square using a texture bitmap */
\r
3015 HBITMAP hbm = SelectObject( texture_hdc, square_color ? liteBackTexture : darkBackTexture );
\r
3016 int r = row, c = column; // [HGM] do not flip board in flipView
\r
3017 if(flipView) { r = BOARD_HEIGHT-1 - r; c = BOARD_WIDTH-1 - c; }
\r
3020 squareSize, squareSize,
\r
3023 backTextureSquareInfo[r][c].mode,
\r
3024 backTextureSquareInfo[r][c].x,
\r
3025 backTextureSquareInfo[r][c].y );
\r
3027 SelectObject( texture_hdc, hbm );
\r
3029 if (piece != EmptySquare) {
\r
3030 DrawPieceOnDC(hdc, piece, piece_color, -1, x, y, tmphdc);
\r
3034 HBRUSH brush = square_color ? lightSquareBrush : darkSquareBrush;
\r
3036 oldBrush = SelectObject(hdc, brush );
\r
3037 BitBlt(hdc, x, y, squareSize, squareSize, 0, 0, 0, PATCOPY);
\r
3038 SelectObject(hdc, oldBrush);
\r
3039 if (piece != EmptySquare)
\r
3040 DrawPieceOnDC(hdc, piece, piece_color, -1, x, y, tmphdc);
\r
3045 if( texture_hdc != NULL ) {
\r
3046 DeleteDC( texture_hdc );
\r
3050 int saveDiagFlag = 0; FILE *diagFile; // [HGM] diag
\r
3051 void fputDW(FILE *f, int x)
\r
3053 fputc(x & 255, f);
\r
3054 fputc(x>>8 & 255, f);
\r
3055 fputc(x>>16 & 255, f);
\r
3056 fputc(x>>24 & 255, f);
\r
3059 #define MAX_CLIPS 200 /* more than enough */
\r
3062 DrawLogoOnDC(HDC hdc, RECT logoRect, HBITMAP logo)
\r
3064 // HBITMAP bufferBitmap;
\r
3069 int w = 100, h = 50;
\r
3071 if(logo == NULL) return;
\r
3072 // GetClientRect(hwndMain, &Rect);
\r
3073 // bufferBitmap = CreateCompatibleBitmap(hdc, Rect.right-Rect.left+1,
\r
3074 // Rect.bottom-Rect.top+1);
\r
3075 tmphdc = CreateCompatibleDC(hdc);
\r
3076 hbm = SelectObject(tmphdc, logo);
\r
3077 if( GetObject( logo, sizeof(bi), &bi ) > 0 ) {
\r
3081 StretchBlt(hdc, logoRect.left, logoRect.top, logoRect.right - logoRect.left,
\r
3082 logoRect.bottom - logoRect.top, tmphdc, 0, 0, w, h, SRCCOPY);
\r
3083 SelectObject(tmphdc, hbm);
\r
3087 static HDC hdcSeek;
\r
3089 // [HGM] seekgraph
\r
3090 void DrawSeekAxis( int x, int y, int xTo, int yTo )
\r
3093 HPEN hp = SelectObject( hdcSeek, gridPen );
\r
3094 MoveToEx( hdcSeek, boardRect.left+x, boardRect.top+y, &stPt );
\r
3095 LineTo( hdcSeek, boardRect.left+xTo, boardRect.top+yTo );
\r
3096 SelectObject( hdcSeek, hp );
\r
3099 // front-end wrapper for drawing functions to do rectangles
\r
3100 void DrawSeekBackground( int left, int top, int right, int bottom )
\r
3105 if (hdcSeek == NULL) {
\r
3106 hdcSeek = GetDC(hwndMain);
\r
3107 if (!appData.monoMode) {
\r
3108 SelectPalette(hdcSeek, hPal, FALSE);
\r
3109 RealizePalette(hdcSeek);
\r
3112 hp = SelectObject( hdcSeek, gridPen );
\r
3113 rc.top = boardRect.top+top; rc.left = boardRect.left+left;
\r
3114 rc.bottom = boardRect.top+bottom; rc.right = boardRect.left+right;
\r
3115 FillRect( hdcSeek, &rc, lightSquareBrush );
\r
3116 SelectObject( hdcSeek, hp );
\r
3119 // front-end wrapper for putting text in graph
\r
3120 void DrawSeekText(char *buf, int x, int y)
\r
3123 SetBkMode( hdcSeek, TRANSPARENT );
\r
3124 GetTextExtentPoint32( hdcSeek, buf, strlen(buf), &stSize );
\r
3125 TextOut( hdcSeek, boardRect.left+x-3, boardRect.top+y-stSize.cy/2, buf, strlen(buf) );
\r
3128 void DrawSeekDot(int x, int y, int color)
\r
3130 int square = color & 0x80;
\r
3132 HBRUSH oldBrush = SelectObject(hdcSeek,
\r
3133 color == 0 ? markerBrush : color == 1 ? darkSquareBrush : explodeBrush);
\r
3135 Rectangle(hdcSeek, boardRect.left+x - squareSize/9, boardRect.top+y - squareSize/9,
\r
3136 boardRect.left+x + squareSize/9, boardRect.top+y + squareSize/9);
\r
3138 Ellipse(hdcSeek, boardRect.left+x - squareSize/8, boardRect.top+y - squareSize/8,
\r
3139 boardRect.left+x + squareSize/8, boardRect.top+y + squareSize/8);
\r
3140 SelectObject(hdcSeek, oldBrush);
\r
3144 HDCDrawPosition(HDC hdc, BOOLEAN repaint, Board board)
\r
3146 static Board lastReq, lastDrawn;
\r
3147 static HighlightInfo lastDrawnHighlight, lastDrawnPremove;
\r
3148 static int lastDrawnFlipView = 0;
\r
3149 static int lastReqValid = 0, lastDrawnValid = 0;
\r
3150 int releaseDC, x, y, x2, y2, row, column, num_clips = 0, i;
\r
3153 HBITMAP bufferBitmap;
\r
3154 HBITMAP oldBitmap;
\r
3156 HRGN clips[MAX_CLIPS];
\r
3157 ChessSquare dragged_piece = EmptySquare;
\r
3159 /* I'm undecided on this - this function figures out whether a full
\r
3160 * repaint is necessary on its own, so there's no real reason to have the
\r
3161 * caller tell it that. I think this can safely be set to FALSE - but
\r
3162 * if we trust the callers not to request full repaints unnessesarily, then
\r
3163 * we could skip some clipping work. In other words, only request a full
\r
3164 * redraw when the majority of pieces have changed positions (ie. flip,
\r
3165 * gamestart and similar) --Hawk
\r
3167 Boolean fullrepaint = repaint;
\r
3169 if(DrawSeekGraph()) return; // [HG} seekgraph: suppress printing board if seek graph up
\r
3171 if( DrawPositionNeedsFullRepaint() ) {
\r
3172 fullrepaint = TRUE;
\r
3175 if (board == NULL) {
\r
3176 if (!lastReqValid) {
\r
3181 CopyBoard(lastReq, board);
\r
3185 if (doingSizing) {
\r
3189 if (IsIconic(hwndMain)) {
\r
3193 if (hdc == NULL) {
\r
3194 hdc = GetDC(hwndMain);
\r
3195 if (!appData.monoMode) {
\r
3196 SelectPalette(hdc, hPal, FALSE);
\r
3197 RealizePalette(hdc);
\r
3201 releaseDC = FALSE;
\r
3204 /* Create some work-DCs */
\r
3205 hdcmem = CreateCompatibleDC(hdc);
\r
3206 tmphdc = CreateCompatibleDC(hdc);
\r
3208 /* If dragging is in progress, we temporarely remove the piece */
\r
3209 /* [HGM] or temporarily decrease count if stacked */
\r
3210 /* !! Moved to before board compare !! */
\r
3211 if (dragInfo.from.x >= 0 && dragInfo.pos.x >= 0) {
\r
3212 dragged_piece = board[dragInfo.from.y][dragInfo.from.x];
\r
3213 if(dragInfo.from.x == BOARD_LEFT-2 ) {
\r
3214 if(--board[dragInfo.from.y][dragInfo.from.x+1] == 0 )
\r
3215 board[dragInfo.from.y][dragInfo.from.x] = EmptySquare;
\r
3217 if(dragInfo.from.x == BOARD_RGHT+1) {
\r
3218 if(--board[dragInfo.from.y][dragInfo.from.x-1] == 0 )
\r
3219 board[dragInfo.from.y][dragInfo.from.x] = EmptySquare;
\r
3221 board[dragInfo.from.y][dragInfo.from.x] = EmptySquare;
\r
3224 /* Figure out which squares need updating by comparing the
\r
3225 * newest board with the last drawn board and checking if
\r
3226 * flipping has changed.
\r
3228 if (!fullrepaint && lastDrawnValid && lastDrawnFlipView == flipView) {
\r
3229 for (row = 0; row < BOARD_HEIGHT; row++) { /* [HGM] true size, not 8 */
\r
3230 for (column = 0; column < BOARD_WIDTH; column++) {
\r
3231 if (lastDrawn[row][column] != board[row][column]) {
\r
3232 SquareToPos(row, column, &x, &y);
\r
3233 clips[num_clips++] =
\r
3234 CreateRectRgn(x, y, x + squareSize, y + squareSize);
\r
3238 for (i=0; i<2; i++) {
\r
3239 if (lastDrawnHighlight.sq[i].x != highlightInfo.sq[i].x ||
\r
3240 lastDrawnHighlight.sq[i].y != highlightInfo.sq[i].y) {
\r
3241 if (lastDrawnHighlight.sq[i].x >= 0 &&
\r
3242 lastDrawnHighlight.sq[i].y >= 0) {
\r
3243 SquareToPos(lastDrawnHighlight.sq[i].y,
\r
3244 lastDrawnHighlight.sq[i].x, &x, &y);
\r
3245 clips[num_clips++] =
\r
3246 CreateRectRgn(x - lineGap, y - lineGap,
\r
3247 x + squareSize + lineGap, y + squareSize + lineGap);
\r
3249 if (highlightInfo.sq[i].x >= 0 && highlightInfo.sq[i].y >= 0) {
\r
3250 SquareToPos(highlightInfo.sq[i].y, highlightInfo.sq[i].x, &x, &y);
\r
3251 clips[num_clips++] =
\r
3252 CreateRectRgn(x - lineGap, y - lineGap,
\r
3253 x + squareSize + lineGap, y + squareSize + lineGap);
\r
3257 for (i=0; i<2; i++) {
\r
3258 if (lastDrawnPremove.sq[i].x != premoveHighlightInfo.sq[i].x ||
\r
3259 lastDrawnPremove.sq[i].y != premoveHighlightInfo.sq[i].y) {
\r
3260 if (lastDrawnPremove.sq[i].x >= 0 &&
\r
3261 lastDrawnPremove.sq[i].y >= 0) {
\r
3262 SquareToPos(lastDrawnPremove.sq[i].y,
\r
3263 lastDrawnPremove.sq[i].x, &x, &y);
\r
3264 clips[num_clips++] =
\r
3265 CreateRectRgn(x - lineGap, y - lineGap,
\r
3266 x + squareSize + lineGap, y + squareSize + lineGap);
\r
3268 if (premoveHighlightInfo.sq[i].x >= 0 &&
\r
3269 premoveHighlightInfo.sq[i].y >= 0) {
\r
3270 SquareToPos(premoveHighlightInfo.sq[i].y,
\r
3271 premoveHighlightInfo.sq[i].x, &x, &y);
\r
3272 clips[num_clips++] =
\r
3273 CreateRectRgn(x - lineGap, y - lineGap,
\r
3274 x + squareSize + lineGap, y + squareSize + lineGap);
\r
3279 fullrepaint = TRUE;
\r
3282 /* Create a buffer bitmap - this is the actual bitmap
\r
3283 * being written to. When all the work is done, we can
\r
3284 * copy it to the real DC (the screen). This avoids
\r
3285 * the problems with flickering.
\r
3287 GetClientRect(hwndMain, &Rect);
\r
3288 bufferBitmap = CreateCompatibleBitmap(hdc, Rect.right-Rect.left+1,
\r
3289 Rect.bottom-Rect.top+1);
\r
3290 oldBitmap = SelectObject(hdcmem, bufferBitmap);
\r
3291 if (!appData.monoMode) {
\r
3292 SelectPalette(hdcmem, hPal, FALSE);
\r
3295 /* Create clips for dragging */
\r
3296 if (!fullrepaint) {
\r
3297 if (dragInfo.from.x >= 0) {
\r
3298 SquareToPos(dragInfo.from.y, dragInfo.from.x, &x, &y);
\r
3299 clips[num_clips++] = CreateRectRgn(x, y, x+squareSize, y+squareSize);
\r
3301 if (dragInfo.start.x >= 0) {
\r
3302 SquareToPos(dragInfo.start.y, dragInfo.start.x, &x, &y);
\r
3303 clips[num_clips++] = CreateRectRgn(x, y, x+squareSize, y+squareSize);
\r
3305 if (dragInfo.pos.x >= 0) {
\r
3306 x = dragInfo.pos.x - squareSize / 2;
\r
3307 y = dragInfo.pos.y - squareSize / 2;
\r
3308 clips[num_clips++] = CreateRectRgn(x, y, x+squareSize, y+squareSize);
\r
3310 if (dragInfo.lastpos.x >= 0) {
\r
3311 x = dragInfo.lastpos.x - squareSize / 2;
\r
3312 y = dragInfo.lastpos.y - squareSize / 2;
\r
3313 clips[num_clips++] = CreateRectRgn(x, y, x+squareSize, y+squareSize);
\r
3317 /* Are we animating a move?
\r
3319 * - remove the piece from the board (temporarely)
\r
3320 * - calculate the clipping region
\r
3322 if (!fullrepaint) {
\r
3323 if (animInfo.piece != EmptySquare) {
\r
3324 board[animInfo.from.y][animInfo.from.x] = EmptySquare;
\r
3325 x = boardRect.left + animInfo.lastpos.x;
\r
3326 y = boardRect.top + animInfo.lastpos.y;
\r
3327 x2 = boardRect.left + animInfo.pos.x;
\r
3328 y2 = boardRect.top + animInfo.pos.y;
\r
3329 clips[num_clips++] = CreateRectRgn(MIN(x,x2), MIN(y,y2), MAX(x,x2)+squareSize, MAX(y,y2)+squareSize);
\r
3330 /* Slight kludge. The real problem is that after AnimateMove is
\r
3331 done, the position on the screen does not match lastDrawn.
\r
3332 This currently causes trouble only on e.p. captures in
\r
3333 atomic, where the piece moves to an empty square and then
\r
3334 explodes. The old and new positions both had an empty square
\r
3335 at the destination, but animation has drawn a piece there and
\r
3336 we have to remember to erase it. [HGM] moved until after setting lastDrawn */
\r
3337 lastDrawn[animInfo.to.y][animInfo.to.x] = animInfo.piece;
\r
3341 /* No clips? Make sure we have fullrepaint set to TRUE */
\r
3342 if (num_clips == 0)
\r
3343 fullrepaint = TRUE;
\r
3345 /* Set clipping on the memory DC */
\r
3346 if (!fullrepaint) {
\r
3347 SelectClipRgn(hdcmem, clips[0]);
\r
3348 for (x = 1; x < num_clips; x++) {
\r
3349 if (ExtSelectClipRgn(hdcmem, clips[x], RGN_OR) == ERROR)
\r
3350 abort(); // this should never ever happen!
\r
3354 /* Do all the drawing to the memory DC */
\r
3355 if(explodeInfo.radius) { // [HGM] atomic
\r
3357 int x, y, r=(explodeInfo.radius * squareSize)/100;
\r
3358 board[explodeInfo.fromY][explodeInfo.fromX] = EmptySquare; // suppress display of capturer
\r
3359 SquareToPos(explodeInfo.toY, explodeInfo.toX, &x, &y);
\r
3360 x += squareSize/2;
\r
3361 y += squareSize/2;
\r
3362 if(!fullrepaint) {
\r
3363 clips[num_clips] = CreateRectRgn(x-r, y-r, x+r, y+r);
\r
3364 ExtSelectClipRgn(hdcmem, clips[num_clips++], RGN_OR);
\r
3366 DrawGridOnDC(hdcmem);
\r
3367 DrawHighlightsOnDC(hdcmem);
\r
3368 DrawBoardOnDC(hdcmem, board, tmphdc);
\r
3369 oldBrush = SelectObject(hdcmem, explodeBrush);
\r
3370 Ellipse(hdcmem, x-r, y-r, x+r, y+r);
\r
3371 SelectObject(hdcmem, oldBrush);
\r
3373 DrawGridOnDC(hdcmem);
\r
3374 DrawHighlightsOnDC(hdcmem);
\r
3375 DrawBoardOnDC(hdcmem, board, tmphdc);
\r
3377 for (row = 0; row < BOARD_HEIGHT; row++) {
\r
3378 for (column = 0; column < BOARD_WIDTH; column++) {
\r
3379 if (marker[row][column]) { // marker changes only occur with full repaint!
\r
3380 HBRUSH oldBrush = SelectObject(hdcmem,
\r
3381 marker[row][column] == 2 ? markerBrush : explodeBrush);
\r
3382 SquareToPos(row, column, &x, &y);
\r
3383 Ellipse(hdcmem, x + squareSize/4, y + squareSize/4,
\r
3384 x + 3*squareSize/4, y + 3*squareSize/4);
\r
3385 SelectObject(hdcmem, oldBrush);
\r
3390 HBITMAP whiteLogo = (HBITMAP) first.programLogo, blackLogo = (HBITMAP) second.programLogo;
\r
3391 if(appData.autoLogo) {
\r
3393 switch(gameMode) { // pick logos based on game mode
\r
3394 case IcsObserving:
\r
3395 whiteLogo = second.programLogo; // ICS logo
\r
3396 blackLogo = second.programLogo;
\r
3399 case IcsPlayingWhite:
\r
3400 if(!appData.zippyPlay) whiteLogo = userLogo;
\r
3401 blackLogo = second.programLogo; // ICS logo
\r
3403 case IcsPlayingBlack:
\r
3404 whiteLogo = second.programLogo; // ICS logo
\r
3405 blackLogo = appData.zippyPlay ? first.programLogo : userLogo;
\r
3407 case TwoMachinesPlay:
\r
3408 if(first.twoMachinesColor[0] == 'b') {
\r
3409 whiteLogo = second.programLogo;
\r
3410 blackLogo = first.programLogo;
\r
3413 case MachinePlaysWhite:
\r
3414 blackLogo = userLogo;
\r
3416 case MachinePlaysBlack:
\r
3417 whiteLogo = userLogo;
\r
3418 blackLogo = first.programLogo;
\r
3421 DrawLogoOnDC(hdc, leftLogoRect, flipClock ? blackLogo : whiteLogo);
\r
3422 DrawLogoOnDC(hdc, rightLogoRect, flipClock ? whiteLogo : blackLogo);
\r
3425 if( appData.highlightMoveWithArrow ) {
\r
3426 DrawArrowHighlight(hdcmem);
\r
3429 DrawCoordsOnDC(hdcmem);
\r
3431 CopyBoard(lastDrawn, board); /* [HGM] Moved to here from end of routine, */
\r
3432 /* to make sure lastDrawn contains what is actually drawn */
\r
3434 /* Put the dragged piece back into place and draw it (out of place!) */
\r
3435 if (dragged_piece != EmptySquare) {
\r
3436 /* [HGM] or restack */
\r
3437 if(dragInfo.from.x == BOARD_LEFT-2 )
\r
3438 board[dragInfo.from.y][dragInfo.from.x+1]++;
\r
3440 if(dragInfo.from.x == BOARD_RGHT+1 )
\r
3441 board[dragInfo.from.y][dragInfo.from.x-1]++;
\r
3442 board[dragInfo.from.y][dragInfo.from.x] = dragged_piece;
\r
3443 x = dragInfo.pos.x - squareSize / 2;
\r
3444 y = dragInfo.pos.y - squareSize / 2;
\r
3445 DrawPieceOnDC(hdcmem, dragged_piece,
\r
3446 ((int) dragged_piece < (int) BlackPawn),
\r
3447 (dragInfo.from.y + dragInfo.from.x) % 2, x, y, tmphdc);
\r
3450 /* Put the animated piece back into place and draw it */
\r
3451 if (animInfo.piece != EmptySquare) {
\r
3452 board[animInfo.from.y][animInfo.from.x] = animInfo.piece;
\r
3453 x = boardRect.left + animInfo.pos.x;
\r
3454 y = boardRect.top + animInfo.pos.y;
\r
3455 DrawPieceOnDC(hdcmem, animInfo.piece,
\r
3456 ((int) animInfo.piece < (int) BlackPawn),
\r
3457 (animInfo.from.y + animInfo.from.x) % 2, x, y, tmphdc);
\r
3460 /* Release the bufferBitmap by selecting in the old bitmap
\r
3461 * and delete the memory DC
\r
3463 SelectObject(hdcmem, oldBitmap);
\r
3466 /* Set clipping on the target DC */
\r
3467 if (!fullrepaint) {
\r
3468 SelectClipRgn(hdc, clips[0]);
\r
3469 for (x = 1; x < num_clips; x++) {
\r
3470 if (ExtSelectClipRgn(hdc, clips[x], RGN_OR) == ERROR)
\r
3471 abort(); // this should never ever happen!
\r
3475 /* Copy the new bitmap onto the screen in one go.
\r
3476 * This way we avoid any flickering
\r
3478 oldBitmap = SelectObject(tmphdc, bufferBitmap);
\r
3479 BitBlt(hdc, boardRect.left, boardRect.top,
\r
3480 boardRect.right - boardRect.left,
\r
3481 boardRect.bottom - boardRect.top,
\r
3482 tmphdc, boardRect.left, boardRect.top, SRCCOPY);
\r
3483 if(saveDiagFlag) {
\r
3484 BITMAP b; int i, j=0, m, w, wb, fac=0; char pData[1000000];
\r
3485 BITMAPINFOHEADER bih; int color[16], nrColors=0;
\r
3487 GetObject(bufferBitmap, sizeof(b), &b);
\r
3488 if(b.bmWidthBytes*b.bmHeight <= 990000) {
\r
3489 bih.biSize = sizeof(BITMAPINFOHEADER);
\r
3490 bih.biWidth = b.bmWidth;
\r
3491 bih.biHeight = b.bmHeight;
\r
3493 bih.biBitCount = b.bmBitsPixel;
\r
3494 bih.biCompression = 0;
\r
3495 bih.biSizeImage = b.bmWidthBytes*b.bmHeight;
\r
3496 bih.biXPelsPerMeter = 0;
\r
3497 bih.biYPelsPerMeter = 0;
\r
3498 bih.biClrUsed = 0;
\r
3499 bih.biClrImportant = 0;
\r
3500 // fprintf(diagFile, "t=%d\nw=%d\nh=%d\nB=%d\nP=%d\nX=%d\n",
\r
3501 // b.bmType, b.bmWidth, b.bmHeight, b.bmWidthBytes, b.bmPlanes, b.bmBitsPixel);
\r
3502 GetDIBits(tmphdc,bufferBitmap,0,b.bmHeight,pData,(BITMAPINFO*)&bih,DIB_RGB_COLORS);
\r
3503 // fprintf(diagFile, "%8x\n", (int) pData);
\r
3505 wb = b.bmWidthBytes;
\r
3507 for(i=0; i<wb*(b.bmHeight - boardRect.top + OUTER_MARGIN)>>2; i++) {
\r
3508 int k = ((int*) pData)[i];
\r
3509 for(j=0; j<nrColors; j++) if(color[j] == k) break;
\r
3510 if(j >= 16) break;
\r
3512 if(j >= nrColors) nrColors = j+1;
\r
3514 if(j<16) { // 16 colors is enough. Compress to 4 bits per pixel
\r
3516 for(i=0; i<b.bmHeight - boardRect.top + OUTER_MARGIN; i++) {
\r
3517 for(w=0; w<(wb>>2); w+=2) {
\r
3518 int k = ((int*) pData)[(wb*i>>2) + w];
\r
3519 for(j=0; j<nrColors; j++) if(color[j] == k) break;
\r
3520 k = ((int*) pData)[(wb*i>>2) + w + 1];
\r
3521 for(m=0; m<nrColors; m++) if(color[m] == k) break;
\r
3522 pData[p++] = m | j<<4;
\r
3524 while(p&3) pData[p++] = 0;
\r
3527 wb = ((wb+31)>>5)<<2;
\r
3529 // write BITMAPFILEHEADER
\r
3530 fprintf(diagFile, "BM");
\r
3531 fputDW(diagFile, wb*(b.bmHeight - boardRect.top + OUTER_MARGIN)+0x36 + (fac?64:0));
\r
3532 fputDW(diagFile, 0);
\r
3533 fputDW(diagFile, 0x36 + (fac?64:0));
\r
3534 // write BITMAPINFOHEADER
\r
3535 fputDW(diagFile, 40);
\r
3536 fputDW(diagFile, b.bmWidth);
\r
3537 fputDW(diagFile, b.bmHeight - boardRect.top + OUTER_MARGIN);
\r
3538 if(fac) fputDW(diagFile, 0x040001); // planes and bits/pixel
\r
3539 else fputDW(diagFile, 0x200001); // planes and bits/pixel
\r
3540 fputDW(diagFile, 0);
\r
3541 fputDW(diagFile, 0);
\r
3542 fputDW(diagFile, 0);
\r
3543 fputDW(diagFile, 0);
\r
3544 fputDW(diagFile, 0);
\r
3545 fputDW(diagFile, 0);
\r
3546 // write color table
\r
3548 for(i=0; i<16; i++) fputDW(diagFile, color[i]);
\r
3549 // write bitmap data
\r
3550 for(i=0; i<wb*(b.bmHeight - boardRect.top + OUTER_MARGIN); i++)
\r
3551 fputc(pData[i], diagFile);
\r
3555 SelectObject(tmphdc, oldBitmap);
\r
3557 /* Massive cleanup */
\r
3558 for (x = 0; x < num_clips; x++)
\r
3559 DeleteObject(clips[x]);
\r
3562 DeleteObject(bufferBitmap);
\r
3565 ReleaseDC(hwndMain, hdc);
\r
3567 if (lastDrawnFlipView != flipView) {
\r
3569 CheckMenuItem(GetMenu(hwndMain),IDM_FlipView, MF_BYCOMMAND|MF_CHECKED);
\r
3571 CheckMenuItem(GetMenu(hwndMain),IDM_FlipView, MF_BYCOMMAND|MF_UNCHECKED);
\r
3574 /* CopyBoard(lastDrawn, board);*/
\r
3575 lastDrawnHighlight = highlightInfo;
\r
3576 lastDrawnPremove = premoveHighlightInfo;
\r
3577 lastDrawnFlipView = flipView;
\r
3578 lastDrawnValid = 1;
\r
3581 /* [HGM] diag: Save the current board display to the given open file and close the file */
\r
3586 saveDiagFlag = 1; diagFile = f;
\r
3587 HDCDrawPosition(NULL, TRUE, NULL);
\r
3591 // if(f != NULL) fprintf(f, "Sorry, but this feature is still in preparation\n");
\r
3598 /*---------------------------------------------------------------------------*\
\r
3599 | CLIENT PAINT PROCEDURE
\r
3600 | This is the main event-handler for the WM_PAINT message.
\r
3602 \*---------------------------------------------------------------------------*/
\r
3604 PaintProc(HWND hwnd)
\r
3610 if((hdc = BeginPaint(hwnd, &ps))) {
\r
3611 if (IsIconic(hwnd)) {
\r
3612 DrawIcon(hdc, 2, 2, iconCurrent);
\r
3614 if (!appData.monoMode) {
\r
3615 SelectPalette(hdc, hPal, FALSE);
\r
3616 RealizePalette(hdc);
\r
3618 HDCDrawPosition(hdc, 1, NULL);
\r
3620 SelectObject(hdc, font[boardSize][MESSAGE_FONT]->hf);
\r
3621 ExtTextOut(hdc, messageRect.left, messageRect.top,
\r
3622 ETO_CLIPPED|ETO_OPAQUE,
\r
3623 &messageRect, messageText, strlen(messageText), NULL);
\r
3624 SelectObject(hdc, oldFont);
\r
3625 DisplayBothClocks();
\r
3627 EndPaint(hwnd,&ps);
\r
3635 * If the user selects on a border boundary, return -1; if off the board,
\r
3636 * return -2. Otherwise map the event coordinate to the square.
\r
3637 * The offset boardRect.left or boardRect.top must already have been
\r
3638 * subtracted from x.
\r
3640 int EventToSquare(x, limit)
\r
3648 if ((x % (squareSize + lineGap)) >= squareSize)
\r
3650 x /= (squareSize + lineGap);
\r
3662 DropEnable dropEnables[] = {
\r
3663 { 'P', DP_Pawn, "Pawn" },
\r
3664 { 'N', DP_Knight, "Knight" },
\r
3665 { 'B', DP_Bishop, "Bishop" },
\r
3666 { 'R', DP_Rook, "Rook" },
\r
3667 { 'Q', DP_Queen, "Queen" },
\r
3671 SetupDropMenu(HMENU hmenu)
\r
3673 int i, count, enable;
\r
3675 extern char white_holding[], black_holding[];
\r
3676 char item[MSG_SIZ];
\r
3678 for (i=0; i<sizeof(dropEnables)/sizeof(DropEnable); i++) {
\r
3679 p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,
\r
3680 dropEnables[i].piece);
\r
3682 while (p && *p++ == dropEnables[i].piece) count++;
\r
3683 sprintf(item, "%s %d", dropEnables[i].name, count);
\r
3684 enable = count > 0 || !appData.testLegality
\r
3685 /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse
\r
3686 && !appData.icsActive);
\r
3687 ModifyMenu(hmenu, dropEnables[i].command,
\r
3688 MF_BYCOMMAND | (enable ? MF_ENABLED : MF_GRAYED) | MF_STRING,
\r
3689 dropEnables[i].command, item);
\r
3693 void DragPieceBegin(int x, int y)
\r
3695 dragInfo.lastpos.x = boardRect.left + x;
\r
3696 dragInfo.lastpos.y = boardRect.top + y;
\r
3697 dragInfo.from.x = fromX;
\r
3698 dragInfo.from.y = fromY;
\r
3699 dragInfo.start = dragInfo.from;
\r
3700 SetCapture(hwndMain);
\r
3703 void DragPieceEnd(int x, int y)
\r
3706 dragInfo.start.x = dragInfo.start.y = -1;
\r
3707 dragInfo.from = dragInfo.start;
\r
3708 dragInfo.pos = dragInfo.lastpos = dragInfo.start;
\r
3711 /* Event handler for mouse messages */
\r
3713 MouseEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
3717 static int recursive = 0;
\r
3719 BOOLEAN forceFullRepaint = IsFullRepaintPreferrable(); /* [AS] */
\r
3722 if (message == WM_MBUTTONUP) {
\r
3723 /* Hideous kludge to fool TrackPopupMenu into paying attention
\r
3724 to the middle button: we simulate pressing the left button too!
\r
3726 PostMessage(hwnd, WM_LBUTTONDOWN, wParam, lParam);
\r
3727 PostMessage(hwnd, WM_LBUTTONUP, wParam, lParam);
\r
3733 pt.x = LOWORD(lParam);
\r
3734 pt.y = HIWORD(lParam);
\r
3735 x = EventToSquare(pt.x - boardRect.left, BOARD_WIDTH);
\r
3736 y = EventToSquare(pt.y - boardRect.top, BOARD_HEIGHT);
\r
3737 if (!flipView && y >= 0) {
\r
3738 y = BOARD_HEIGHT - 1 - y;
\r
3740 if (flipView && x >= 0) {
\r
3741 x = BOARD_WIDTH - 1 - x;
\r
3744 switch (message) {
\r
3745 case WM_LBUTTONDOWN:
\r
3746 if (PtInRect((LPRECT) &whiteRect, pt)) {
\r
3747 if (gameMode == EditPosition) {
\r
3748 SetWhiteToPlayEvent();
\r
3749 } else if (gameMode == IcsPlayingBlack ||
\r
3750 gameMode == MachinePlaysWhite) {
\r
3752 } else if (gameMode == EditGame) {
\r
3753 AdjustClock(flipClock, -1);
\r
3755 } else if (PtInRect((LPRECT) &blackRect, pt)) {
\r
3756 if (gameMode == EditPosition) {
\r
3757 SetBlackToPlayEvent();
\r
3758 } else if (gameMode == IcsPlayingWhite ||
\r
3759 gameMode == MachinePlaysBlack) {
\r
3761 } else if (gameMode == EditGame) {
\r
3762 AdjustClock(!flipClock, -1);
\r
3765 dragInfo.start.x = dragInfo.start.y = -1;
\r
3766 dragInfo.from = dragInfo.start;
\r
3767 if(fromX == -1 && frozen) { // not sure where this is for
\r
3768 fromX = fromY = -1;
\r
3769 DrawPosition(forceFullRepaint || FALSE, NULL); /* [AS] */
\r
3772 LeftClick(Press, pt.x - boardRect.left, pt.y - boardRect.top);
\r
3773 DrawPosition(TRUE, NULL);
\r
3776 case WM_LBUTTONUP:
\r
3777 LeftClick(Release, pt.x - boardRect.left, pt.y - boardRect.top);
\r
3778 DrawPosition(TRUE, NULL);
\r
3781 case WM_MOUSEMOVE:
\r
3782 if(SeekGraphClick(Press, pt.x - boardRect.left, pt.y - boardRect.top, 1)) break;
\r
3783 MovePV(pt.x - boardRect.left, pt.y - boardRect.top, boardRect.bottom - boardRect.top);
\r
3784 if ((appData.animateDragging || appData.highlightDragging)
\r
3785 && (wParam & MK_LBUTTON)
\r
3786 && dragInfo.from.x >= 0)
\r
3788 BOOL full_repaint = FALSE;
\r
3790 if (appData.animateDragging) {
\r
3791 dragInfo.pos = pt;
\r
3793 if (appData.highlightDragging) {
\r
3794 SetHighlights(fromX, fromY, x, y);
\r
3795 if( IsDrawArrowEnabled() && (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT) ) {
\r
3796 full_repaint = TRUE;
\r
3800 DrawPosition( full_repaint, NULL);
\r
3802 dragInfo.lastpos = dragInfo.pos;
\r
3806 case WM_MOUSEWHEEL: // [DM]
\r
3807 { static int lastDir = 0; // [HGM] build in some hysteresis to avoid spurious events
\r
3808 /* Mouse Wheel is being rolled forward
\r
3809 * Play moves forward
\r
3811 if((short)HIWORD(wParam) > 0 && currentMove < forwardMostMove)
\r
3812 { if(lastDir == 1) ForwardEvent(); else lastDir = 1; } // [HGM] suppress first event in direction
\r
3813 /* Mouse Wheel is being rolled backward
\r
3814 * Play moves backward
\r
3816 if((short)HIWORD(wParam) < 0 && currentMove > backwardMostMove)
\r
3817 { if(lastDir == -1) BackwardEvent(); else lastDir = -1; }
\r
3821 case WM_MBUTTONUP:
\r
3822 case WM_RBUTTONUP:
\r
3824 RightClick(Release, pt.x - boardRect.left, pt.y - boardRect.top, &fromX, &fromY);
\r
3827 case WM_MBUTTONDOWN:
\r
3828 case WM_RBUTTONDOWN:
\r
3831 fromX = fromY = -1;
\r
3832 dragInfo.pos.x = dragInfo.pos.y = -1;
\r
3833 dragInfo.start.x = dragInfo.start.y = -1;
\r
3834 dragInfo.from = dragInfo.start;
\r
3835 dragInfo.lastpos = dragInfo.pos;
\r
3836 if (appData.highlightDragging) {
\r
3837 ClearHighlights();
\r
3840 /* [HGM] right mouse button in clock area edit-game mode ups clock */
\r
3841 if (PtInRect((LPRECT) &whiteRect, pt)) {
\r
3842 if (gameMode == EditGame) AdjustClock(flipClock, 1);
\r
3843 } else if (PtInRect((LPRECT) &blackRect, pt)) {
\r
3844 if (gameMode == EditGame) AdjustClock(!flipClock, 1);
\r
3847 DrawPosition(TRUE, NULL);
\r
3849 menuNr = RightClick(Press, pt.x - boardRect.left, pt.y - boardRect.top, &fromX, &fromY);
\r
3852 if (message == WM_MBUTTONDOWN) {
\r
3853 buttonCount = 3; /* even if system didn't think so */
\r
3854 if (wParam & MK_SHIFT)
\r
3855 MenuPopup(hwnd, pt, LoadMenu(hInst, "BlackPieceMenu"), -1);
\r
3857 MenuPopup(hwnd, pt, LoadMenu(hInst, "WhitePieceMenu"), -1);
\r
3858 } else { /* message == WM_RBUTTONDOWN */
\r
3859 /* Just have one menu, on the right button. Windows users don't
\r
3860 think to try the middle one, and sometimes other software steals
\r
3861 it, or it doesn't really exist. */
\r
3862 if(gameInfo.variant != VariantShogi)
\r
3863 MenuPopup(hwnd, pt, LoadMenu(hInst, "PieceMenu"), -1);
\r
3865 MenuPopup(hwnd, pt, LoadMenu(hInst, "ShogiPieceMenu"), -1);
\r
3869 SetCapture(hwndMain);
3872 hmenu = LoadMenu(hInst, "DropPieceMenu");
\r
3873 SetupDropMenu(hmenu);
\r
3874 MenuPopup(hwnd, pt, hmenu, -1);
\r
3884 /* Preprocess messages for buttons in main window */
\r
3886 ButtonProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
3888 int id = GetWindowLong(hwnd, GWL_ID);
\r
3891 for (i=0; i<N_BUTTONS; i++) {
\r
3892 if (buttonDesc[i].id == id) break;
\r
3894 if (i == N_BUTTONS) return 0;
\r
3895 switch (message) {
\r
3900 dir = (wParam == VK_LEFT) ? -1 : 1;
\r
3901 SetFocus(buttonDesc[(i + dir + N_BUTTONS) % N_BUTTONS].hwnd);
\r
3908 SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(buttonDesc[i].id, 0), 0);
\r
3911 if (appData.icsActive && (isalpha((char)wParam) || wParam == '0')) {
\r
3912 // [HGM] movenum: only letters or leading zero should go to ICS input
\r
3913 HWND h = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
3914 if (IsIconic(hwndConsole)) ShowWindow(hwndConsole, SW_RESTORE);
\r
3916 SendMessage(h, WM_CHAR, wParam, lParam);
\r
3918 } else if (isalpha((char)wParam) || isdigit((char)wParam)){
\r
3919 PopUpMoveDialog((char)wParam);
\r
3925 return CallWindowProc(buttonDesc[i].wndproc, hwnd, message, wParam, lParam);
\r
3928 /* Process messages for Promotion dialog box */
\r
3930 Promotion(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
3934 switch (message) {
\r
3935 case WM_INITDIALOG: /* message: initialize dialog box */
\r
3936 /* Center the dialog over the application window */
\r
3937 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
3938 ShowWindow(GetDlgItem(hDlg, PB_King),
\r
3939 (!appData.testLegality || gameInfo.variant == VariantSuicide ||
\r
3940 gameInfo.variant == VariantGiveaway || gameInfo.variant == VariantSuper ) ?
\r
3941 SW_SHOW : SW_HIDE);
\r
3942 /* [HGM] Only allow C & A promotions if these pieces are defined */
\r
3943 ShowWindow(GetDlgItem(hDlg, PB_Archbishop),
\r
3944 ((PieceToChar(WhiteAngel) >= 'A' &&
\r
3945 PieceToChar(WhiteAngel) != '~') ||
\r
3946 (PieceToChar(BlackAngel) >= 'A' &&
\r
3947 PieceToChar(BlackAngel) != '~') ) ?
\r
3948 SW_SHOW : SW_HIDE);
\r
3949 ShowWindow(GetDlgItem(hDlg, PB_Chancellor),
\r
3950 ((PieceToChar(WhiteMarshall) >= 'A' &&
\r
3951 PieceToChar(WhiteMarshall) != '~') ||
\r
3952 (PieceToChar(BlackMarshall) >= 'A' &&
\r
3953 PieceToChar(BlackMarshall) != '~') ) ?
\r
3954 SW_SHOW : SW_HIDE);
\r
3955 /* [HGM] Hide B & R button in Shogi, use Q as promote, N as defer */
\r
3956 ShowWindow(GetDlgItem(hDlg, PB_Rook),
\r
3957 gameInfo.variant != VariantShogi ?
\r
3958 SW_SHOW : SW_HIDE);
\r
3959 ShowWindow(GetDlgItem(hDlg, PB_Bishop),
\r
3960 gameInfo.variant != VariantShogi ?
\r
3961 SW_SHOW : SW_HIDE);
\r
3962 ShowWindow(GetDlgItem(hDlg, IDC_Yes),
\r
3963 gameInfo.variant == VariantShogi ?
\r
3964 SW_SHOW : SW_HIDE);
\r
3965 ShowWindow(GetDlgItem(hDlg, IDC_No),
\r
3966 gameInfo.variant == VariantShogi ?
\r
3967 SW_SHOW : SW_HIDE);
\r
3968 ShowWindow(GetDlgItem(hDlg, IDC_Centaur),
\r
3969 gameInfo.variant == VariantSuper ?
\r
3970 SW_SHOW : SW_HIDE);
\r
3973 case WM_COMMAND: /* message: received a command */
\r
3974 switch (LOWORD(wParam)) {
\r
3976 EndDialog(hDlg, TRUE); /* Exit the dialog */
\r
3977 ClearHighlights();
\r
3978 DrawPosition(FALSE, NULL);
\r
3981 promoChar = gameInfo.variant == VariantSuper ? PieceToChar(BlackSilver) : PieceToChar(BlackKing);
\r
3984 promoChar = gameInfo.variant == VariantShogi ? '+' : PieceToChar(BlackQueen);
\r
3987 promoChar = PieceToChar(BlackRook);
\r
3990 promoChar = PieceToChar(BlackBishop);
\r
3992 case PB_Chancellor:
\r
3993 promoChar = PieceToChar(BlackMarshall);
\r
3995 case PB_Archbishop:
\r
3996 promoChar = PieceToChar(BlackAngel);
\r
3999 promoChar = gameInfo.variant == VariantShogi ? '=' : PieceToChar(BlackKnight);
\r
4004 EndDialog(hDlg, TRUE); /* Exit the dialog */
\r
4005 /* [HGM] <popupFix> Call FinishMove rather than UserMoveEvent, as we
\r
4006 only show the popup when we are already sure the move is valid or
\r
4007 legal. We pass a faulty move type, but the kludge is that FinishMove
\r
4008 will figure out it is a promotion from the promoChar. */
\r
4009 UserMoveEvent(fromX, fromY, toX, toY, promoChar);
\r
4010 fromX = fromY = -1;
\r
4011 if (!appData.highlightLastMove) {
\r
4012 ClearHighlights();
\r
4013 DrawPosition(FALSE, NULL);
\r
4020 /* Pop up promotion dialog */
\r
4022 PromotionPopup(HWND hwnd)
\r
4026 lpProc = MakeProcInstance((FARPROC)Promotion, hInst);
\r
4027 DialogBox(hInst, MAKEINTRESOURCE(DLG_PromotionKing),
\r
4028 hwnd, (DLGPROC)lpProc);
\r
4029 FreeProcInstance(lpProc);
\r
4035 DrawPosition(TRUE, NULL);
\r
4036 PromotionPopup(hwndMain);
\r
4039 /* Toggle ShowThinking */
\r
4041 ToggleShowThinking()
\r
4043 appData.showThinking = !appData.showThinking;
\r
4044 ShowThinkingEvent();
\r
4048 LoadGameDialog(HWND hwnd, char* title)
\r
4052 char fileTitle[MSG_SIZ];
\r
4053 f = OpenFileDialog(hwnd, "rb", "",
\r
4054 appData.oldSaveStyle ? "gam" : "pgn",
\r
4056 title, &number, fileTitle, NULL);
\r
4058 cmailMsgLoaded = FALSE;
\r
4059 if (number == 0) {
\r
4060 int error = GameListBuild(f);
\r
4062 DisplayError("Cannot build game list", error);
\r
4063 } else if (!ListEmpty(&gameList) &&
\r
4064 ((ListGame *) gameList.tailPred)->number > 1) {
\r
4065 GameListPopUp(f, fileTitle);
\r
4068 GameListDestroy();
\r
4071 LoadGame(f, number, fileTitle, FALSE);
\r
4075 int get_term_width()
\r
4080 HFONT hfont, hold_font;
\r
4085 hText = GetDlgItem(hwndConsole, OPT_ConsoleText);
\r
4089 // get the text metrics
\r
4090 hdc = GetDC(hText);
\r
4091 lf = font[boardSize][CONSOLE_FONT]->lf;
\r
4092 if (consoleCF.dwEffects & CFE_BOLD)
\r
4093 lf.lfWeight = FW_BOLD;
\r
4094 if (consoleCF.dwEffects & CFE_ITALIC)
\r
4095 lf.lfItalic = TRUE;
\r
4096 if (consoleCF.dwEffects & CFE_STRIKEOUT)
\r
4097 lf.lfStrikeOut = TRUE;
\r
4098 if (consoleCF.dwEffects & CFE_UNDERLINE)
\r
4099 lf.lfUnderline = TRUE;
\r
4100 hfont = CreateFontIndirect(&lf);
\r
4101 hold_font = SelectObject(hdc, hfont);
\r
4102 GetTextMetrics(hdc, &tm);
\r
4103 SelectObject(hdc, hold_font);
\r
4104 DeleteObject(hfont);
\r
4105 ReleaseDC(hText, hdc);
\r
4107 // get the rectangle
\r
4108 SendMessage(hText, EM_GETRECT, 0, (LPARAM)&rc);
\r
4110 return (rc.right-rc.left) / tm.tmAveCharWidth;
\r
4113 void UpdateICSWidth(HWND hText)
\r
4115 LONG old_width, new_width;
\r
4117 new_width = get_term_width(hText, FALSE);
\r
4118 old_width = GetWindowLong(hText, GWL_USERDATA);
\r
4119 if (new_width != old_width)
\r
4121 ics_update_width(new_width);
\r
4122 SetWindowLong(hText, GWL_USERDATA, new_width);
\r
4127 ChangedConsoleFont()
\r
4130 CHARRANGE tmpsel, sel;
\r
4131 MyFont *f = font[boardSize][CONSOLE_FONT];
\r
4132 HWND hText = GetDlgItem(hwndConsole, OPT_ConsoleText);
\r
4133 HWND hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
4136 cfmt.cbSize = sizeof(CHARFORMAT);
\r
4137 cfmt.dwMask = CFM_FACE|CFM_SIZE|CFM_CHARSET;
\r
4138 strcpy(cfmt.szFaceName, font[boardSize][CONSOLE_FONT]->mfp.faceName);
\r
4139 /* yHeight is expressed in twips. A twip is 1/20 of a font's point
\r
4140 * size. This was undocumented in the version of MSVC++ that I had
\r
4141 * when I wrote the code, but is apparently documented now.
\r
4143 cfmt.yHeight = (int)(f->mfp.pointSize * 20.0 + 0.5);
\r
4144 cfmt.bCharSet = f->lf.lfCharSet;
\r
4145 cfmt.bPitchAndFamily = f->lf.lfPitchAndFamily;
\r
4146 SendMessage(hText, EM_SETCHARFORMAT, SCF_ALL, (LPARAM) &cfmt);
\r
4147 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM) &cfmt);
\r
4148 /* Why are the following seemingly needed too? */
\r
4149 SendMessage(hText, EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM) &cfmt);
\r
4150 SendMessage(hInput, EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM) &cfmt);
\r
4151 SendMessage(hText, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
4153 tmpsel.cpMax = -1; /*999999?*/
\r
4154 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&tmpsel);
\r
4155 SendMessage(hText, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) &cfmt);
\r
4156 /* Trying putting this here too. It still seems to tickle a RichEdit
\r
4157 * bug: sometimes RichEdit indents the first line of a paragraph too.
\r
4159 paraf.cbSize = sizeof(paraf);
\r
4160 paraf.dwMask = PFM_OFFSET | PFM_STARTINDENT;
\r
4161 paraf.dxStartIndent = 0;
\r
4162 paraf.dxOffset = WRAP_INDENT;
\r
4163 SendMessage(hText, EM_SETPARAFORMAT, 0, (LPARAM) ¶f);
\r
4164 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
4165 UpdateICSWidth(hText);
\r
4168 /*---------------------------------------------------------------------------*\
\r
4170 * Window Proc for main window
\r
4172 \*---------------------------------------------------------------------------*/
\r
4174 /* Process messages for main window, etc. */
\r
4176 WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
4179 int wmId, wmEvent;
\r
4183 char fileTitle[MSG_SIZ];
\r
4184 char buf[MSG_SIZ];
\r
4185 static SnapData sd;
\r
4187 switch (message) {
\r
4189 case WM_PAINT: /* message: repaint portion of window */
\r
4193 case WM_ERASEBKGND:
\r
4194 if (IsIconic(hwnd)) {
\r
4195 /* Cheat; change the message */
\r
4196 return (DefWindowProc(hwnd, WM_ICONERASEBKGND, wParam, lParam));
\r
4198 return (DefWindowProc(hwnd, message, wParam, lParam));
\r
4202 case WM_LBUTTONDOWN:
\r
4203 case WM_MBUTTONDOWN:
\r
4204 case WM_RBUTTONDOWN:
\r
4205 case WM_LBUTTONUP:
\r
4206 case WM_MBUTTONUP:
\r
4207 case WM_RBUTTONUP:
\r
4208 case WM_MOUSEMOVE:
\r
4209 case WM_MOUSEWHEEL:
\r
4210 MouseEvent(hwnd, message, wParam, lParam);
\r
4213 JAWS_KB_NAVIGATION
\r
4217 JAWS_ALT_INTERCEPT
\r
4219 if (appData.icsActive && ((char)wParam == '\r' || (char)wParam > ' ' && !((char)wParam >= '1' && (char)wParam <= '9'))) {
\r
4220 // [HGM] movenum: for non-zero digits we always do type-in dialog
\r
4221 HWND h = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
4222 if (IsIconic(hwndConsole)) ShowWindow(hwndConsole, SW_RESTORE);
\r
4224 SendMessage(h, message, wParam, lParam);
\r
4225 } else if(lParam != KF_REPEAT) {
\r
4226 if (isalpha((char)wParam) || isdigit((char)wParam)) {
\r
4227 PopUpMoveDialog((char)wParam);
\r
4228 } else if((char)wParam == 003) CopyGameToClipboard();
\r
4229 else if((char)wParam == 026) PasteGameOrFENFromClipboard();
\r
4234 case WM_PALETTECHANGED:
\r
4235 if (hwnd != (HWND)wParam && !appData.monoMode) {
\r
4237 HDC hdc = GetDC(hwndMain);
\r
4238 SelectPalette(hdc, hPal, TRUE);
\r
4239 nnew = RealizePalette(hdc);
\r
4241 paletteChanged = TRUE;
\r
4242 InvalidateRect(hwnd, &boardRect, FALSE);
\r
4244 ReleaseDC(hwnd, hdc);
\r
4248 case WM_QUERYNEWPALETTE:
\r
4249 if (!appData.monoMode /*&& paletteChanged*/) {
\r
4251 HDC hdc = GetDC(hwndMain);
\r
4252 paletteChanged = FALSE;
\r
4253 SelectPalette(hdc, hPal, FALSE);
\r
4254 nnew = RealizePalette(hdc);
\r
4256 InvalidateRect(hwnd, &boardRect, FALSE);
\r
4258 ReleaseDC(hwnd, hdc);
\r
4263 case WM_COMMAND: /* message: command from application menu */
\r
4264 wmId = LOWORD(wParam);
\r
4265 wmEvent = HIWORD(wParam);
\r
4270 SAY("new game enter a move to play against the computer with white");
\r
4273 case IDM_NewGameFRC:
\r
4274 if( NewGameFRC() == 0 ) {
\r
4279 case IDM_NewVariant:
\r
4280 NewVariantPopup(hwnd);
\r
4283 case IDM_LoadGame:
\r
4284 LoadGameDialog(hwnd, "Load Game from File");
\r
4287 case IDM_LoadNextGame:
\r
4291 case IDM_LoadPrevGame:
\r
4295 case IDM_ReloadGame:
\r
4299 case IDM_LoadPosition:
\r
4300 if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
\r
4301 Reset(FALSE, TRUE);
\r
4304 f = OpenFileDialog(hwnd, "rb", "",
\r
4305 appData.oldSaveStyle ? "pos" : "fen",
\r
4307 "Load Position from File", &number, fileTitle, NULL);
\r
4309 LoadPosition(f, number, fileTitle);
\r
4313 case IDM_LoadNextPosition:
\r
4314 ReloadPosition(1);
\r
4317 case IDM_LoadPrevPosition:
\r
4318 ReloadPosition(-1);
\r
4321 case IDM_ReloadPosition:
\r
4322 ReloadPosition(0);
\r
4325 case IDM_SaveGame:
\r
4326 defName = DefaultFileName(appData.oldSaveStyle ? "gam" : "pgn");
\r
4327 f = OpenFileDialog(hwnd, "a", defName,
\r
4328 appData.oldSaveStyle ? "gam" : "pgn",
\r
4330 "Save Game to File", NULL, fileTitle, NULL);
\r
4332 SaveGame(f, 0, "");
\r
4336 case IDM_SavePosition:
\r
4337 defName = DefaultFileName(appData.oldSaveStyle ? "pos" : "fen");
\r
4338 f = OpenFileDialog(hwnd, "a", defName,
\r
4339 appData.oldSaveStyle ? "pos" : "fen",
\r
4341 "Save Position to File", NULL, fileTitle, NULL);
\r
4343 SavePosition(f, 0, "");
\r
4347 case IDM_SaveDiagram:
\r
4348 defName = "diagram";
\r
4349 f = OpenFileDialog(hwnd, "wb", defName,
\r
4352 "Save Diagram to File", NULL, fileTitle, NULL);
\r
4358 case IDM_CopyGame:
\r
4359 CopyGameToClipboard();
\r
4362 case IDM_PasteGame:
\r
4363 PasteGameFromClipboard();
\r
4366 case IDM_CopyGameListToClipboard:
\r
4367 CopyGameListToClipboard();
\r
4370 /* [AS] Autodetect FEN or PGN data */
\r
4371 case IDM_PasteAny:
\r
4372 PasteGameOrFENFromClipboard();
\r
4375 /* [AS] Move history */
\r
4376 case IDM_ShowMoveHistory:
\r
4377 if( MoveHistoryIsUp() ) {
\r
4378 MoveHistoryPopDown();
\r
4381 MoveHistoryPopUp();
\r
4385 /* [AS] Eval graph */
\r
4386 case IDM_ShowEvalGraph:
\r
4387 if( EvalGraphIsUp() ) {
\r
4388 EvalGraphPopDown();
\r
4392 SetFocus(hwndMain);
\r
4396 /* [AS] Engine output */
\r
4397 case IDM_ShowEngineOutput:
\r
4398 if( EngineOutputIsUp() ) {
\r
4399 EngineOutputPopDown();
\r
4402 EngineOutputPopUp();
\r
4406 /* [AS] User adjudication */
\r
4407 case IDM_UserAdjudication_White:
\r
4408 UserAdjudicationEvent( +1 );
\r
4411 case IDM_UserAdjudication_Black:
\r
4412 UserAdjudicationEvent( -1 );
\r
4415 case IDM_UserAdjudication_Draw:
\r
4416 UserAdjudicationEvent( 0 );
\r
4419 /* [AS] Game list options dialog */
\r
4420 case IDM_GameListOptions:
\r
4421 GameListOptions();
\r
4428 case IDM_CopyPosition:
\r
4429 CopyFENToClipboard();
\r
4432 case IDM_PastePosition:
\r
4433 PasteFENFromClipboard();
\r
4436 case IDM_MailMove:
\r
4440 case IDM_ReloadCMailMsg:
\r
4441 Reset(TRUE, TRUE);
\r
4442 ReloadCmailMsgEvent(FALSE);
\r
4445 case IDM_Minimize:
\r
4446 ShowWindow(hwnd, SW_MINIMIZE);
\r
4453 case IDM_MachineWhite:
\r
4454 MachineWhiteEvent();
\r
4456 * refresh the tags dialog only if it's visible
\r
4458 if (gameMode == MachinePlaysWhite && IsWindowVisible(editTagsDialog)) {
\r
4460 tags = PGNTags(&gameInfo);
\r
4461 TagsPopUp(tags, CmailMsg());
\r
4464 SAY("computer starts playing white");
\r
4467 case IDM_MachineBlack:
\r
4468 MachineBlackEvent();
\r
4470 * refresh the tags dialog only if it's visible
\r
4472 if (gameMode == MachinePlaysBlack && IsWindowVisible(editTagsDialog)) {
\r
4474 tags = PGNTags(&gameInfo);
\r
4475 TagsPopUp(tags, CmailMsg());
\r
4478 SAY("computer starts playing black");
\r
4481 case IDM_TwoMachines:
\r
4482 TwoMachinesEvent();
\r
4484 * refresh the tags dialog only if it's visible
\r
4486 if (gameMode == TwoMachinesPlay && IsWindowVisible(editTagsDialog)) {
\r
4488 tags = PGNTags(&gameInfo);
\r
4489 TagsPopUp(tags, CmailMsg());
\r
4492 SAY("programs start playing each other");
\r
4495 case IDM_AnalysisMode:
\r
4496 if (!first.analysisSupport) {
\r
4497 sprintf(buf, "%s does not support analysis", first.tidy);
\r
4498 DisplayError(buf, 0);
\r
4500 SAY("analyzing current position");
\r
4501 /* [DM] icsEngineAnlyze [HGM] Why is this front-end??? */
\r
4502 if (appData.icsActive) {
\r
4503 if (gameMode != IcsObserving) {
\r
4504 sprintf(buf, "You are not observing a game");
\r
4505 DisplayError(buf, 0);
\r
4506 /* secure check */
\r
4507 if (appData.icsEngineAnalyze) {
\r
4508 if (appData.debugMode)
\r
4509 fprintf(debugFP, "Found unexpected active ICS engine analyze \n");
\r
4510 ExitAnalyzeMode();
\r
4516 /* if enable, user want disable icsEngineAnalyze */
\r
4517 if (appData.icsEngineAnalyze) {
\r
4518 ExitAnalyzeMode();
\r
4522 appData.icsEngineAnalyze = TRUE;
\r
4523 if (appData.debugMode) fprintf(debugFP, "ICS engine analyze starting...\n");
\r
4526 if (!appData.showThinking) ToggleShowThinking();
\r
4527 AnalyzeModeEvent();
\r
4531 case IDM_AnalyzeFile:
\r
4532 if (!first.analysisSupport) {
\r
4533 char buf[MSG_SIZ];
\r
4534 sprintf(buf, "%s does not support analysis", first.tidy);
\r
4535 DisplayError(buf, 0);
\r
4537 if (!appData.showThinking) ToggleShowThinking();
\r
4538 AnalyzeFileEvent();
\r
4539 LoadGameDialog(hwnd, "Analyze Game from File");
\r
4540 AnalysisPeriodicEvent(1);
\r
4544 case IDM_IcsClient:
\r
4548 case IDM_EditGame:
\r
4553 case IDM_EditPosition:
\r
4554 EditPositionEvent();
\r
4555 SAY("to set up a position type a FEN");
\r
4558 case IDM_Training:
\r
4562 case IDM_ShowGameList:
\r
4563 ShowGameListProc();
\r
4566 case IDM_EditTags:
\r
4570 case IDM_EditComment:
\r
4571 if (commentUp && editComment) {
\r
4574 EditCommentEvent();
\r
4594 case IDM_CallFlag:
\r
4614 case IDM_StopObserving:
\r
4615 StopObservingEvent();
\r
4618 case IDM_StopExamining:
\r
4619 StopExaminingEvent();
\r
4622 case IDM_TypeInMove:
\r
4623 PopUpMoveDialog('\000');
\r
4626 case IDM_TypeInName:
\r
4627 PopUpNameDialog('\000');
\r
4630 case IDM_Backward:
\r
4632 SetFocus(hwndMain);
\r
4639 SetFocus(hwndMain);
\r
4644 SetFocus(hwndMain);
\r
4649 SetFocus(hwndMain);
\r
4656 case IDM_TruncateGame:
\r
4657 TruncateGameEvent();
\r
4664 case IDM_RetractMove:
\r
4665 RetractMoveEvent();
\r
4668 case IDM_FlipView:
\r
4669 flipView = !flipView;
\r
4670 DrawPosition(FALSE, NULL);
\r
4673 case IDM_FlipClock:
\r
4674 flipClock = !flipClock;
\r
4675 DisplayBothClocks();
\r
4676 DrawPosition(FALSE, NULL);
\r
4679 case IDM_MuteSounds:
\r
4680 mute = !mute; // [HGM] mute: keep track of global muting variable
\r
4681 CheckMenuItem(GetMenu(hwndMain),IDM_MuteSounds,
\r
4682 MF_BYCOMMAND|(mute?MF_CHECKED:MF_UNCHECKED));
\r
4685 case IDM_GeneralOptions:
\r
4686 GeneralOptionsPopup(hwnd);
\r
4687 DrawPosition(TRUE, NULL);
\r
4690 case IDM_BoardOptions:
\r
4691 BoardOptionsPopup(hwnd);
\r
4694 case IDM_EnginePlayOptions:
\r
4695 EnginePlayOptionsPopup(hwnd);
\r
4698 case IDM_Engine1Options:
\r
4699 EngineOptionsPopup(hwnd, &first);
\r
4702 case IDM_Engine2Options:
\r
4703 EngineOptionsPopup(hwnd, &second);
\r
4706 case IDM_OptionsUCI:
\r
4707 UciOptionsPopup(hwnd);
\r
4710 case IDM_IcsOptions:
\r
4711 IcsOptionsPopup(hwnd);
\r
4715 FontsOptionsPopup(hwnd);
\r
4719 SoundOptionsPopup(hwnd);
\r
4722 case IDM_CommPort:
\r
4723 CommPortOptionsPopup(hwnd);
\r
4726 case IDM_LoadOptions:
\r
4727 LoadOptionsPopup(hwnd);
\r
4730 case IDM_SaveOptions:
\r
4731 SaveOptionsPopup(hwnd);
\r
4734 case IDM_TimeControl:
\r
4735 TimeControlOptionsPopup(hwnd);
\r
4738 case IDM_SaveSettings:
\r
4739 SaveSettings(settingsFileName);
\r
4742 case IDM_SaveSettingsOnExit:
\r
4743 saveSettingsOnExit = !saveSettingsOnExit;
\r
4744 (void) CheckMenuItem(GetMenu(hwndMain), IDM_SaveSettingsOnExit,
\r
4745 MF_BYCOMMAND|(saveSettingsOnExit ?
\r
4746 MF_CHECKED : MF_UNCHECKED));
\r
4757 case IDM_AboutGame:
\r
4762 appData.debugMode = !appData.debugMode;
\r
4763 if (appData.debugMode) {
\r
4764 char dir[MSG_SIZ];
\r
4765 GetCurrentDirectory(MSG_SIZ, dir);
\r
4766 SetCurrentDirectory(installDir);
\r
4767 debugFP = fopen(appData.nameOfDebugFile, "w");
\r
4768 SetCurrentDirectory(dir);
\r
4769 setbuf(debugFP, NULL);
\r
4776 case IDM_HELPCONTENTS:
\r
4777 if (!MyHelp (hwnd, "winboard.hlp", HELP_KEY,(DWORD)(LPSTR)"CONTENTS") &&
\r
4778 !HtmlHelp(hwnd, "winboard.chm", 0, 0) ) {
\r
4779 MessageBox (GetFocus(),
\r
4780 "Unable to activate help",
\r
4781 szAppName, MB_SYSTEMMODAL|MB_OK|MB_ICONHAND);
\r
4785 case IDM_HELPSEARCH:
\r
4786 if (!MyHelp (hwnd, "winboard.hlp", HELP_PARTIALKEY, (DWORD)(LPSTR)"") &&
\r
4787 !HtmlHelp(hwnd, "winboard.chm", 0, 0) ) {
\r
4788 MessageBox (GetFocus(),
\r
4789 "Unable to activate help",
\r
4790 szAppName, MB_SYSTEMMODAL|MB_OK|MB_ICONHAND);
\r
4794 case IDM_HELPHELP:
\r
4795 if(!WinHelp(hwnd, (LPSTR)NULL, HELP_HELPONHELP, 0)) {
\r
4796 MessageBox (GetFocus(),
\r
4797 "Unable to activate help",
\r
4798 szAppName, MB_SYSTEMMODAL|MB_OK|MB_ICONHAND);
\r
4803 lpProc = MakeProcInstance((FARPROC)About, hInst);
\r
4805 (gameInfo.event && strcmp(gameInfo.event, "Easter Egg Hunt") == 0) ?
\r
4806 "AboutBox2" : "AboutBox", hwnd, (DLGPROC)lpProc);
\r
4807 FreeProcInstance(lpProc);
\r
4810 case IDM_DirectCommand1:
\r
4811 AskQuestionEvent("Direct Command",
\r
4812 "Send to chess program:", "", "1");
\r
4814 case IDM_DirectCommand2:
\r
4815 AskQuestionEvent("Direct Command",
\r
4816 "Send to second chess program:", "", "2");
\r
4819 case EP_WhitePawn:
\r
4820 EditPositionMenuEvent(WhitePawn, fromX, fromY);
\r
4821 fromX = fromY = -1;
\r
4824 case EP_WhiteKnight:
\r
4825 EditPositionMenuEvent(WhiteKnight, fromX, fromY);
\r
4826 fromX = fromY = -1;
\r
4829 case EP_WhiteBishop:
\r
4830 EditPositionMenuEvent(WhiteBishop, fromX, fromY);
\r
4831 fromX = fromY = -1;
\r
4834 case EP_WhiteRook:
\r
4835 EditPositionMenuEvent(WhiteRook, fromX, fromY);
\r
4836 fromX = fromY = -1;
\r
4839 case EP_WhiteQueen:
\r
4840 EditPositionMenuEvent(WhiteQueen, fromX, fromY);
\r
4841 fromX = fromY = -1;
\r
4844 case EP_WhiteFerz:
\r
4845 EditPositionMenuEvent(WhiteFerz, fromX, fromY);
\r
4846 fromX = fromY = -1;
\r
4849 case EP_WhiteWazir:
\r
4850 EditPositionMenuEvent(WhiteWazir, fromX, fromY);
\r
4851 fromX = fromY = -1;
\r
4854 case EP_WhiteAlfil:
\r
4855 EditPositionMenuEvent(WhiteAlfil, fromX, fromY);
\r
4856 fromX = fromY = -1;
\r
4859 case EP_WhiteCannon:
\r
4860 EditPositionMenuEvent(WhiteCannon, fromX, fromY);
\r
4861 fromX = fromY = -1;
\r
4864 case EP_WhiteCardinal:
\r
4865 EditPositionMenuEvent(WhiteAngel, fromX, fromY);
\r
4866 fromX = fromY = -1;
\r
4869 case EP_WhiteMarshall:
\r
4870 EditPositionMenuEvent(WhiteMarshall, fromX, fromY);
\r
4871 fromX = fromY = -1;
\r
4874 case EP_WhiteKing:
\r
4875 EditPositionMenuEvent(WhiteKing, fromX, fromY);
\r
4876 fromX = fromY = -1;
\r
4879 case EP_BlackPawn:
\r
4880 EditPositionMenuEvent(BlackPawn, fromX, fromY);
\r
4881 fromX = fromY = -1;
\r
4884 case EP_BlackKnight:
\r
4885 EditPositionMenuEvent(BlackKnight, fromX, fromY);
\r
4886 fromX = fromY = -1;
\r
4889 case EP_BlackBishop:
\r
4890 EditPositionMenuEvent(BlackBishop, fromX, fromY);
\r
4891 fromX = fromY = -1;
\r
4894 case EP_BlackRook:
\r
4895 EditPositionMenuEvent(BlackRook, fromX, fromY);
\r
4896 fromX = fromY = -1;
\r
4899 case EP_BlackQueen:
\r
4900 EditPositionMenuEvent(BlackQueen, fromX, fromY);
\r
4901 fromX = fromY = -1;
\r
4904 case EP_BlackFerz:
\r
4905 EditPositionMenuEvent(BlackFerz, fromX, fromY);
\r
4906 fromX = fromY = -1;
\r
4909 case EP_BlackWazir:
\r
4910 EditPositionMenuEvent(BlackWazir, fromX, fromY);
\r
4911 fromX = fromY = -1;
\r
4914 case EP_BlackAlfil:
\r
4915 EditPositionMenuEvent(BlackAlfil, fromX, fromY);
\r
4916 fromX = fromY = -1;
\r
4919 case EP_BlackCannon:
\r
4920 EditPositionMenuEvent(BlackCannon, fromX, fromY);
\r
4921 fromX = fromY = -1;
\r
4924 case EP_BlackCardinal:
\r
4925 EditPositionMenuEvent(BlackAngel, fromX, fromY);
\r
4926 fromX = fromY = -1;
\r
4929 case EP_BlackMarshall:
\r
4930 EditPositionMenuEvent(BlackMarshall, fromX, fromY);
\r
4931 fromX = fromY = -1;
\r
4934 case EP_BlackKing:
\r
4935 EditPositionMenuEvent(BlackKing, fromX, fromY);
\r
4936 fromX = fromY = -1;
\r
4939 case EP_EmptySquare:
\r
4940 EditPositionMenuEvent(EmptySquare, fromX, fromY);
\r
4941 fromX = fromY = -1;
\r
4944 case EP_ClearBoard:
\r
4945 EditPositionMenuEvent(ClearBoard, fromX, fromY);
\r
4946 fromX = fromY = -1;
\r
4950 EditPositionMenuEvent(WhitePlay, fromX, fromY);
\r
4951 fromX = fromY = -1;
\r
4955 EditPositionMenuEvent(BlackPlay, fromX, fromY);
\r
4956 fromX = fromY = -1;
\r
4960 EditPositionMenuEvent(PromotePiece, fromX, fromY);
\r
4961 fromX = fromY = -1;
\r
4965 EditPositionMenuEvent(DemotePiece, fromX, fromY);
\r
4966 fromX = fromY = -1;
\r
4970 DropMenuEvent(WhitePawn, fromX, fromY);
\r
4971 fromX = fromY = -1;
\r
4975 DropMenuEvent(WhiteKnight, fromX, fromY);
\r
4976 fromX = fromY = -1;
\r
4980 DropMenuEvent(WhiteBishop, fromX, fromY);
\r
4981 fromX = fromY = -1;
\r
4985 DropMenuEvent(WhiteRook, fromX, fromY);
\r
4986 fromX = fromY = -1;
\r
4990 DropMenuEvent(WhiteQueen, fromX, fromY);
\r
4991 fromX = fromY = -1;
\r
4995 return (DefWindowProc(hwnd, message, wParam, lParam));
\r
5001 case CLOCK_TIMER_ID:
\r
5002 KillTimer(hwnd, clockTimerEvent); /* Simulate one-shot timer as in X */
\r
5003 clockTimerEvent = 0;
\r
5004 DecrementClocks(); /* call into back end */
\r
5006 case LOAD_GAME_TIMER_ID:
\r
5007 KillTimer(hwnd, loadGameTimerEvent); /* Simulate one-shot timer as in X*/
\r
5008 loadGameTimerEvent = 0;
\r
5009 AutoPlayGameLoop(); /* call into back end */
\r
5011 case ANALYSIS_TIMER_ID:
\r
5012 if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile
\r
5013 || appData.icsEngineAnalyze) && appData.periodicUpdates) {
\r
5014 AnalysisPeriodicEvent(0);
\r
5016 KillTimer(hwnd, analysisTimerEvent);
\r
5017 analysisTimerEvent = 0;
\r
5020 case DELAYED_TIMER_ID:
\r
5021 KillTimer(hwnd, delayedTimerEvent);
\r
5022 delayedTimerEvent = 0;
\r
5023 delayedTimerCallback();
\r
5028 case WM_USER_Input:
\r
5029 InputEvent(hwnd, message, wParam, lParam);
\r
5032 /* [AS] Also move "attached" child windows */
\r
5033 case WM_WINDOWPOSCHANGING:
\r
5035 if( hwnd == hwndMain && appData.useStickyWindows ) {
\r
5036 LPWINDOWPOS lpwp = (LPWINDOWPOS) lParam;
\r
5038 if( ((lpwp->flags & SWP_NOMOVE) == 0) && ((lpwp->flags & SWP_NOSIZE) != 0) ) {
\r
5039 /* Window is moving */
\r
5042 // GetWindowRect( hwnd, &rcMain ); //[HGM] sticky: in XP this returned new position, not old
\r
5043 rcMain.left = wpMain.x; // replace by these 4 lines to reconstruct old rect
\r
5044 rcMain.right = wpMain.x + wpMain.width;
\r
5045 rcMain.top = wpMain.y;
\r
5046 rcMain.bottom = wpMain.y + wpMain.height;
\r
5048 ReattachAfterMove( &rcMain, lpwp->x, lpwp->y, moveHistoryDialog, &wpMoveHistory );
\r
5049 ReattachAfterMove( &rcMain, lpwp->x, lpwp->y, evalGraphDialog, &wpEvalGraph );
\r
5050 ReattachAfterMove( &rcMain, lpwp->x, lpwp->y, engineOutputDialog, &wpEngineOutput );
\r
5051 ReattachAfterMove( &rcMain, lpwp->x, lpwp->y, gameListDialog, &wpGameList );
\r
5052 ReattachAfterMove( &rcMain, lpwp->x, lpwp->y, hwndConsole, &wpConsole );
\r
5053 wpMain.x = lpwp->x;
\r
5054 wpMain.y = lpwp->y;
\r
5059 /* [AS] Snapping */
\r
5060 case WM_ENTERSIZEMOVE:
\r
5061 if(appData.debugMode) { fprintf(debugFP, "size-move\n"); }
\r
5062 if (hwnd == hwndMain) {
\r
5063 doingSizing = TRUE;
\r
5066 return OnEnterSizeMove( &sd, hwnd, wParam, lParam );
\r
5070 if(appData.debugMode) { fprintf(debugFP, "sizing\n"); }
\r
5071 if (hwnd == hwndMain) {
\r
5072 lastSizing = wParam;
\r
5077 if(appData.debugMode) { fprintf(debugFP, "moving\n"); }
\r
5078 return OnMoving( &sd, hwnd, wParam, lParam );
\r
5080 case WM_EXITSIZEMOVE:
\r
5081 if(appData.debugMode) { fprintf(debugFP, "exit size-move, size = %d\n", squareSize); }
\r
5082 if (hwnd == hwndMain) {
\r
5084 doingSizing = FALSE;
\r
5085 InvalidateRect(hwnd, &boardRect, FALSE);
\r
5086 GetClientRect(hwnd, &client);
\r
5087 ResizeBoard(client.right, client.bottom, lastSizing);
\r
5089 if(appData.debugMode) { fprintf(debugFP, "square size = %d\n", squareSize); }
\r
5091 return OnExitSizeMove( &sd, hwnd, wParam, lParam );
\r
5094 case WM_DESTROY: /* message: window being destroyed */
\r
5095 PostQuitMessage(0);
\r
5099 if (hwnd == hwndMain) {
\r
5104 default: /* Passes it on if unprocessed */
\r
5105 return (DefWindowProc(hwnd, message, wParam, lParam));
\r
5110 /*---------------------------------------------------------------------------*\
\r
5112 * Misc utility routines
\r
5114 \*---------------------------------------------------------------------------*/
\r
5117 * Decent random number generator, at least not as bad as Windows
\r
5118 * standard rand, which returns a value in the range 0 to 0x7fff.
\r
5120 unsigned int randstate;
\r
5125 randstate = randstate * 1664525 + 1013904223;
\r
5126 return (int) randstate & 0x7fffffff;
\r
5130 mysrandom(unsigned int seed)
\r
5137 * returns TRUE if user selects a different color, FALSE otherwise
\r
5141 ChangeColor(HWND hwnd, COLORREF *which)
\r
5143 static BOOL firstTime = TRUE;
\r
5144 static DWORD customColors[16];
\r
5146 COLORREF newcolor;
\r
5151 /* Make initial colors in use available as custom colors */
\r
5152 /* Should we put the compiled-in defaults here instead? */
\r
5154 customColors[i++] = lightSquareColor & 0xffffff;
\r
5155 customColors[i++] = darkSquareColor & 0xffffff;
\r
5156 customColors[i++] = whitePieceColor & 0xffffff;
\r
5157 customColors[i++] = blackPieceColor & 0xffffff;
\r
5158 customColors[i++] = highlightSquareColor & 0xffffff;
\r
5159 customColors[i++] = premoveHighlightColor & 0xffffff;
\r
5161 for (ccl = (ColorClass) 0; ccl < NColorClasses && i < 16; ccl++) {
\r
5162 customColors[i++] = textAttribs[ccl].color;
\r
5164 while (i < 16) customColors[i++] = RGB(255, 255, 255);
\r
5165 firstTime = FALSE;
\r
5168 cc.lStructSize = sizeof(cc);
\r
5169 cc.hwndOwner = hwnd;
\r
5170 cc.hInstance = NULL;
\r
5171 cc.rgbResult = (DWORD) (*which & 0xffffff);
\r
5172 cc.lpCustColors = (LPDWORD) customColors;
\r
5173 cc.Flags = CC_RGBINIT|CC_FULLOPEN;
\r
5175 if (!ChooseColor(&cc)) return FALSE;
\r
5177 newcolor = (COLORREF) (0x2000000 | cc.rgbResult);
\r
5178 if (newcolor == *which) return FALSE;
\r
5179 *which = newcolor;
\r
5183 InitDrawingColors();
\r
5184 InvalidateRect(hwnd, &boardRect, FALSE);
\r
5189 MyLoadSound(MySound *ms)
\r
5195 if (ms->data) free(ms->data);
\r
5198 switch (ms->name[0]) {
\r
5204 /* System sound from Control Panel. Don't preload here. */
\r
5208 if (ms->name[1] == NULLCHAR) {
\r
5209 /* "!" alone = silence */
\r
5212 /* Builtin wave resource. Error if not found. */
\r
5213 HANDLE h = FindResource(hInst, ms->name + 1, "WAVE");
\r
5214 if (h == NULL) break;
\r
5215 ms->data = (void *)LoadResource(hInst, h);
\r
5216 if (h == NULL) break;
\r
5221 /* .wav file. Error if not found. */
\r
5222 f = fopen(ms->name, "rb");
\r
5223 if (f == NULL) break;
\r
5224 if (fstat(fileno(f), &st) < 0) break;
\r
5225 ms->data = malloc(st.st_size);
\r
5226 if (fread(ms->data, st.st_size, 1, f) < 1) break;
\r
5232 char buf[MSG_SIZ];
\r
5233 sprintf(buf, "Error loading sound %s", ms->name);
\r
5234 DisplayError(buf, GetLastError());
\r
5240 MyPlaySound(MySound *ms)
\r
5242 BOOLEAN ok = FALSE;
\r
5244 if(mute) return TRUE; // [HGM] mute: suppress all sound play when muted
\r
5245 switch (ms->name[0]) {
\r
5247 if(appData.debugMode) fprintf(debugFP, "silence\n");
\r
5252 /* System sound from Control Panel (deprecated feature).
\r
5253 "$" alone or an unset sound name gets default beep (still in use). */
\r
5254 if (ms->name[1]) {
\r
5255 ok = PlaySound(ms->name + 1, NULL, SND_ALIAS|SND_ASYNC);
\r
5257 if (!ok) ok = MessageBeep(MB_OK);
\r
5260 /* Builtin wave resource, or "!" alone for silence */
\r
5261 if (ms->name[1]) {
\r
5262 if (ms->data == NULL) return FALSE;
\r
5263 ok = PlaySound(ms->data, NULL, SND_MEMORY|SND_ASYNC);
\r
5269 /* .wav file. Error if not found. */
\r
5270 if (ms->data == NULL) return FALSE;
\r
5271 ok = PlaySound(ms->data, NULL, SND_MEMORY|SND_ASYNC);
\r
5274 /* Don't print an error: this can happen innocently if the sound driver
\r
5275 is busy; for instance, if another instance of WinBoard is playing
\r
5276 a sound at about the same time. */
\r
5282 OldOpenFileHook(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
5285 OPENFILENAME *ofn;
\r
5286 static UINT *number; /* gross that this is static */
\r
5288 switch (message) {
\r
5289 case WM_INITDIALOG: /* message: initialize dialog box */
\r
5290 /* Center the dialog over the application window */
\r
5291 ofn = (OPENFILENAME *) lParam;
\r
5292 if (ofn->Flags & OFN_ENABLETEMPLATE) {
\r
5293 number = (UINT *) ofn->lCustData;
\r
5294 SendMessage(GetDlgItem(hDlg, edt2), WM_SETTEXT, 0, (LPARAM) "");
\r
5298 CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
\r
5299 return FALSE; /* Allow for further processing */
\r
5302 if ((LOWORD(wParam) == IDOK) && (number != NULL)) {
\r
5303 *number = GetDlgItemInt(hDlg, OPT_IndexNumberOld, &ok, FALSE);
\r
5305 return FALSE; /* Allow for further processing */
\r
5311 OpenFileHook(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
\r
5313 static UINT *number;
\r
5314 OPENFILENAME *ofname;
\r
5317 case WM_INITDIALOG:
\r
5318 ofname = (OPENFILENAME *)lParam;
\r
5319 number = (UINT *)(ofname->lCustData);
\r
5322 ofnot = (OFNOTIFY *)lParam;
\r
5323 if (ofnot->hdr.code == CDN_FILEOK) {
\r
5324 *number = GetDlgItemInt(hdlg, OPT_IndexNumber, NULL, FALSE);
\r
5333 OpenFileDialog(HWND hwnd, char *write, char *defName, char *defExt, // [HGM] diag: type of 'write' now string
\r
5334 char *nameFilt, char *dlgTitle, UINT *number,
\r
5335 char fileTitle[MSG_SIZ], char fileName[MSG_SIZ])
\r
5337 OPENFILENAME openFileName;
\r
5338 char buf1[MSG_SIZ];
\r
5341 if (fileName == NULL) fileName = buf1;
\r
5342 if (defName == NULL) {
\r
5343 strcpy(fileName, "*.");
\r
5344 strcat(fileName, defExt);
\r
5346 strcpy(fileName, defName);
\r
5348 if (fileTitle) strcpy(fileTitle, "");
\r
5349 if (number) *number = 0;
\r
5351 openFileName.lStructSize = sizeof(OPENFILENAME);
\r
5352 openFileName.hwndOwner = hwnd;
\r
5353 openFileName.hInstance = (HANDLE) hInst;
\r
5354 openFileName.lpstrFilter = nameFilt;
\r
5355 openFileName.lpstrCustomFilter = (LPSTR) NULL;
\r
5356 openFileName.nMaxCustFilter = 0L;
\r
5357 openFileName.nFilterIndex = 1L;
\r
5358 openFileName.lpstrFile = fileName;
\r
5359 openFileName.nMaxFile = MSG_SIZ;
\r
5360 openFileName.lpstrFileTitle = fileTitle;
\r
5361 openFileName.nMaxFileTitle = fileTitle ? MSG_SIZ : 0;
\r
5362 openFileName.lpstrInitialDir = NULL;
\r
5363 openFileName.lpstrTitle = dlgTitle;
\r
5364 openFileName.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY
\r
5365 | (write[0] != 'r' ? 0 : OFN_FILEMUSTEXIST)
\r
5366 | (number ? OFN_ENABLETEMPLATE | OFN_ENABLEHOOK: 0)
\r
5367 | (oldDialog ? 0 : OFN_EXPLORER);
\r
5368 openFileName.nFileOffset = 0;
\r
5369 openFileName.nFileExtension = 0;
\r
5370 openFileName.lpstrDefExt = defExt;
\r
5371 openFileName.lCustData = (LONG) number;
\r
5372 openFileName.lpfnHook = oldDialog ?
\r
5373 (LPOFNHOOKPROC) OldOpenFileHook : (LPOFNHOOKPROC) OpenFileHook;
\r
5374 openFileName.lpTemplateName = (LPSTR)(oldDialog ? 1536 : DLG_IndexNumber);
\r
5376 if (write[0] != 'r' ? GetSaveFileName(&openFileName) :
\r
5377 GetOpenFileName(&openFileName)) {
\r
5378 /* open the file */
\r
5379 f = fopen(openFileName.lpstrFile, write);
\r
5381 MessageBox(hwnd, "File open failed", NULL,
\r
5382 MB_OK|MB_ICONEXCLAMATION);
\r
5386 int err = CommDlgExtendedError();
\r
5387 if (err != 0) DisplayError("Internal error in file dialog box", err);
\r
5396 MenuPopup(HWND hwnd, POINT pt, HMENU hmenu, UINT def)
\r
5398 HMENU hmenuTrackPopup; /* floating pop-up menu */
\r
5401 * Get the first pop-up menu in the menu template. This is the
\r
5402 * menu that TrackPopupMenu displays.
\r
5404 hmenuTrackPopup = GetSubMenu(hmenu, 0);
\r
5406 SetMenuDefaultItem(hmenuTrackPopup, def, FALSE);
\r
5409 * TrackPopup uses screen coordinates, so convert the
\r
5410 * coordinates of the mouse click to screen coordinates.
\r
5412 ClientToScreen(hwnd, (LPPOINT) &pt);
\r
5414 /* Draw and track the floating pop-up menu. */
\r
5415 TrackPopupMenu(hmenuTrackPopup, TPM_CENTERALIGN | TPM_RIGHTBUTTON,
\r
5416 pt.x, pt.y, 0, hwnd, NULL);
\r
5418 /* Destroy the menu.*/
\r
5419 DestroyMenu(hmenu);
\r
5424 int sizeX, sizeY, newSizeX, newSizeY;
\r
5426 } ResizeEditPlusButtonsClosure;
\r
5429 ResizeEditPlusButtonsCallback(HWND hChild, LPARAM lparam)
\r
5431 ResizeEditPlusButtonsClosure *cl = (ResizeEditPlusButtonsClosure *)lparam;
\r
5435 if (hChild == cl->hText) return TRUE;
\r
5436 GetWindowRect(hChild, &rect); /* gives screen coords */
\r
5437 pt.x = rect.left + (cl->newSizeX - cl->sizeX)/2;
\r
5438 pt.y = rect.top + cl->newSizeY - cl->sizeY;
\r
5439 ScreenToClient(cl->hDlg, &pt);
\r
5440 cl->hdwp = DeferWindowPos(cl->hdwp, hChild, NULL,
\r
5441 pt.x, pt.y, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER);
\r
5445 /* Resize a dialog that has a (rich) edit field filling most of
\r
5446 the top, with a row of buttons below */
\r
5448 ResizeEditPlusButtons(HWND hDlg, HWND hText, int sizeX, int sizeY, int newSizeX, int newSizeY)
\r
5451 int newTextHeight, newTextWidth;
\r
5452 ResizeEditPlusButtonsClosure cl;
\r
5454 /*if (IsIconic(hDlg)) return;*/
\r
5455 if (newSizeX == sizeX && newSizeY == sizeY) return;
\r
5457 cl.hdwp = BeginDeferWindowPos(8);
\r
5459 GetWindowRect(hText, &rectText); /* gives screen coords */
\r
5460 newTextWidth = rectText.right - rectText.left + newSizeX - sizeX;
\r
5461 newTextHeight = rectText.bottom - rectText.top + newSizeY - sizeY;
\r
5462 if (newTextHeight < 0) {
\r
5463 newSizeY += -newTextHeight;
\r
5464 newTextHeight = 0;
\r
5466 cl.hdwp = DeferWindowPos(cl.hdwp, hText, NULL, 0, 0,
\r
5467 newTextWidth, newTextHeight, SWP_NOZORDER|SWP_NOMOVE);
\r
5473 cl.newSizeX = newSizeX;
\r
5474 cl.newSizeY = newSizeY;
\r
5475 EnumChildWindows(hDlg, ResizeEditPlusButtonsCallback, (LPARAM)&cl);
\r
5477 EndDeferWindowPos(cl.hdwp);
\r
5480 BOOL CenterWindowEx(HWND hwndChild, HWND hwndParent, int mode)
\r
5482 RECT rChild, rParent;
\r
5483 int wChild, hChild, wParent, hParent;
\r
5484 int wScreen, hScreen, xNew, yNew;
\r
5487 /* Get the Height and Width of the child window */
\r
5488 GetWindowRect (hwndChild, &rChild);
\r
5489 wChild = rChild.right - rChild.left;
\r
5490 hChild = rChild.bottom - rChild.top;
\r
5492 /* Get the Height and Width of the parent window */
\r
5493 GetWindowRect (hwndParent, &rParent);
\r
5494 wParent = rParent.right - rParent.left;
\r
5495 hParent = rParent.bottom - rParent.top;
\r
5497 /* Get the display limits */
\r
5498 hdc = GetDC (hwndChild);
\r
5499 wScreen = GetDeviceCaps (hdc, HORZRES);
\r
5500 hScreen = GetDeviceCaps (hdc, VERTRES);
\r
5501 ReleaseDC(hwndChild, hdc);
\r
5503 /* Calculate new X position, then adjust for screen */
\r
5504 xNew = rParent.left + ((wParent - wChild) /2);
\r
5507 } else if ((xNew+wChild) > wScreen) {
\r
5508 xNew = wScreen - wChild;
\r
5511 /* Calculate new Y position, then adjust for screen */
\r
5513 yNew = rParent.top + ((hParent - hChild) /2);
\r
5516 yNew = rParent.top + GetSystemMetrics( SM_CYCAPTION ) * 2 / 3;
\r
5521 } else if ((yNew+hChild) > hScreen) {
\r
5522 yNew = hScreen - hChild;
\r
5525 /* Set it, and return */
\r
5526 return SetWindowPos (hwndChild, NULL,
\r
5527 xNew, yNew, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
\r
5530 /* Center one window over another */
\r
5531 BOOL CenterWindow (HWND hwndChild, HWND hwndParent)
\r
5533 return CenterWindowEx( hwndChild, hwndParent, 0 );
\r
5536 /*---------------------------------------------------------------------------*\
\r
5538 * Startup Dialog functions
\r
5540 \*---------------------------------------------------------------------------*/
\r
5542 InitComboStrings(HANDLE hwndCombo, char **cd)
\r
5544 SendMessage(hwndCombo, CB_RESETCONTENT, 0, 0);
\r
5546 while (*cd != NULL) {
\r
5547 SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM) *cd);
\r
5553 InitComboStringsFromOption(HANDLE hwndCombo, char *str)
\r
5555 char buf1[MAX_ARG_LEN];
\r
5558 if (str[0] == '@') {
\r
5559 FILE* f = fopen(str + 1, "r");
\r
5561 DisplayFatalError(str + 1, errno, 2);
\r
5564 len = fread(buf1, 1, sizeof(buf1)-1, f);
\r
5566 buf1[len] = NULLCHAR;
\r
5570 SendMessage(hwndCombo, CB_RESETCONTENT, 0, 0);
\r
5573 char buf[MSG_SIZ];
\r
5574 char *end = strchr(str, '\n');
\r
5575 if (end == NULL) return;
\r
5576 memcpy(buf, str, end - str);
\r
5577 buf[end - str] = NULLCHAR;
\r
5578 SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM) buf);
\r
5584 SetStartupDialogEnables(HWND hDlg)
\r
5586 EnableWindow(GetDlgItem(hDlg, OPT_ChessEngineName),
\r
5587 IsDlgButtonChecked(hDlg, OPT_ChessEngine) ||
\r
5588 (appData.zippyPlay && IsDlgButtonChecked(hDlg, OPT_ChessServer)));
\r
5589 EnableWindow(GetDlgItem(hDlg, OPT_SecondChessEngineName),
\r
5590 IsDlgButtonChecked(hDlg, OPT_ChessEngine));
\r
5591 EnableWindow(GetDlgItem(hDlg, OPT_ChessServerName),
\r
5592 IsDlgButtonChecked(hDlg, OPT_ChessServer));
\r
5593 EnableWindow(GetDlgItem(hDlg, OPT_AdditionalOptions),
\r
5594 IsDlgButtonChecked(hDlg, OPT_AnyAdditional));
\r
5595 EnableWindow(GetDlgItem(hDlg, IDOK),
\r
5596 IsDlgButtonChecked(hDlg, OPT_ChessEngine) ||
\r
5597 IsDlgButtonChecked(hDlg, OPT_ChessServer) ||
\r
5598 IsDlgButtonChecked(hDlg, OPT_View));
\r
5602 QuoteForFilename(char *filename)
\r
5604 int dquote, space;
\r
5605 dquote = strchr(filename, '"') != NULL;
\r
5606 space = strchr(filename, ' ') != NULL;
\r
5607 if (dquote || space) {
\r
5619 InitEngineBox(HWND hDlg, HWND hwndCombo, char* nthcp, char* nthd, char* nthdir, char *nthnames)
\r
5621 char buf[MSG_SIZ];
\r
5624 InitComboStringsFromOption(hwndCombo, nthnames);
\r
5625 q = QuoteForFilename(nthcp);
\r
5626 sprintf(buf, "%s%s%s", q, nthcp, q);
\r
5627 if (*nthdir != NULLCHAR) {
\r
5628 q = QuoteForFilename(nthdir);
\r
5629 sprintf(buf + strlen(buf), " /%s=%s%s%s", nthd, q, nthdir, q);
\r
5631 if (*nthcp == NULLCHAR) {
\r
5632 SendMessage(hwndCombo, CB_SETCURSEL, (WPARAM) 0, (LPARAM) 0);
\r
5633 } else if (SendMessage(hwndCombo, CB_SELECTSTRING, (WPARAM) -1, (LPARAM) buf) == CB_ERR) {
\r
5634 SendMessage(hwndCombo, CB_SETCURSEL, (WPARAM) -1, (LPARAM) 0);
\r
5635 SendMessage(hwndCombo, WM_SETTEXT, (WPARAM) 0, (LPARAM) buf);
\r
5640 StartupDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
5642 char buf[MSG_SIZ];
\r
5646 switch (message) {
\r
5647 case WM_INITDIALOG:
\r
5648 /* Center the dialog */
\r
5649 CenterWindow (hDlg, GetDesktopWindow());
\r
5650 /* Initialize the dialog items */
\r
5651 InitEngineBox(hDlg, GetDlgItem(hDlg, OPT_ChessEngineName),
\r
5652 appData.firstChessProgram, "fd", appData.firstDirectory,
\r
5653 firstChessProgramNames);
\r
5654 InitEngineBox(hDlg, GetDlgItem(hDlg, OPT_SecondChessEngineName),
\r
5655 appData.secondChessProgram, "sd", appData.secondDirectory,
\r
5656 secondChessProgramNames);
\r
5657 hwndCombo = GetDlgItem(hDlg, OPT_ChessServerName);
\r
5658 InitComboStringsFromOption(hwndCombo, icsNames);
\r
5659 sprintf(buf, "%s /icsport=%s", appData.icsHost, appData.icsPort);
\r
5660 if (*appData.icsHelper != NULLCHAR) {
\r
5661 char *q = QuoteForFilename(appData.icsHelper);
\r
5662 sprintf(buf + strlen(buf), " /icshelper=%s%s%s", q, appData.icsHelper, q);
\r
5664 if (*appData.icsHost == NULLCHAR) {
\r
5665 SendMessage(hwndCombo, CB_SETCURSEL, (WPARAM) 0, (LPARAM) 0);
\r
5666 /*SendMessage(hwndCombo, CB_SHOWDROPDOWN, (WPARAM) TRUE, (LPARAM) 0); !!too soon */
\r
5667 } else if (SendMessage(hwndCombo, CB_SELECTSTRING, (WPARAM) -1, (LPARAM) buf) == CB_ERR) {
\r
5668 SendMessage(hwndCombo, CB_SETCURSEL, (WPARAM) -1, (LPARAM) 0);
\r
5669 SendMessage(hwndCombo, WM_SETTEXT, (WPARAM) 0, (LPARAM) buf);
\r
5672 if (appData.icsActive) {
\r
5673 CheckDlgButton(hDlg, OPT_ChessServer, BST_CHECKED);
\r
5675 else if (appData.noChessProgram) {
\r
5676 CheckDlgButton(hDlg, OPT_View, BST_CHECKED);
\r
5679 CheckDlgButton(hDlg, OPT_ChessEngine, BST_CHECKED);
\r
5682 SetStartupDialogEnables(hDlg);
\r
5686 switch (LOWORD(wParam)) {
\r
5688 if (IsDlgButtonChecked(hDlg, OPT_ChessEngine)) {
\r
5689 strcpy(buf, "/fcp=");
\r
5690 GetDlgItemText(hDlg, OPT_ChessEngineName, buf + strlen(buf), sizeof(buf) - strlen(buf));
\r
5692 ParseArgs(StringGet, &p);
\r
5693 strcpy(buf, "/scp=");
\r
5694 GetDlgItemText(hDlg, OPT_SecondChessEngineName, buf + strlen(buf), sizeof(buf) - strlen(buf));
\r
5696 ParseArgs(StringGet, &p);
\r
5697 appData.noChessProgram = FALSE;
\r
5698 appData.icsActive = FALSE;
\r
5699 } else if (IsDlgButtonChecked(hDlg, OPT_ChessServer)) {
\r
5700 strcpy(buf, "/ics /icshost=");
\r
5701 GetDlgItemText(hDlg, OPT_ChessServerName, buf + strlen(buf), sizeof(buf) - strlen(buf));
\r
5703 ParseArgs(StringGet, &p);
\r
5704 if (appData.zippyPlay) {
\r
5705 strcpy(buf, "/fcp=");
\r
5706 GetDlgItemText(hDlg, OPT_ChessEngineName, buf + strlen(buf), sizeof(buf) - strlen(buf));
\r
5708 ParseArgs(StringGet, &p);
\r
5710 } else if (IsDlgButtonChecked(hDlg, OPT_View)) {
\r
5711 appData.noChessProgram = TRUE;
\r
5712 appData.icsActive = FALSE;
\r
5714 MessageBox(hDlg, "Choose an option, or cancel to exit",
\r
5715 "Option Error", MB_OK|MB_ICONEXCLAMATION);
\r
5718 if (IsDlgButtonChecked(hDlg, OPT_AnyAdditional)) {
\r
5719 GetDlgItemText(hDlg, OPT_AdditionalOptions, buf, sizeof(buf));
\r
5721 ParseArgs(StringGet, &p);
\r
5723 EndDialog(hDlg, TRUE);
\r
5730 case IDM_HELPCONTENTS:
\r
5731 if (!WinHelp (hDlg, "winboard.hlp", HELP_KEY,(DWORD)(LPSTR)"CONTENTS")) {
\r
5732 MessageBox (GetFocus(),
\r
5733 "Unable to activate help",
\r
5734 szAppName, MB_SYSTEMMODAL|MB_OK|MB_ICONHAND);
\r
5739 SetStartupDialogEnables(hDlg);
\r
5747 /*---------------------------------------------------------------------------*\
\r
5749 * About box dialog functions
\r
5751 \*---------------------------------------------------------------------------*/
\r
5753 /* Process messages for "About" dialog box */
\r
5755 About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
5757 switch (message) {
\r
5758 case WM_INITDIALOG: /* message: initialize dialog box */
\r
5759 /* Center the dialog over the application window */
\r
5760 CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
\r
5761 SetDlgItemText(hDlg, ABOUTBOX_Version, programVersion);
\r
5765 case WM_COMMAND: /* message: received a command */
\r
5766 if (LOWORD(wParam) == IDOK /* "OK" box selected? */
\r
5767 || LOWORD(wParam) == IDCANCEL) { /* System menu close command? */
\r
5768 EndDialog(hDlg, TRUE); /* Exit the dialog */
\r
5776 /*---------------------------------------------------------------------------*\
\r
5778 * Comment Dialog functions
\r
5780 \*---------------------------------------------------------------------------*/
\r
5783 CommentDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
5785 static HANDLE hwndText = NULL;
\r
5786 int len, newSizeX, newSizeY, flags;
\r
5787 static int sizeX, sizeY;
\r
5792 switch (message) {
\r
5793 case WM_INITDIALOG: /* message: initialize dialog box */
\r
5794 /* Initialize the dialog items */
\r
5795 hwndText = GetDlgItem(hDlg, OPT_CommentText);
\r
5796 SetDlgItemText(hDlg, OPT_CommentText, commentText);
\r
5797 EnableWindow(GetDlgItem(hDlg, OPT_CancelComment), editComment);
\r
5798 EnableWindow(GetDlgItem(hDlg, OPT_ClearComment), editComment);
\r
5799 EnableWindow(GetDlgItem(hDlg, OPT_EditComment), !editComment);
\r
5800 SendMessage(hwndText, EM_SETREADONLY, !editComment, 0);
\r
5801 SetWindowText(hDlg, commentTitle);
\r
5802 if (editComment) {
\r
5803 SetFocus(hwndText);
\r
5805 SetFocus(GetDlgItem(hDlg, IDOK));
\r
5807 SendMessage(GetDlgItem(hDlg, OPT_CommentText),
\r
5808 WM_SETFONT, (WPARAM)font[boardSize][COMMENT_FONT]->hf,
\r
5809 MAKELPARAM(FALSE, 0));
\r
5810 /* Size and position the dialog */
\r
5811 if (!commentDialog) {
\r
5812 commentDialog = hDlg;
\r
5813 flags = SWP_NOZORDER;
\r
5814 GetClientRect(hDlg, &rect);
\r
5815 sizeX = rect.right;
\r
5816 sizeY = rect.bottom;
\r
5817 if (wpComment.x != CW_USEDEFAULT && wpComment.y != CW_USEDEFAULT &&
\r
5818 wpComment.width != CW_USEDEFAULT && wpComment.height != CW_USEDEFAULT) {
\r
5819 WINDOWPLACEMENT wp;
\r
5820 EnsureOnScreen(&wpComment.x, &wpComment.y, 0, 0);
\r
5821 wp.length = sizeof(WINDOWPLACEMENT);
\r
5823 wp.showCmd = SW_SHOW;
\r
5824 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
5825 wp.rcNormalPosition.left = wpComment.x;
\r
5826 wp.rcNormalPosition.right = wpComment.x + wpComment.width;
\r
5827 wp.rcNormalPosition.top = wpComment.y;
\r
5828 wp.rcNormalPosition.bottom = wpComment.y + wpComment.height;
\r
5829 SetWindowPlacement(hDlg, &wp);
\r
5831 GetClientRect(hDlg, &rect);
\r
5832 newSizeX = rect.right;
\r
5833 newSizeY = rect.bottom;
\r
5834 ResizeEditPlusButtons(hDlg, hwndText, sizeX, sizeY,
\r
5835 newSizeX, newSizeY);
\r
5842 case WM_COMMAND: /* message: received a command */
\r
5843 switch (LOWORD(wParam)) {
\r
5845 if (editComment) {
\r
5847 /* Read changed options from the dialog box */
\r
5848 hwndText = GetDlgItem(hDlg, OPT_CommentText);
\r
5849 len = GetWindowTextLength(hwndText);
\r
5850 str = (char *) malloc(len + 1);
\r
5851 GetWindowText(hwndText, str, len + 1);
\r
5860 ReplaceComment(commentIndex, str);
\r
5867 case OPT_CancelComment:
\r
5871 case OPT_ClearComment:
\r
5872 SetDlgItemText(hDlg, OPT_CommentText, "");
\r
5875 case OPT_EditComment:
\r
5876 EditCommentEvent();
\r
5885 newSizeX = LOWORD(lParam);
\r
5886 newSizeY = HIWORD(lParam);
\r
5887 ResizeEditPlusButtons(hDlg, hwndText, sizeX, sizeY, newSizeX, newSizeY);
\r
5892 case WM_GETMINMAXINFO:
\r
5893 /* Prevent resizing window too small */
\r
5894 mmi = (MINMAXINFO *) lParam;
\r
5895 mmi->ptMinTrackSize.x = 100;
\r
5896 mmi->ptMinTrackSize.y = 100;
\r
5903 EitherCommentPopUp(int index, char *title, char *str, BOOLEAN edit)
\r
5908 CheckMenuItem(GetMenu(hwndMain), IDM_EditComment, edit ? MF_CHECKED : MF_UNCHECKED);
\r
5910 if (str == NULL) str = "";
\r
5911 p = (char *) malloc(2 * strlen(str) + 2);
\r
5914 if (*str == '\n') *q++ = '\r';
\r
5918 if (commentText != NULL) free(commentText);
\r
5920 commentIndex = index;
\r
5921 commentTitle = title;
\r
5923 editComment = edit;
\r
5925 if (commentDialog) {
\r
5926 SendMessage(commentDialog, WM_INITDIALOG, 0, 0);
\r
5927 if (!commentUp) ShowWindow(commentDialog, SW_SHOW);
\r
5929 lpProc = MakeProcInstance((FARPROC)CommentDialog, hInst);
\r
5930 CreateDialog(hInst, MAKEINTRESOURCE(DLG_EditComment),
\r
5931 hwndMain, (DLGPROC)lpProc);
\r
5932 FreeProcInstance(lpProc);
\r
5938 /*---------------------------------------------------------------------------*\
\r
5940 * Type-in move dialog functions
\r
5942 \*---------------------------------------------------------------------------*/
\r
5945 TypeInMoveDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
5947 char move[MSG_SIZ];
\r
5949 ChessMove moveType;
\r
5950 int fromX, fromY, toX, toY;
\r
5953 switch (message) {
\r
5954 case WM_INITDIALOG:
\r
5955 move[0] = (char) lParam;
\r
5956 move[1] = NULLCHAR;
\r
5957 CenterWindowEx(hDlg, GetWindow(hDlg, GW_OWNER), 1 );
\r
5958 hInput = GetDlgItem(hDlg, OPT_Move);
\r
5959 SetWindowText(hInput, move);
\r
5961 SendMessage(hInput, EM_SETSEL, (WPARAM)9999, (LPARAM)9999);
\r
5965 switch (LOWORD(wParam)) {
\r
5967 GetDlgItemText(hDlg, OPT_Move, move, sizeof(move));
\r
5968 { int n; Board board;
\r
5970 if(gameMode == EditPosition && ParseFEN(board, &n, move) ) {
\r
5971 EditPositionPasteFEN(move);
\r
5972 EndDialog(hDlg, TRUE);
\r
5975 // [HGM] movenum: allow move number to be typed in any mode
\r
5976 if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
\r
5978 EndDialog(hDlg, TRUE);
\r
5982 if (gameMode != EditGame && currentMove != forwardMostMove &&
\r
5983 gameMode != Training) {
\r
5984 DisplayMoveError("Displayed move is not current");
\r
5986 // GetDlgItemText(hDlg, OPT_Move, move, sizeof(move)); // moved upstream
\r
5987 int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
\r
5988 &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
\r
5989 if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
\r
5990 if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
\r
5991 &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
\r
5992 if (gameMode != Training)
\r
5993 forwardMostMove = currentMove;
\r
5994 UserMoveEvent(fromX, fromY, toX, toY, promoChar);
\r
5996 DisplayMoveError("Could not parse move");
\r
5999 EndDialog(hDlg, TRUE);
\r
6002 EndDialog(hDlg, FALSE);
\r
6013 PopUpMoveDialog(char firstchar)
\r
6017 if ((gameMode == BeginningOfGame && !appData.icsActive) ||
\r
6018 gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
\r
6019 gameMode == AnalyzeMode || gameMode == EditGame ||
\r
6020 gameMode == EditPosition || gameMode == IcsExamining ||
\r
6021 gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
\r
6022 isdigit(firstchar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
\r
6023 ( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
\r
6024 gameMode == IcsObserving || gameMode == TwoMachinesPlay ) ||
\r
6025 gameMode == Training) {
\r
6026 lpProc = MakeProcInstance((FARPROC)TypeInMoveDialog, hInst);
\r
6027 DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_TypeInMove),
\r
6028 hwndMain, (DLGPROC)lpProc, (LPARAM)firstchar);
\r
6029 FreeProcInstance(lpProc);
\r
6033 /*---------------------------------------------------------------------------*\
\r
6035 * Type-in name dialog functions
\r
6037 \*---------------------------------------------------------------------------*/
\r
6040 TypeInNameDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
6042 char move[MSG_SIZ];
\r
6045 switch (message) {
\r
6046 case WM_INITDIALOG:
\r
6047 move[0] = (char) lParam;
\r
6048 move[1] = NULLCHAR;
\r
6049 CenterWindowEx(hDlg, GetWindow(hDlg, GW_OWNER), 1 );
\r
6050 hInput = GetDlgItem(hDlg, OPT_Name);
\r
6051 SetWindowText(hInput, move);
\r
6053 SendMessage(hInput, EM_SETSEL, (WPARAM)9999, (LPARAM)9999);
\r
6057 switch (LOWORD(wParam)) {
\r
6059 GetDlgItemText(hDlg, OPT_Name, move, sizeof(move));
\r
6060 appData.userName = strdup(move);
\r
6063 EndDialog(hDlg, TRUE);
\r
6066 EndDialog(hDlg, FALSE);
\r
6077 PopUpNameDialog(char firstchar)
\r
6081 lpProc = MakeProcInstance((FARPROC)TypeInNameDialog, hInst);
\r
6082 DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_TypeInName),
\r
6083 hwndMain, (DLGPROC)lpProc, (LPARAM)firstchar);
\r
6084 FreeProcInstance(lpProc);
\r
6087 /*---------------------------------------------------------------------------*\
\r
6091 \*---------------------------------------------------------------------------*/
\r
6093 /* Nonmodal error box */
\r
6094 LRESULT CALLBACK ErrorDialog(HWND hDlg, UINT message,
\r
6095 WPARAM wParam, LPARAM lParam);
\r
6098 ErrorPopUp(char *title, char *content)
\r
6102 BOOLEAN modal = hwndMain == NULL;
\r
6120 strncpy(errorTitle, title, sizeof(errorTitle));
\r
6121 errorTitle[sizeof(errorTitle) - 1] = '\0';
\r
6124 MessageBox(NULL, errorMessage, errorTitle, MB_OK|MB_ICONEXCLAMATION);
\r
6126 lpProc = MakeProcInstance((FARPROC)ErrorDialog, hInst);
\r
6127 CreateDialog(hInst, MAKEINTRESOURCE(DLG_Error),
\r
6128 hwndMain, (DLGPROC)lpProc);
\r
6129 FreeProcInstance(lpProc);
\r
6136 if (!appData.popupMoveErrors && moveErrorMessageUp) DisplayMessage("", "");
\r
6137 if (errorDialog == NULL) return;
\r
6138 DestroyWindow(errorDialog);
\r
6139 errorDialog = NULL;
\r
6140 if(errorExitStatus) ExitEvent(errorExitStatus);
\r
6144 ErrorDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
6149 switch (message) {
\r
6150 case WM_INITDIALOG:
\r
6151 GetWindowRect(hDlg, &rChild);
\r
6154 SetWindowPos(hDlg, NULL, rChild.left,
\r
6155 rChild.top + boardRect.top - (rChild.bottom - rChild.top),
\r
6156 0, 0, SWP_NOZORDER|SWP_NOSIZE);
\r
6160 [AS] It seems that the above code wants to move the dialog up in the "caption
\r
6161 area" of the main window, but it uses the dialog height as an hard-coded constant,
\r
6162 and it doesn't work when you resize the dialog.
\r
6163 For now, just give it a default position.
\r
6165 SetWindowPos(hDlg, NULL, boardRect.left+8, boardRect.top+8, 0, 0, SWP_NOZORDER|SWP_NOSIZE);
\r
6167 errorDialog = hDlg;
\r
6168 SetWindowText(hDlg, errorTitle);
\r
6169 hwndText = GetDlgItem(hDlg, OPT_ErrorText);
\r
6170 SetDlgItemText(hDlg, OPT_ErrorText, errorMessage);
\r
6174 switch (LOWORD(wParam)) {
\r
6177 if (errorDialog == hDlg) errorDialog = NULL;
\r
6178 DestroyWindow(hDlg);
\r
6190 HWND gothicDialog = NULL;
\r
6193 GothicDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
6197 int height = GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYFRAME);
\r
6199 switch (message) {
\r
6200 case WM_INITDIALOG:
\r
6201 GetWindowRect(hDlg, &rChild);
\r
6203 SetWindowPos(hDlg, NULL, wpMain.x, wpMain.y-height, wpMain.width, height,
\r
6207 [AS] It seems that the above code wants to move the dialog up in the "caption
\r
6208 area" of the main window, but it uses the dialog height as an hard-coded constant,
\r
6209 and it doesn't work when you resize the dialog.
\r
6210 For now, just give it a default position.
\r
6212 gothicDialog = hDlg;
\r
6213 SetWindowText(hDlg, errorTitle);
\r
6214 hwndText = GetDlgItem(hDlg, OPT_ErrorText);
\r
6215 SetDlgItemText(hDlg, OPT_ErrorText, errorMessage);
\r
6219 switch (LOWORD(wParam)) {
\r
6222 if (errorDialog == hDlg) errorDialog = NULL;
\r
6223 DestroyWindow(hDlg);
\r
6235 GothicPopUp(char *title, VariantClass variant)
\r
6238 static char *lastTitle;
\r
6240 strncpy(errorTitle, title, sizeof(errorTitle));
\r
6241 errorTitle[sizeof(errorTitle) - 1] = '\0';
\r
6243 if(lastTitle != title && gothicDialog != NULL) {
\r
6244 DestroyWindow(gothicDialog);
\r
6245 gothicDialog = NULL;
\r
6247 if(variant != VariantNormal && gothicDialog == NULL) {
\r
6248 title = lastTitle;
\r
6249 lpProc = MakeProcInstance((FARPROC)GothicDialog, hInst);
\r
6250 CreateDialog(hInst, MAKEINTRESOURCE(DLG_Error),
\r
6251 hwndMain, (DLGPROC)lpProc);
\r
6252 FreeProcInstance(lpProc);
\r
6257 /*---------------------------------------------------------------------------*\
\r
6259 * Ics Interaction console functions
\r
6261 \*---------------------------------------------------------------------------*/
\r
6263 #define HISTORY_SIZE 64
\r
6264 static char *history[HISTORY_SIZE];
\r
6265 int histIn = 0, histP = 0;
\r
6268 SaveInHistory(char *cmd)
\r
6270 if (history[histIn] != NULL) {
\r
6271 free(history[histIn]);
\r
6272 history[histIn] = NULL;
\r
6274 if (*cmd == NULLCHAR) return;
\r
6275 history[histIn] = StrSave(cmd);
\r
6276 histIn = (histIn + 1) % HISTORY_SIZE;
\r
6277 if (history[histIn] != NULL) {
\r
6278 free(history[histIn]);
\r
6279 history[histIn] = NULL;
\r
6285 PrevInHistory(char *cmd)
\r
6288 if (histP == histIn) {
\r
6289 if (history[histIn] != NULL) free(history[histIn]);
\r
6290 history[histIn] = StrSave(cmd);
\r
6292 newhp = (histP - 1 + HISTORY_SIZE) % HISTORY_SIZE;
\r
6293 if (newhp == histIn || history[newhp] == NULL) return NULL;
\r
6295 return history[histP];
\r
6301 if (histP == histIn) return NULL;
\r
6302 histP = (histP + 1) % HISTORY_SIZE;
\r
6303 return history[histP];
\r
6307 LoadIcsTextMenu(IcsTextMenuEntry *e)
\r
6311 hmenu = LoadMenu(hInst, "TextMenu");
\r
6312 h = GetSubMenu(hmenu, 0);
\r
6314 if (strcmp(e->item, "-") == 0) {
\r
6315 AppendMenu(h, MF_SEPARATOR, 0, 0);
\r
6317 if (e->item[0] == '|') {
\r
6318 AppendMenu(h, MF_STRING|MF_MENUBARBREAK,
\r
6319 IDM_CommandX + i, &e->item[1]);
\r
6321 AppendMenu(h, MF_STRING, IDM_CommandX + i, e->item);
\r
6330 WNDPROC consoleTextWindowProc;
\r
6333 CommandX(HWND hwnd, char *command, BOOLEAN getname, BOOLEAN immediate)
\r
6335 char buf[MSG_SIZ], name[MSG_SIZ];
\r
6336 HWND hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6340 SetWindowText(hInput, command);
\r
6342 SendMessage(hInput, WM_CHAR, '\r', 0);
\r
6344 sel.cpMin = 999999;
\r
6345 sel.cpMax = 999999;
\r
6346 SendMessage(hInput, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6351 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6352 if (sel.cpMin == sel.cpMax) {
\r
6353 /* Expand to surrounding word */
\r
6356 tr.chrg.cpMax = sel.cpMin;
\r
6357 tr.chrg.cpMin = --sel.cpMin;
\r
6358 if (sel.cpMin < 0) break;
\r
6359 tr.lpstrText = name;
\r
6360 SendMessage(hwnd, EM_GETTEXTRANGE, 0, (LPARAM) &tr);
\r
6361 } while (isalpha(name[0]) || isdigit(name[0]) || name[0] == '-');
\r
6365 tr.chrg.cpMin = sel.cpMax;
\r
6366 tr.chrg.cpMax = ++sel.cpMax;
\r
6367 tr.lpstrText = name;
\r
6368 if (SendMessage(hwnd, EM_GETTEXTRANGE, 0, (LPARAM) &tr) < 1) break;
\r
6369 } while (isalpha(name[0]) || isdigit(name[0]) || name[0] == '-');
\r
6372 if (sel.cpMax == sel.cpMin || sel.cpMax - sel.cpMin > MSG_SIZ/2) {
\r
6373 MessageBeep(MB_ICONEXCLAMATION);
\r
6377 tr.lpstrText = name;
\r
6378 SendMessage(hwnd, EM_GETTEXTRANGE, 0, (LPARAM) &tr);
\r
6380 if (sel.cpMax - sel.cpMin > MSG_SIZ/2) {
\r
6381 MessageBeep(MB_ICONEXCLAMATION);
\r
6384 SendMessage(hwnd, EM_GETSELTEXT, 0, (LPARAM) name);
\r
6387 sprintf(buf, "%s %s", command, name);
\r
6388 SetWindowText(hInput, buf);
\r
6389 SendMessage(hInput, WM_CHAR, '\r', 0);
\r
6391 sprintf(buf, "%s %s ", command, name); /* trailing space */
\r
6392 SetWindowText(hInput, buf);
\r
6393 sel.cpMin = 999999;
\r
6394 sel.cpMax = 999999;
\r
6395 SendMessage(hInput, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6401 ConsoleTextSubclass(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
6406 switch (message) {
\r
6408 if (!(GetKeyState(VK_CONTROL) & ~1)) break;
\r
6411 SendMessage(hwnd, EM_LINESCROLL, 0, -999999);
\r
6414 sel.cpMin = 999999;
\r
6415 sel.cpMax = 999999;
\r
6416 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6417 SendMessage(hwnd, EM_SCROLLCARET, 0, 0);
\r
6422 if(wParam != '\022') {
\r
6423 if (wParam == '\t') {
\r
6424 if (GetKeyState(VK_SHIFT) < 0) {
\r
6426 if (IsIconic(hwndMain)) ShowWindow(hwndMain, SW_RESTORE);
\r
6427 if (buttonDesc[0].hwnd) {
\r
6428 SetFocus(buttonDesc[0].hwnd);
\r
6430 SetFocus(hwndMain);
\r
6434 SetFocus(GetDlgItem(hwndConsole, OPT_ConsoleInput));
\r
6437 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6438 JAWS_DELETE( SetFocus(hInput); )
\r
6439 SendMessage(hInput, message, wParam, lParam);
\r
6442 } // [HGM] navigate: for Ctrl+R, flow into nex case (moved up here) to summon up menu
\r
6443 case WM_RBUTTONUP:
\r
6444 if (GetKeyState(VK_SHIFT) & ~1) {
\r
6445 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6446 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6449 HMENU hmenu = LoadIcsTextMenu(icsTextMenuEntry);
\r
6450 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6451 if (sel.cpMin == sel.cpMax) {
\r
6452 EnableMenuItem(hmenu, IDM_Copy, MF_BYCOMMAND|MF_GRAYED);
\r
6453 EnableMenuItem(hmenu, IDM_QuickPaste, MF_BYCOMMAND|MF_GRAYED);
\r
6455 if (!IsClipboardFormatAvailable(CF_TEXT)) {
\r
6456 EnableMenuItem(hmenu, IDM_Paste, MF_BYCOMMAND|MF_GRAYED);
\r
6458 pt.x = LOWORD(lParam);
\r
6459 pt.y = HIWORD(lParam);
\r
6460 MenuPopup(hwnd, pt, hmenu, -1);
\r
6464 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6466 return SendMessage(hInput, message, wParam, lParam);
\r
6467 case WM_MBUTTONDOWN:
\r
6468 return SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6469 case WM_RBUTTONDOWN:
\r
6470 if (!(GetKeyState(VK_SHIFT) & ~1)) {
\r
6471 /* Move selection here if it was empty */
\r
6473 pt.x = LOWORD(lParam);
\r
6474 pt.y = HIWORD(lParam);
\r
6475 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6476 if (sel.cpMin == sel.cpMax) {
\r
6477 sel.cpMin = SendMessage(hwnd, EM_CHARFROMPOS, 0, (LPARAM)&pt); /*doc is wrong*/
\r
6478 sel.cpMax = sel.cpMin;
\r
6479 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6481 SendMessage(hwnd, EM_HIDESELECTION, FALSE, FALSE);
\r
6485 switch (LOWORD(wParam)) {
\r
6486 case IDM_QuickPaste:
\r
6488 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6489 if (sel.cpMin == sel.cpMax) {
\r
6490 MessageBeep(MB_ICONEXCLAMATION);
\r
6493 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6494 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6495 SendMessage(hInput, WM_PASTE, 0, 0);
\r
6500 SendMessage(hwnd, WM_CUT, 0, 0);
\r
6503 SendMessage(hwnd, WM_PASTE, 0, 0);
\r
6506 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6510 int i = LOWORD(wParam) - IDM_CommandX;
\r
6511 if (i >= 0 && i < ICS_TEXT_MENU_SIZE &&
\r
6512 icsTextMenuEntry[i].command != NULL) {
\r
6513 CommandX(hwnd, icsTextMenuEntry[i].command,
\r
6514 icsTextMenuEntry[i].getname,
\r
6515 icsTextMenuEntry[i].immediate);
\r
6523 return (*consoleTextWindowProc)(hwnd, message, wParam, lParam);
\r
6526 WNDPROC consoleInputWindowProc;
\r
6529 ConsoleInputSubclass(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
6531 char buf[MSG_SIZ];
\r
6533 static BOOL sendNextChar = FALSE;
\r
6534 static BOOL quoteNextChar = FALSE;
\r
6535 InputSource *is = consoleInputSource;
\r
6539 switch (message) {
\r
6541 if (!appData.localLineEditing || sendNextChar) {
\r
6542 is->buf[0] = (CHAR) wParam;
\r
6544 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
6545 sendNextChar = FALSE;
\r
6548 if (quoteNextChar) {
\r
6549 buf[0] = (char) wParam;
\r
6550 buf[1] = NULLCHAR;
\r
6551 SendMessage(hwnd, EM_REPLACESEL, TRUE, (LPARAM) buf);
\r
6552 quoteNextChar = FALSE;
\r
6556 case '\r': /* Enter key */
\r
6557 is->count = GetWindowText(hwnd, is->buf, INPUT_SOURCE_BUF_SIZE-1);
\r
6558 if (consoleEcho) SaveInHistory(is->buf);
\r
6559 is->buf[is->count++] = '\n';
\r
6560 is->buf[is->count] = NULLCHAR;
\r
6561 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
6562 if (consoleEcho) {
\r
6563 ConsoleOutput(is->buf, is->count, TRUE);
\r
6564 } else if (appData.localLineEditing) {
\r
6565 ConsoleOutput("\n", 1, TRUE);
\r
6568 case '\033': /* Escape key */
\r
6569 SetWindowText(hwnd, "");
\r
6570 cf.cbSize = sizeof(CHARFORMAT);
\r
6571 cf.dwMask = CFM_COLOR|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT;
\r
6572 if (consoleEcho) {
\r
6573 cf.crTextColor = textAttribs[ColorNormal].color;
\r
6575 cf.crTextColor = COLOR_ECHOOFF;
\r
6577 cf.dwEffects = textAttribs[ColorNormal].effects;
\r
6578 SendMessage(hwnd, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
\r
6580 case '\t': /* Tab key */
\r
6581 if (GetKeyState(VK_SHIFT) < 0) {
\r
6583 SetFocus(GetDlgItem(hwndConsole, OPT_ConsoleText));
\r
6586 if (IsIconic(hwndMain)) ShowWindow(hwndMain, SW_RESTORE);
\r
6587 if (buttonDesc[0].hwnd) {
\r
6588 SetFocus(buttonDesc[0].hwnd);
\r
6590 SetFocus(hwndMain);
\r
6594 case '\023': /* Ctrl+S */
\r
6595 sendNextChar = TRUE;
\r
6597 case '\021': /* Ctrl+Q */
\r
6598 quoteNextChar = TRUE;
\r
6608 GetWindowText(hwnd, buf, MSG_SIZ);
\r
6609 p = PrevInHistory(buf);
\r
6611 SetWindowText(hwnd, p);
\r
6612 sel.cpMin = 999999;
\r
6613 sel.cpMax = 999999;
\r
6614 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6619 p = NextInHistory();
\r
6621 SetWindowText(hwnd, p);
\r
6622 sel.cpMin = 999999;
\r
6623 sel.cpMax = 999999;
\r
6624 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6630 if (!(GetKeyState(VK_CONTROL) & ~1)) break;
\r
6634 SendDlgItemMessage(hwndConsole, OPT_ConsoleText, message, wParam, lParam);
\r
6638 case WM_MBUTTONDOWN:
\r
6639 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6640 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6642 case WM_RBUTTONUP:
\r
6643 if (GetKeyState(VK_SHIFT) & ~1) {
\r
6644 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6645 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6649 hmenu = LoadMenu(hInst, "InputMenu");
\r
6650 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6651 if (sel.cpMin == sel.cpMax) {
\r
6652 EnableMenuItem(hmenu, IDM_Copy, MF_BYCOMMAND|MF_GRAYED);
\r
6653 EnableMenuItem(hmenu, IDM_Cut, MF_BYCOMMAND|MF_GRAYED);
\r
6655 if (!IsClipboardFormatAvailable(CF_TEXT)) {
\r
6656 EnableMenuItem(hmenu, IDM_Paste, MF_BYCOMMAND|MF_GRAYED);
\r
6658 pt.x = LOWORD(lParam);
\r
6659 pt.y = HIWORD(lParam);
\r
6660 MenuPopup(hwnd, pt, hmenu, -1);
\r
6664 switch (LOWORD(wParam)) {
\r
6666 SendMessage(hwnd, EM_UNDO, 0, 0);
\r
6668 case IDM_SelectAll:
\r
6670 sel.cpMax = -1; /*999999?*/
\r
6671 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6674 SendMessage(hwnd, WM_CUT, 0, 0);
\r
6677 SendMessage(hwnd, WM_PASTE, 0, 0);
\r
6680 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6685 return (*consoleInputWindowProc)(hwnd, message, wParam, lParam);
\r
6688 #define CO_MAX 100000
\r
6689 #define CO_TRIM 1000
\r
6692 ConsoleWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
6694 static SnapData sd;
\r
6695 HWND hText, hInput;
\r
6697 static int sizeX, sizeY;
\r
6698 int newSizeX, newSizeY;
\r
6702 hText = GetDlgItem(hDlg, OPT_ConsoleText);
\r
6703 hInput = GetDlgItem(hDlg, OPT_ConsoleInput);
\r
6705 switch (message) {
\r
6707 if (((NMHDR*)lParam)->code == EN_LINK)
\r
6709 ENLINK *pLink = (ENLINK*)lParam;
\r
6710 if (pLink->msg == WM_LBUTTONUP)
\r
6714 tr.chrg = pLink->chrg;
\r
6715 tr.lpstrText = malloc(1+tr.chrg.cpMax-tr.chrg.cpMin);
\r
6716 SendMessage(hText, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
\r
6717 ShellExecute(NULL, "open", tr.lpstrText, NULL, NULL, SW_SHOW);
\r
6718 free(tr.lpstrText);
\r
6722 case WM_INITDIALOG: /* message: initialize dialog box */
\r
6723 hwndConsole = hDlg;
\r
6725 consoleTextWindowProc = (WNDPROC)
\r
6726 SetWindowLong(hText, GWL_WNDPROC, (LONG) ConsoleTextSubclass);
\r
6727 SendMessage(hText, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
6728 consoleInputWindowProc = (WNDPROC)
\r
6729 SetWindowLong(hInput, GWL_WNDPROC, (LONG) ConsoleInputSubclass);
\r
6730 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
6731 Colorize(ColorNormal, TRUE);
\r
6732 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM) &consoleCF);
\r
6733 ChangedConsoleFont();
\r
6734 GetClientRect(hDlg, &rect);
\r
6735 sizeX = rect.right;
\r
6736 sizeY = rect.bottom;
\r
6737 if (wpConsole.x != CW_USEDEFAULT && wpConsole.y != CW_USEDEFAULT &&
\r
6738 wpConsole.width != CW_USEDEFAULT && wpConsole.height != CW_USEDEFAULT) {
\r
6739 WINDOWPLACEMENT wp;
\r
6740 EnsureOnScreen(&wpConsole.x, &wpConsole.y, 0, 0);
\r
6741 wp.length = sizeof(WINDOWPLACEMENT);
\r
6743 wp.showCmd = SW_SHOW;
\r
6744 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
6745 wp.rcNormalPosition.left = wpConsole.x;
\r
6746 wp.rcNormalPosition.right = wpConsole.x + wpConsole.width;
\r
6747 wp.rcNormalPosition.top = wpConsole.y;
\r
6748 wp.rcNormalPosition.bottom = wpConsole.y + wpConsole.height;
\r
6749 SetWindowPlacement(hDlg, &wp);
\r
6752 // [HGM] Chessknight's change 2004-07-13
\r
6753 else { /* Determine Defaults */
\r
6754 WINDOWPLACEMENT wp;
\r
6755 wpConsole.x = wpMain.width + 1;
\r
6756 wpConsole.y = wpMain.y;
\r
6757 wpConsole.width = screenWidth - wpMain.width;
\r
6758 wpConsole.height = wpMain.height;
\r
6759 EnsureOnScreen(&wpConsole.x, &wpConsole.y, 0, 0);
\r
6760 wp.length = sizeof(WINDOWPLACEMENT);
\r
6762 wp.showCmd = SW_SHOW;
\r
6763 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
6764 wp.rcNormalPosition.left = wpConsole.x;
\r
6765 wp.rcNormalPosition.right = wpConsole.x + wpConsole.width;
\r
6766 wp.rcNormalPosition.top = wpConsole.y;
\r
6767 wp.rcNormalPosition.bottom = wpConsole.y + wpConsole.height;
\r
6768 SetWindowPlacement(hDlg, &wp);
\r
6771 // Allow hText to highlight URLs and send notifications on them
\r
6772 wMask = (WORD) SendMessage(hText, EM_GETEVENTMASK, 0, 0L);
\r
6773 SendMessage(hText, EM_SETEVENTMASK, 0, wMask | ENM_LINK);
\r
6774 SendMessage(hText, EM_AUTOURLDETECT, TRUE, 0L);
\r
6775 SetWindowLong(hText, GWL_USERDATA, 79); // initialize the text window's width
\r
6789 if (IsIconic(hDlg)) break;
\r
6790 newSizeX = LOWORD(lParam);
\r
6791 newSizeY = HIWORD(lParam);
\r
6792 if (sizeX != newSizeX || sizeY != newSizeY) {
\r
6793 RECT rectText, rectInput;
\r
6795 int newTextHeight, newTextWidth;
\r
6796 GetWindowRect(hText, &rectText);
\r
6797 newTextWidth = rectText.right - rectText.left + newSizeX - sizeX;
\r
6798 newTextHeight = rectText.bottom - rectText.top + newSizeY - sizeY;
\r
6799 if (newTextHeight < 0) {
\r
6800 newSizeY += -newTextHeight;
\r
6801 newTextHeight = 0;
\r
6803 SetWindowPos(hText, NULL, 0, 0,
\r
6804 newTextWidth, newTextHeight, SWP_NOZORDER|SWP_NOMOVE);
\r
6805 GetWindowRect(hInput, &rectInput); /* gives screen coords */
\r
6806 pt.x = rectInput.left;
\r
6807 pt.y = rectInput.top + newSizeY - sizeY;
\r
6808 ScreenToClient(hDlg, &pt);
\r
6809 SetWindowPos(hInput, NULL,
\r
6810 pt.x, pt.y, /* needs client coords */
\r
6811 rectInput.right - rectInput.left + newSizeX - sizeX,
\r
6812 rectInput.bottom - rectInput.top, SWP_NOZORDER);
\r
6818 case WM_GETMINMAXINFO:
\r
6819 /* Prevent resizing window too small */
\r
6820 mmi = (MINMAXINFO *) lParam;
\r
6821 mmi->ptMinTrackSize.x = 100;
\r
6822 mmi->ptMinTrackSize.y = 100;
\r
6825 /* [AS] Snapping */
\r
6826 case WM_ENTERSIZEMOVE:
\r
6827 return OnEnterSizeMove( &sd, hDlg, wParam, lParam );
\r
6830 return OnSizing( &sd, hDlg, wParam, lParam );
\r
6833 return OnMoving( &sd, hDlg, wParam, lParam );
\r
6835 case WM_EXITSIZEMOVE:
\r
6836 UpdateICSWidth(hText);
\r
6837 return OnExitSizeMove( &sd, hDlg, wParam, lParam );
\r
6840 return DefWindowProc(hDlg, message, wParam, lParam);
\r
6848 if (hwndConsole) return;
\r
6849 hCons = CreateDialog(hInst, szConsoleName, 0, NULL);
\r
6850 SendMessage(hCons, WM_INITDIALOG, 0, 0);
\r
6855 ConsoleOutput(char* data, int length, int forceVisible)
\r
6860 char buf[CO_MAX+1];
\r
6863 static int delayLF = 0;
\r
6864 CHARRANGE savesel, sel;
\r
6866 if (hwndConsole == NULL || length > CO_MAX-100 || length == 0) return;
\r
6874 while (length--) {
\r
6882 } else if (*p == '\007') {
\r
6883 MyPlaySound(&sounds[(int)SoundBell]);
\r
6890 hText = GetDlgItem(hwndConsole, OPT_ConsoleText);
\r
6891 SendMessage(hText, EM_HIDESELECTION, TRUE, FALSE);
\r
6892 /* Save current selection */
\r
6893 SendMessage(hText, EM_EXGETSEL, 0, (LPARAM)&savesel);
\r
6894 exlen = GetWindowTextLength(hText);
\r
6895 /* Find out whether current end of text is visible */
\r
6896 SendMessage(hText, EM_GETRECT, 0, (LPARAM) &rect);
\r
6897 SendMessage(hText, EM_POSFROMCHAR, (WPARAM) &pEnd, exlen);
\r
6898 /* Trim existing text if it's too long */
\r
6899 if (exlen + (q - buf) > CO_MAX) {
\r
6900 trim = (CO_TRIM > (q - buf)) ? CO_TRIM : (q - buf);
\r
6903 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6904 SendMessage(hText, EM_REPLACESEL, 0, (LPARAM)"");
\r
6906 savesel.cpMin -= trim;
\r
6907 savesel.cpMax -= trim;
\r
6908 if (exlen < 0) exlen = 0;
\r
6909 if (savesel.cpMin < 0) savesel.cpMin = 0;
\r
6910 if (savesel.cpMax < savesel.cpMin) savesel.cpMax = savesel.cpMin;
\r
6912 /* Append the new text */
\r
6913 sel.cpMin = exlen;
\r
6914 sel.cpMax = exlen;
\r
6915 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6916 SendMessage(hText, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&consoleCF);
\r
6917 SendMessage(hText, EM_REPLACESEL, 0, (LPARAM) buf);
\r
6918 if (forceVisible || exlen == 0 ||
\r
6919 (rect.left <= pEnd.x && pEnd.x < rect.right &&
\r
6920 rect.top <= pEnd.y && pEnd.y < rect.bottom)) {
\r
6921 /* Scroll to make new end of text visible if old end of text
\r
6922 was visible or new text is an echo of user typein */
\r
6923 sel.cpMin = 9999999;
\r
6924 sel.cpMax = 9999999;
\r
6925 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6926 SendMessage(hText, EM_HIDESELECTION, FALSE, FALSE);
\r
6927 SendMessage(hText, EM_SCROLLCARET, 0, 0);
\r
6928 SendMessage(hText, EM_HIDESELECTION, TRUE, FALSE);
\r
6930 if (savesel.cpMax == exlen || forceVisible) {
\r
6931 /* Move insert point to new end of text if it was at the old
\r
6932 end of text or if the new text is an echo of user typein */
\r
6933 sel.cpMin = 9999999;
\r
6934 sel.cpMax = 9999999;
\r
6935 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6937 /* Restore previous selection */
\r
6938 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&savesel);
\r
6940 SendMessage(hText, EM_HIDESELECTION, FALSE, FALSE);
\r
6947 DisplayHoldingsCount(HDC hdc, int x, int y, int rightAlign, int copyNumber)
\r
6951 COLORREF oldFg, oldBg;
\r
6955 if(copyNumber > 1) sprintf(buf, "%d", copyNumber); else buf[0] = 0;
\r
6957 oldFg = SetTextColor(hdc, RGB(255, 255, 255)); /* white */
\r
6958 oldBg = SetBkColor(hdc, RGB(0, 0, 0)); /* black */
\r
6959 oldFont = SelectObject(hdc, font[boardSize][CLOCK_FONT]->hf);
\r
6962 rect.right = x + squareSize;
\r
6964 rect.bottom = y + squareSize;
\r
6967 ExtTextOut(hdc, x + MESSAGE_LINE_LEFTMARGIN
\r
6968 + (rightAlign ? (squareSize*2)/3 : 0),
\r
6969 y, ETO_CLIPPED|ETO_OPAQUE,
\r
6970 &rect, str, strlen(str), NULL);
\r
6972 (void) SetTextColor(hdc, oldFg);
\r
6973 (void) SetBkColor(hdc, oldBg);
\r
6974 (void) SelectObject(hdc, oldFont);
\r
6978 DisplayAClock(HDC hdc, int timeRemaining, int highlight,
\r
6979 RECT *rect, char *color, char *flagFell)
\r
6983 COLORREF oldFg, oldBg;
\r
6986 if (appData.clockMode) {
\r
6988 sprintf(buf, "%c %s %s", color[0], TimeString(timeRemaining), flagFell);
\r
6990 sprintf(buf, "%s:%c%s %s", color, (logoHeight>0 ? 0 : ' '), TimeString(timeRemaining), flagFell);
\r
6997 oldFg = SetTextColor(hdc, RGB(255, 255, 255)); /* white */
\r
6998 oldBg = SetBkColor(hdc, RGB(0, 0, 0)); /* black */
\r
7000 oldFg = SetTextColor(hdc, RGB(0, 0, 0)); /* black */
\r
7001 oldBg = SetBkColor(hdc, RGB(255, 255, 255)); /* white */
\r
7003 oldFont = SelectObject(hdc, font[boardSize][CLOCK_FONT]->hf);
\r
7007 ExtTextOut(hdc, rect->left + MESSAGE_LINE_LEFTMARGIN,
\r
7008 rect->top, ETO_CLIPPED|ETO_OPAQUE,
\r
7009 rect, str, strlen(str), NULL);
\r
7010 if(logoHeight > 0 && appData.clockMode) {
\r
7012 sprintf(buf, "%s %s", buf+7, flagFell);
\r
7013 r.top = rect->top + logoHeight/2;
\r
7014 r.left = rect->left;
\r
7015 r.right = rect->right;
\r
7016 r.bottom = rect->bottom;
\r
7017 ExtTextOut(hdc, rect->left + MESSAGE_LINE_LEFTMARGIN,
\r
7018 r.top, ETO_CLIPPED|ETO_OPAQUE,
\r
7019 &r, str, strlen(str), NULL);
\r
7021 (void) SetTextColor(hdc, oldFg);
\r
7022 (void) SetBkColor(hdc, oldBg);
\r
7023 (void) SelectObject(hdc, oldFont);
\r
7028 DoReadFile(HANDLE hFile, char *buf, int count, DWORD *outCount,
\r
7034 if( count <= 0 ) {
\r
7035 if (appData.debugMode) {
\r
7036 fprintf( debugFP, "DoReadFile: trying to read past end of buffer, overflow = %d\n", count );
\r
7039 return ERROR_INVALID_USER_BUFFER;
\r
7042 ResetEvent(ovl->hEvent);
\r
7043 ovl->Offset = ovl->OffsetHigh = 0;
\r
7044 ok = ReadFile(hFile, buf, count, outCount, ovl);
\r
7048 err = GetLastError();
\r
7049 if (err == ERROR_IO_PENDING) {
\r
7050 ok = GetOverlappedResult(hFile, ovl, outCount, TRUE);
\r
7054 err = GetLastError();
\r
7061 DoWriteFile(HANDLE hFile, char *buf, int count, DWORD *outCount,
\r
7066 ResetEvent(ovl->hEvent);
\r
7067 ovl->Offset = ovl->OffsetHigh = 0;
\r
7068 ok = WriteFile(hFile, buf, count, outCount, ovl);
\r
7072 err = GetLastError();
\r
7073 if (err == ERROR_IO_PENDING) {
\r
7074 ok = GetOverlappedResult(hFile, ovl, outCount, TRUE);
\r
7078 err = GetLastError();
\r
7084 /* [AS] If input is line by line and a line exceed the buffer size, force an error */
\r
7085 void CheckForInputBufferFull( InputSource * is )
\r
7087 if( is->lineByLine && (is->next - is->buf) >= INPUT_SOURCE_BUF_SIZE ) {
\r
7088 /* Look for end of line */
\r
7089 char * p = is->buf;
\r
7091 while( p < is->next && *p != '\n' ) {
\r
7095 if( p >= is->next ) {
\r
7096 if (appData.debugMode) {
\r
7097 fprintf( debugFP, "Input line exceeded buffer size (source id=%lu)\n", is->id );
\r
7100 is->error = ERROR_BROKEN_PIPE; /* [AS] Just any non-successful code! */
\r
7101 is->count = (DWORD) -1;
\r
7102 is->next = is->buf;
\r
7108 InputThread(LPVOID arg)
\r
7113 is = (InputSource *) arg;
\r
7114 ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
\r
7115 ovl.Internal = ovl.InternalHigh = ovl.Offset = ovl.OffsetHigh = 0;
\r
7116 while (is->hThread != NULL) {
\r
7117 is->error = DoReadFile(is->hFile, is->next,
\r
7118 INPUT_SOURCE_BUF_SIZE - (is->next - is->buf),
\r
7119 &is->count, &ovl);
\r
7120 if (is->error == NO_ERROR) {
\r
7121 is->next += is->count;
\r
7123 if (is->error == ERROR_BROKEN_PIPE) {
\r
7124 /* Correct for MS brain damage. EOF reading a pipe is not an error. */
\r
7127 is->count = (DWORD) -1;
\r
7128 /* [AS] The (is->count <= 0) check below is not useful for unsigned values! */
\r
7133 CheckForInputBufferFull( is );
\r
7135 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7137 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7139 if (is->count <= 0) break; /* Quit on EOF or error */
\r
7142 CloseHandle(ovl.hEvent);
\r
7143 CloseHandle(is->hFile);
\r
7145 if (appData.debugMode) {
\r
7146 fprintf( debugFP, "Input thread terminated (id=%lu, error=%d, count=%ld)\n", is->id, is->error, is->count );
\r
7153 /* Windows 95 beta 2 won't let you do overlapped i/o on a console or pipe */
\r
7155 NonOvlInputThread(LPVOID arg)
\r
7162 is = (InputSource *) arg;
\r
7163 while (is->hThread != NULL) {
\r
7164 is->error = ReadFile(is->hFile, is->next,
\r
7165 INPUT_SOURCE_BUF_SIZE - (is->next - is->buf),
\r
7166 &is->count, NULL) ? NO_ERROR : GetLastError();
\r
7167 if (is->error == NO_ERROR) {
\r
7168 /* Change CRLF to LF */
\r
7169 if (is->next > is->buf) {
\r
7171 i = is->count + 1;
\r
7179 if (prev == '\r' && *p == '\n') {
\r
7191 if (is->error == ERROR_BROKEN_PIPE) {
\r
7192 /* Correct for MS brain damage. EOF reading a pipe is not an error. */
\r
7195 is->count = (DWORD) -1;
\r
7199 CheckForInputBufferFull( is );
\r
7201 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7203 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7205 if (is->count < 0) break; /* Quit on error */
\r
7207 CloseHandle(is->hFile);
\r
7212 SocketInputThread(LPVOID arg)
\r
7216 is = (InputSource *) arg;
\r
7217 while (is->hThread != NULL) {
\r
7218 is->count = recv(is->sock, is->buf, INPUT_SOURCE_BUF_SIZE, 0);
\r
7219 if ((int)is->count == SOCKET_ERROR) {
\r
7220 is->count = (DWORD) -1;
\r
7221 is->error = WSAGetLastError();
\r
7223 is->error = NO_ERROR;
\r
7224 is->next += is->count;
\r
7225 if (is->count == 0 && is->second == is) {
\r
7226 /* End of file on stderr; quit with no message */
\r
7230 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7232 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7234 if (is->count <= 0) break; /* Quit on EOF or error */
\r
7240 InputEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
7244 is = (InputSource *) lParam;
\r
7245 if (is->lineByLine) {
\r
7246 /* Feed in lines one by one */
\r
7247 char *p = is->buf;
\r
7249 while (q < is->next) {
\r
7250 if (*q++ == '\n') {
\r
7251 (is->func)(is, is->closure, p, q - p, NO_ERROR);
\r
7256 /* Move any partial line to the start of the buffer */
\r
7258 while (p < is->next) {
\r
7263 if (is->error != NO_ERROR || is->count == 0) {
\r
7264 /* Notify backend of the error. Note: If there was a partial
\r
7265 line at the end, it is not flushed through. */
\r
7266 (is->func)(is, is->closure, is->buf, is->count, is->error);
\r
7269 /* Feed in the whole chunk of input at once */
\r
7270 (is->func)(is, is->closure, is->buf, is->count, is->error);
\r
7271 is->next = is->buf;
\r
7275 /*---------------------------------------------------------------------------*\
\r
7277 * Menu enables. Used when setting various modes.
\r
7279 \*---------------------------------------------------------------------------*/
\r
7287 GreyRevert(Boolean grey)
\r
7288 { // [HGM] vari: for retracting variations in local mode
\r
7289 HMENU hmenu = GetMenu(hwndMain);
\r
7290 EnableMenuItem(hmenu, IDM_Revert, MF_BYCOMMAND|(grey ? MF_GRAYED : MF_ENABLED));
\r
7294 SetMenuEnables(HMENU hmenu, Enables *enab)
\r
7296 while (enab->item > 0) {
\r
7297 (void) EnableMenuItem(hmenu, enab->item, enab->flags);
\r
7302 Enables gnuEnables[] = {
\r
7303 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7304 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7305 { IDM_IcsClient, MF_BYCOMMAND|MF_GRAYED },
\r
7306 { IDM_Accept, MF_BYCOMMAND|MF_GRAYED },
\r
7307 { IDM_Decline, MF_BYCOMMAND|MF_GRAYED },
\r
7308 { IDM_Rematch, MF_BYCOMMAND|MF_GRAYED },
\r
7309 { IDM_Adjourn, MF_BYCOMMAND|MF_GRAYED },
\r
7310 { IDM_StopExamining, MF_BYCOMMAND|MF_GRAYED },
\r
7311 { IDM_StopObserving, MF_BYCOMMAND|MF_GRAYED },
\r
7312 { IDM_Revert, MF_BYCOMMAND|MF_GRAYED },
\r
7313 { IDM_NewChat, MF_BYCOMMAND|MF_GRAYED },
\r
7317 Enables icsEnables[] = {
\r
7318 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7319 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7320 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7321 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7322 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7323 { IDM_MachineBoth, MF_BYCOMMAND|MF_GRAYED },
\r
7324 { IDM_AnalysisMode, MF_BYCOMMAND|MF_ENABLED },
\r
7325 { IDM_AnalyzeFile, MF_BYCOMMAND|MF_GRAYED },
\r
7326 { IDM_TimeControl, MF_BYCOMMAND|MF_GRAYED },
\r
7327 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7328 { IDM_Hint, MF_BYCOMMAND|MF_GRAYED },
\r
7329 { IDM_Book, MF_BYCOMMAND|MF_GRAYED },
\r
7330 { IDM_IcsOptions, MF_BYCOMMAND|MF_ENABLED },
\r
7331 { IDM_Engine1Options, MF_BYCOMMAND|MF_GRAYED },
\r
7332 { IDM_Engine2Options, MF_BYCOMMAND|MF_GRAYED },
\r
7337 Enables zippyEnables[] = {
\r
7338 { IDM_MoveNow, MF_BYCOMMAND|MF_ENABLED },
\r
7339 { IDM_Hint, MF_BYCOMMAND|MF_ENABLED },
\r
7340 { IDM_Book, MF_BYCOMMAND|MF_ENABLED },
\r
7341 { IDM_Engine1Options, MF_BYCOMMAND|MF_ENABLED },
\r
7346 Enables ncpEnables[] = {
\r
7347 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7348 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7349 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7350 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7351 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7352 { IDM_AnalysisMode, MF_BYCOMMAND|MF_GRAYED },
\r
7353 { IDM_AnalyzeFile, MF_BYCOMMAND|MF_GRAYED },
\r
7354 { IDM_IcsClient, MF_BYCOMMAND|MF_GRAYED },
\r
7355 { ACTION_POS, MF_BYPOSITION|MF_GRAYED },
\r
7356 { IDM_Revert, MF_BYCOMMAND|MF_GRAYED },
\r
7357 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7358 { IDM_RetractMove, MF_BYCOMMAND|MF_GRAYED },
\r
7359 { IDM_TimeControl, MF_BYCOMMAND|MF_GRAYED },
\r
7360 { IDM_Hint, MF_BYCOMMAND|MF_GRAYED },
\r
7361 { IDM_Book, MF_BYCOMMAND|MF_GRAYED },
\r
7362 { IDM_MachineBoth, MF_BYCOMMAND|MF_GRAYED },
\r
7363 { IDM_NewChat, MF_BYCOMMAND|MF_GRAYED },
\r
7364 { IDM_Engine1Options, MF_BYCOMMAND|MF_GRAYED },
\r
7365 { IDM_Engine2Options, MF_BYCOMMAND|MF_GRAYED },
\r
7369 Enables trainingOnEnables[] = {
\r
7370 { IDM_EditComment, MF_BYCOMMAND|MF_GRAYED },
\r
7371 { IDM_Pause, MF_BYCOMMAND|MF_GRAYED },
\r
7372 { IDM_Forward, MF_BYCOMMAND|MF_GRAYED },
\r
7373 { IDM_Backward, MF_BYCOMMAND|MF_GRAYED },
\r
7374 { IDM_ToEnd, MF_BYCOMMAND|MF_GRAYED },
\r
7375 { IDM_ToStart, MF_BYCOMMAND|MF_GRAYED },
\r
7376 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7377 { IDM_TruncateGame, MF_BYCOMMAND|MF_GRAYED },
\r
7381 Enables trainingOffEnables[] = {
\r
7382 { IDM_EditComment, MF_BYCOMMAND|MF_ENABLED },
\r
7383 { IDM_Pause, MF_BYCOMMAND|MF_ENABLED },
\r
7384 { IDM_Forward, MF_BYCOMMAND|MF_ENABLED },
\r
7385 { IDM_Backward, MF_BYCOMMAND|MF_ENABLED },
\r
7386 { IDM_ToEnd, MF_BYCOMMAND|MF_ENABLED },
\r
7387 { IDM_ToStart, MF_BYCOMMAND|MF_ENABLED },
\r
7388 { IDM_MoveNow, MF_BYCOMMAND|MF_ENABLED },
\r
7389 { IDM_TruncateGame, MF_BYCOMMAND|MF_ENABLED },
\r
7393 /* These modify either ncpEnables or gnuEnables */
\r
7394 Enables cmailEnables[] = {
\r
7395 { IDM_MailMove, MF_BYCOMMAND|MF_ENABLED },
\r
7396 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_ENABLED },
\r
7397 { ACTION_POS, MF_BYPOSITION|MF_ENABLED },
\r
7398 { IDM_CallFlag, MF_BYCOMMAND|MF_GRAYED },
\r
7399 { IDM_Draw, MF_BYCOMMAND|MF_ENABLED },
\r
7400 { IDM_Adjourn, MF_BYCOMMAND|MF_GRAYED },
\r
7401 { IDM_Abort, MF_BYCOMMAND|MF_GRAYED },
\r
7405 Enables machineThinkingEnables[] = {
\r
7406 { IDM_LoadGame, MF_BYCOMMAND|MF_GRAYED },
\r
7407 { IDM_LoadNextGame, MF_BYCOMMAND|MF_GRAYED },
\r
7408 { IDM_LoadPrevGame, MF_BYCOMMAND|MF_GRAYED },
\r
7409 { IDM_ReloadGame, MF_BYCOMMAND|MF_GRAYED },
\r
7410 { IDM_PasteGame, MF_BYCOMMAND|MF_GRAYED },
\r
7411 { IDM_LoadPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7412 { IDM_LoadNextPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7413 { IDM_LoadPrevPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7414 { IDM_ReloadPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7415 { IDM_PastePosition, MF_BYCOMMAND|MF_GRAYED },
\r
7416 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7417 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7418 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7419 { IDM_TypeInMove, MF_BYCOMMAND|MF_GRAYED },
\r
7420 { IDM_RetractMove, MF_BYCOMMAND|MF_GRAYED },
\r
7424 Enables userThinkingEnables[] = {
\r
7425 { IDM_LoadGame, MF_BYCOMMAND|MF_ENABLED },
\r
7426 { IDM_LoadNextGame, MF_BYCOMMAND|MF_ENABLED },
\r
7427 { IDM_LoadPrevGame, MF_BYCOMMAND|MF_ENABLED },
\r
7428 { IDM_ReloadGame, MF_BYCOMMAND|MF_ENABLED },
\r
7429 { IDM_PasteGame, MF_BYCOMMAND|MF_ENABLED },
\r
7430 { IDM_LoadPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7431 { IDM_LoadNextPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7432 { IDM_LoadPrevPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7433 { IDM_ReloadPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7434 { IDM_PastePosition, MF_BYCOMMAND|MF_ENABLED },
\r
7435 { IDM_MachineWhite, MF_BYCOMMAND|MF_ENABLED },
\r
7436 { IDM_MachineBlack, MF_BYCOMMAND|MF_ENABLED },
\r
7437 { IDM_TwoMachines, MF_BYCOMMAND|MF_ENABLED },
\r
7438 { IDM_TypeInMove, MF_BYCOMMAND|MF_ENABLED },
\r
7439 { IDM_RetractMove, MF_BYCOMMAND|MF_ENABLED },
\r
7443 /*---------------------------------------------------------------------------*\
\r
7445 * Front-end interface functions exported by XBoard.
\r
7446 * Functions appear in same order as prototypes in frontend.h.
\r
7448 \*---------------------------------------------------------------------------*/
\r
7452 static UINT prevChecked = 0;
\r
7453 static int prevPausing = 0;
\r
7456 if (pausing != prevPausing) {
\r
7457 prevPausing = pausing;
\r
7458 (void) CheckMenuItem(GetMenu(hwndMain), IDM_Pause,
\r
7459 MF_BYCOMMAND|(pausing ? MF_CHECKED : MF_UNCHECKED));
\r
7460 if (hwndPause) SetWindowText(hwndPause, pausing ? "C" : "P");
\r
7463 switch (gameMode) {
\r
7464 case BeginningOfGame:
\r
7465 if (appData.icsActive)
\r
7466 nowChecked = IDM_IcsClient;
\r
7467 else if (appData.noChessProgram)
\r
7468 nowChecked = IDM_EditGame;
\r
7470 nowChecked = IDM_MachineBlack;
\r
7472 case MachinePlaysBlack:
\r
7473 nowChecked = IDM_MachineBlack;
\r
7475 case MachinePlaysWhite:
\r
7476 nowChecked = IDM_MachineWhite;
\r
7478 case TwoMachinesPlay:
\r
7479 nowChecked = IDM_TwoMachines;
\r
7482 nowChecked = IDM_AnalysisMode;
\r
7485 nowChecked = IDM_AnalyzeFile;
\r
7488 nowChecked = IDM_EditGame;
\r
7490 case PlayFromGameFile:
\r
7491 nowChecked = IDM_LoadGame;
\r
7493 case EditPosition:
\r
7494 nowChecked = IDM_EditPosition;
\r
7497 nowChecked = IDM_Training;
\r
7499 case IcsPlayingWhite:
\r
7500 case IcsPlayingBlack:
\r
7501 case IcsObserving:
\r
7503 nowChecked = IDM_IcsClient;
\r
7510 if (prevChecked != 0)
\r
7511 (void) CheckMenuItem(GetMenu(hwndMain),
\r
7512 prevChecked, MF_BYCOMMAND|MF_UNCHECKED);
\r
7513 if (nowChecked != 0)
\r
7514 (void) CheckMenuItem(GetMenu(hwndMain),
\r
7515 nowChecked, MF_BYCOMMAND|MF_CHECKED);
\r
7517 if (nowChecked == IDM_LoadGame || nowChecked == IDM_Training) {
\r
7518 (void) EnableMenuItem(GetMenu(hwndMain), IDM_Training,
\r
7519 MF_BYCOMMAND|MF_ENABLED);
\r
7521 (void) EnableMenuItem(GetMenu(hwndMain),
\r
7522 IDM_Training, MF_BYCOMMAND|MF_GRAYED);
\r
7525 prevChecked = nowChecked;
\r
7527 /* [DM] icsEngineAnalyze - Do a sceure check too */
\r
7528 if (appData.icsActive) {
\r
7529 if (appData.icsEngineAnalyze) {
\r
7530 (void) CheckMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7531 MF_BYCOMMAND|MF_CHECKED);
\r
7533 (void) CheckMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7534 MF_BYCOMMAND|MF_UNCHECKED);
\r
7542 HMENU hmenu = GetMenu(hwndMain);
\r
7543 SetMenuEnables(hmenu, icsEnables);
\r
7544 EnableMenuItem(GetSubMenu(hmenu, OPTIONS_POS), ICS_POS,
\r
7545 MF_BYPOSITION|MF_ENABLED);
\r
7547 if (appData.zippyPlay) {
\r
7548 SetMenuEnables(hmenu, zippyEnables);
\r
7549 if (!appData.noChessProgram) /* [DM] icsEngineAnalyze */
\r
7550 (void) EnableMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7551 MF_BYCOMMAND|MF_ENABLED);
\r
7559 SetMenuEnables(GetMenu(hwndMain), gnuEnables);
\r
7565 HMENU hmenu = GetMenu(hwndMain);
\r
7566 SetMenuEnables(hmenu, ncpEnables);
\r
7567 EnableMenuItem(GetSubMenu(hmenu, OPTIONS_POS), SOUNDS_POS,
\r
7568 MF_BYPOSITION|MF_GRAYED);
\r
7569 DrawMenuBar(hwndMain);
\r
7575 SetMenuEnables(GetMenu(hwndMain), cmailEnables);
\r
7579 SetTrainingModeOn()
\r
7582 SetMenuEnables(GetMenu(hwndMain), trainingOnEnables);
\r
7583 for (i = 0; i < N_BUTTONS; i++) {
\r
7584 if (buttonDesc[i].hwnd != NULL)
\r
7585 EnableWindow(buttonDesc[i].hwnd, FALSE);
\r
7590 VOID SetTrainingModeOff()
\r
7593 SetMenuEnables(GetMenu(hwndMain), trainingOffEnables);
\r
7594 for (i = 0; i < N_BUTTONS; i++) {
\r
7595 if (buttonDesc[i].hwnd != NULL)
\r
7596 EnableWindow(buttonDesc[i].hwnd, TRUE);
\r
7602 SetUserThinkingEnables()
\r
7604 SetMenuEnables(GetMenu(hwndMain), userThinkingEnables);
\r
7608 SetMachineThinkingEnables()
\r
7610 HMENU hMenu = GetMenu(hwndMain);
\r
7611 int flags = MF_BYCOMMAND|MF_ENABLED;
\r
7613 SetMenuEnables(hMenu, machineThinkingEnables);
\r
7615 if (gameMode == MachinePlaysBlack) {
\r
7616 (void)EnableMenuItem(hMenu, IDM_MachineBlack, flags);
\r
7617 } else if (gameMode == MachinePlaysWhite) {
\r
7618 (void)EnableMenuItem(hMenu, IDM_MachineWhite, flags);
\r
7619 } else if (gameMode == TwoMachinesPlay) {
\r
7620 (void)EnableMenuItem(hMenu, IDM_TwoMachines, flags);
\r
7626 DisplayTitle(char *str)
\r
7628 char title[MSG_SIZ], *host;
\r
7629 if (str[0] != NULLCHAR) {
\r
7630 strcpy(title, str);
\r
7631 } else if (appData.icsActive) {
\r
7632 if (appData.icsCommPort[0] != NULLCHAR)
\r
7635 host = appData.icsHost;
\r
7636 sprintf(title, "%s: %s", szTitle, host);
\r
7637 } else if (appData.noChessProgram) {
\r
7638 strcpy(title, szTitle);
\r
7640 strcpy(title, szTitle);
\r
7641 strcat(title, ": ");
\r
7642 strcat(title, first.tidy);
\r
7644 SetWindowText(hwndMain, title);
\r
7649 DisplayMessage(char *str1, char *str2)
\r
7653 int remain = MESSAGE_TEXT_MAX - 1;
\r
7656 moveErrorMessageUp = FALSE; /* turned on later by caller if needed */
\r
7657 messageText[0] = NULLCHAR;
\r
7659 len = strlen(str1);
\r
7660 if (len > remain) len = remain;
\r
7661 strncpy(messageText, str1, len);
\r
7662 messageText[len] = NULLCHAR;
\r
7665 if (*str2 && remain >= 2) {
\r
7667 strcat(messageText, " ");
\r
7670 len = strlen(str2);
\r
7671 if (len > remain) len = remain;
\r
7672 strncat(messageText, str2, len);
\r
7674 messageText[MESSAGE_TEXT_MAX - 1] = NULLCHAR;
\r
7676 if (hwndMain == NULL || IsIconic(hwndMain)) return;
\r
7680 hdc = GetDC(hwndMain);
\r
7681 oldFont = SelectObject(hdc, font[boardSize][MESSAGE_FONT]->hf);
\r
7682 ExtTextOut(hdc, messageRect.left, messageRect.top, ETO_CLIPPED|ETO_OPAQUE,
\r
7683 &messageRect, messageText, strlen(messageText), NULL);
\r
7684 (void) SelectObject(hdc, oldFont);
\r
7685 (void) ReleaseDC(hwndMain, hdc);
\r
7689 DisplayError(char *str, int error)
\r
7691 char buf[MSG_SIZ*2], buf2[MSG_SIZ];
\r
7697 len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
\r
7698 NULL, error, LANG_NEUTRAL,
\r
7699 (LPSTR) buf2, MSG_SIZ, NULL);
\r
7701 sprintf(buf, "%s:\n%s", str, buf2);
\r
7703 ErrorMap *em = errmap;
\r
7704 while (em->err != 0 && em->err != error) em++;
\r
7705 if (em->err != 0) {
\r
7706 sprintf(buf, "%s:\n%s", str, em->msg);
\r
7708 sprintf(buf, "%s:\nError code %d", str, error);
\r
7713 ErrorPopUp("Error", buf);
\r
7718 DisplayMoveError(char *str)
\r
7720 fromX = fromY = -1;
\r
7721 ClearHighlights();
\r
7722 DrawPosition(FALSE, NULL);
\r
7723 if (appData.popupMoveErrors) {
\r
7724 ErrorPopUp("Error", str);
\r
7726 DisplayMessage(str, "");
\r
7727 moveErrorMessageUp = TRUE;
\r
7732 DisplayFatalError(char *str, int error, int exitStatus)
\r
7734 char buf[2*MSG_SIZ], buf2[MSG_SIZ];
\r
7736 char *label = exitStatus ? "Fatal Error" : "Exiting";
\r
7739 len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
\r
7740 NULL, error, LANG_NEUTRAL,
\r
7741 (LPSTR) buf2, MSG_SIZ, NULL);
\r
7743 sprintf(buf, "%s:\n%s", str, buf2);
\r
7745 ErrorMap *em = errmap;
\r
7746 while (em->err != 0 && em->err != error) em++;
\r
7747 if (em->err != 0) {
\r
7748 sprintf(buf, "%s:\n%s", str, em->msg);
\r
7750 sprintf(buf, "%s:\nError code %d", str, error);
\r
7755 if (appData.debugMode) {
\r
7756 fprintf(debugFP, "%s: %s\n", label, str);
\r
7758 if (appData.popupExitMessage) {
\r
7759 (void) MessageBox(hwndMain, str, label, MB_OK|
\r
7760 (exitStatus ? MB_ICONSTOP : MB_ICONINFORMATION));
\r
7762 ExitEvent(exitStatus);
\r
7767 DisplayInformation(char *str)
\r
7769 (void) MessageBox(hwndMain, str, "Information", MB_OK|MB_ICONINFORMATION);
\r
7774 DisplayNote(char *str)
\r
7776 ErrorPopUp("Note", str);
\r
7781 char *title, *question, *replyPrefix;
\r
7786 QuestionDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7788 static QuestionParams *qp;
\r
7789 char reply[MSG_SIZ];
\r
7792 switch (message) {
\r
7793 case WM_INITDIALOG:
\r
7794 qp = (QuestionParams *) lParam;
\r
7795 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7796 SetWindowText(hDlg, qp->title);
\r
7797 SetDlgItemText(hDlg, OPT_QuestionText, qp->question);
\r
7798 SetFocus(GetDlgItem(hDlg, OPT_QuestionInput));
\r
7802 switch (LOWORD(wParam)) {
\r
7804 strcpy(reply, qp->replyPrefix);
\r
7805 if (*reply) strcat(reply, " ");
\r
7806 len = strlen(reply);
\r
7807 GetDlgItemText(hDlg, OPT_QuestionInput, reply + len, sizeof(reply) - len);
\r
7808 strcat(reply, "\n");
\r
7809 OutputToProcess(qp->pr, reply, strlen(reply), &err);
\r
7810 EndDialog(hDlg, TRUE);
\r
7811 if (err) DisplayFatalError("Error writing to chess program", err, 1);
\r
7814 EndDialog(hDlg, FALSE);
\r
7825 AskQuestion(char* title, char *question, char *replyPrefix, ProcRef pr)
\r
7827 QuestionParams qp;
\r
7831 qp.question = question;
\r
7832 qp.replyPrefix = replyPrefix;
\r
7834 lpProc = MakeProcInstance((FARPROC)QuestionDialog, hInst);
\r
7835 DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_Question),
\r
7836 hwndMain, (DLGPROC)lpProc, (LPARAM)&qp);
\r
7837 FreeProcInstance(lpProc);
\r
7840 /* [AS] Pick FRC position */
\r
7841 LRESULT CALLBACK NewGameFRC_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7843 static int * lpIndexFRC;
\r
7849 case WM_INITDIALOG:
\r
7850 lpIndexFRC = (int *) lParam;
\r
7852 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7854 SendDlgItemMessage( hDlg, IDC_NFG_Edit, EM_SETLIMITTEXT, sizeof(buf)-1, 0 );
\r
7855 SetDlgItemInt( hDlg, IDC_NFG_Edit, *lpIndexFRC, TRUE );
\r
7856 SendDlgItemMessage( hDlg, IDC_NFG_Edit, EM_SETSEL, 0, -1 );
\r
7857 SetFocus(GetDlgItem(hDlg, IDC_NFG_Edit));
\r
7862 switch( LOWORD(wParam) ) {
\r
7864 *lpIndexFRC = GetDlgItemInt(hDlg, IDC_NFG_Edit, &index_is_ok, TRUE );
\r
7865 EndDialog( hDlg, 0 );
\r
7866 shuffleOpenings = TRUE; /* [HGM] shuffle: switch shuffling on for as long as we stay in current variant */
\r
7869 EndDialog( hDlg, 1 );
\r
7871 case IDC_NFG_Edit:
\r
7872 if( HIWORD(wParam) == EN_CHANGE ) {
\r
7873 GetDlgItemInt(hDlg, IDC_NFG_Edit, &index_is_ok, TRUE );
\r
7875 EnableWindow( GetDlgItem(hDlg, IDOK), index_is_ok );
\r
7878 case IDC_NFG_Random:
\r
7879 sprintf( buf, "%d", myrandom() ); /* [HGM] shuffle: no longer limit to 960 */
\r
7880 SetDlgItemText(hDlg, IDC_NFG_Edit, buf );
\r
7893 int index = appData.defaultFrcPosition;
\r
7894 FARPROC lpProc = MakeProcInstance( (FARPROC) NewGameFRC_Proc, hInst );
\r
7896 result = DialogBoxParam( hInst, MAKEINTRESOURCE(DLG_NewGameFRC), hwndMain, (DLGPROC)lpProc, (LPARAM)&index );
\r
7898 if( result == 0 ) {
\r
7899 appData.defaultFrcPosition = index;
\r
7905 /* [AS] Game list options. Refactored by HGM */
\r
7907 HWND gameListOptionsDialog;
\r
7909 // low-level front-end: clear text edit / list widget
\r
7913 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_RESETCONTENT, 0, 0 );
\r
7916 // low-level front-end: clear text edit / list widget
\r
7918 GLT_DeSelectList()
\r
7920 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_SETCURSEL, 0, 0 );
\r
7923 // low-level front-end: append line to text edit / list widget
\r
7925 GLT_AddToList( char *name )
\r
7928 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_ADDSTRING, 0, (LPARAM) name );
\r
7932 // low-level front-end: get line from text edit / list widget
\r
7934 GLT_GetFromList( int index, char *name )
\r
7937 if( SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_GETTEXT, index, (LPARAM) name ) != LB_ERR )
\r
7943 void GLT_MoveSelection( HWND hDlg, int delta )
\r
7945 int idx1 = (int) SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETCURSEL, 0, 0 );
\r
7946 int idx2 = idx1 + delta;
\r
7947 int count = (int) SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETCOUNT, 0, 0 );
\r
7949 if( idx1 >=0 && idx1 < count && idx2 >= 0 && idx2 < count ) {
\r
7952 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETTEXT, idx1, (LPARAM) buf );
\r
7953 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_DELETESTRING, idx1, 0 );
\r
7954 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_INSERTSTRING, idx2, (LPARAM) buf );
\r
7955 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_SETCURSEL, idx2, 0 );
\r
7959 LRESULT CALLBACK GameListOptions_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7963 case WM_INITDIALOG:
\r
7964 gameListOptionsDialog = hDlg; // [HGM] pass through global to keep out off back-end
\r
7966 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7968 /* Initialize list */
\r
7969 GLT_TagsToList( lpUserGLT );
\r
7971 SetFocus( GetDlgItem(hDlg, IDC_GameListTags) );
\r
7976 switch( LOWORD(wParam) ) {
\r
7979 EndDialog( hDlg, 0 );
\r
7982 EndDialog( hDlg, 1 );
\r
7985 case IDC_GLT_Default:
\r
7986 GLT_TagsToList( GLT_DEFAULT_TAGS );
\r
7989 case IDC_GLT_Restore:
\r
7990 GLT_TagsToList( appData.gameListTags );
\r
7994 GLT_MoveSelection( hDlg, -1 );
\r
7997 case IDC_GLT_Down:
\r
7998 GLT_MoveSelection( hDlg, +1 );
\r
8008 int GameListOptions()
\r
8011 FARPROC lpProc = MakeProcInstance( (FARPROC) GameListOptions_Proc, hInst );
\r
8013 strcpy( lpUserGLT, appData.gameListTags );
\r
8015 result = DialogBoxParam( hInst, MAKEINTRESOURCE(DLG_GameListOptions), hwndMain, (DLGPROC)lpProc, (LPARAM)lpUserGLT );
\r
8017 if( result == 0 ) {
\r
8018 /* [AS] Memory leak here! */
\r
8019 appData.gameListTags = strdup( lpUserGLT );
\r
8026 DisplayIcsInteractionTitle(char *str)
\r
8028 char consoleTitle[MSG_SIZ];
\r
8030 sprintf(consoleTitle, "%s: %s", szConsoleTitle, str);
\r
8031 SetWindowText(hwndConsole, consoleTitle);
\r
8035 DrawPosition(int fullRedraw, Board board)
\r
8037 HDCDrawPosition(NULL, (BOOLEAN) fullRedraw, board);
\r
8040 void NotifyFrontendLogin()
\r
8043 UpdateICSWidth(GetDlgItem(hwndConsole, OPT_ConsoleText));
\r
8049 fromX = fromY = -1;
\r
8050 if (dragInfo.pos.x != -1 || dragInfo.pos.y != -1) {
\r
8051 dragInfo.pos.x = dragInfo.pos.y = -1;
\r
8052 dragInfo.pos.x = dragInfo.pos.y = -1;
\r
8053 dragInfo.lastpos = dragInfo.pos;
\r
8054 dragInfo.start.x = dragInfo.start.y = -1;
\r
8055 dragInfo.from = dragInfo.start;
\r
8057 DrawPosition(TRUE, NULL);
\r
8063 CommentPopUp(char *title, char *str)
\r
8065 HWND hwnd = GetActiveWindow();
\r
8066 EitherCommentPopUp(0, title, str, FALSE);
\r
8068 SetActiveWindow(hwnd);
\r
8072 CommentPopDown(void)
\r
8074 CheckMenuItem(GetMenu(hwndMain), IDM_EditComment, MF_UNCHECKED);
\r
8075 if (commentDialog) {
\r
8076 ShowWindow(commentDialog, SW_HIDE);
\r
8078 commentUp = FALSE;
\r
8082 EditCommentPopUp(int index, char *title, char *str)
\r
8084 EitherCommentPopUp(index, title, str, TRUE);
\r
8091 MyPlaySound(&sounds[(int)SoundMove]);
\r
8094 VOID PlayIcsWinSound()
\r
8096 MyPlaySound(&sounds[(int)SoundIcsWin]);
\r
8099 VOID PlayIcsLossSound()
\r
8101 MyPlaySound(&sounds[(int)SoundIcsLoss]);
\r
8104 VOID PlayIcsDrawSound()
\r
8106 MyPlaySound(&sounds[(int)SoundIcsDraw]);
\r
8109 VOID PlayIcsUnfinishedSound()
\r
8111 MyPlaySound(&sounds[(int)SoundIcsUnfinished]);
\r
8117 MyPlaySound(&sounds[(int)SoundAlarm]);
\r
8125 consoleEcho = TRUE;
\r
8126 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
8127 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&consoleCF);
\r
8128 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
8137 consoleEcho = FALSE;
\r
8138 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
8139 /* This works OK: set text and background both to the same color */
\r
8141 cf.crTextColor = COLOR_ECHOOFF;
\r
8142 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
\r
8143 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, cf.crTextColor);
\r
8146 /* No Raw()...? */
\r
8148 void Colorize(ColorClass cc, int continuation)
\r
8150 currentColorClass = cc;
\r
8151 consoleCF.dwMask = CFM_COLOR|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT;
\r
8152 consoleCF.crTextColor = textAttribs[cc].color;
\r
8153 consoleCF.dwEffects = textAttribs[cc].effects;
\r
8154 if (!continuation) MyPlaySound(&textAttribs[cc].sound);
\r
8160 static char buf[MSG_SIZ];
\r
8161 DWORD bufsiz = MSG_SIZ;
\r
8163 if(appData.userName != NULL && appData.userName[0] != 0) {
\r
8164 return appData.userName; /* [HGM] username: prefer name selected by user over his system login */
\r
8166 if (!GetUserName(buf, &bufsiz)) {
\r
8167 /*DisplayError("Error getting user name", GetLastError());*/
\r
8168 strcpy(buf, "User");
\r
8176 static char buf[MSG_SIZ];
\r
8177 DWORD bufsiz = MSG_SIZ;
\r
8179 if (!GetComputerName(buf, &bufsiz)) {
\r
8180 /*DisplayError("Error getting host name", GetLastError());*/
\r
8181 strcpy(buf, "Unknown");
\r
8188 ClockTimerRunning()
\r
8190 return clockTimerEvent != 0;
\r
8196 if (clockTimerEvent == 0) return FALSE;
\r
8197 KillTimer(hwndMain, clockTimerEvent);
\r
8198 clockTimerEvent = 0;
\r
8203 StartClockTimer(long millisec)
\r
8205 clockTimerEvent = SetTimer(hwndMain, (UINT) CLOCK_TIMER_ID,
\r
8206 (UINT) millisec, NULL);
\r
8210 DisplayWhiteClock(long timeRemaining, int highlight)
\r
8213 char *flag = whiteFlag && gameMode == TwoMachinesPlay ? "(!)" : "";
\r
8215 if(appData.noGUI) return;
\r
8216 hdc = GetDC(hwndMain);
\r
8217 if (!IsIconic(hwndMain)) {
\r
8218 DisplayAClock(hdc, timeRemaining, highlight,
\r
8219 flipClock ? &blackRect : &whiteRect, "White", flag);
\r
8221 if (highlight && iconCurrent == iconBlack) {
\r
8222 iconCurrent = iconWhite;
\r
8223 PostMessage(hwndMain, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8224 if (IsIconic(hwndMain)) {
\r
8225 DrawIcon(hdc, 2, 2, iconCurrent);
\r
8228 (void) ReleaseDC(hwndMain, hdc);
\r
8230 PostMessage(hwndConsole, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8234 DisplayBlackClock(long timeRemaining, int highlight)
\r
8237 char *flag = blackFlag && gameMode == TwoMachinesPlay ? "(!)" : "";
\r
8239 if(appData.noGUI) return;
\r
8240 hdc = GetDC(hwndMain);
\r
8241 if (!IsIconic(hwndMain)) {
\r
8242 DisplayAClock(hdc, timeRemaining, highlight,
\r
8243 flipClock ? &whiteRect : &blackRect, "Black", flag);
\r
8245 if (highlight && iconCurrent == iconWhite) {
\r
8246 iconCurrent = iconBlack;
\r
8247 PostMessage(hwndMain, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8248 if (IsIconic(hwndMain)) {
\r
8249 DrawIcon(hdc, 2, 2, iconCurrent);
\r
8252 (void) ReleaseDC(hwndMain, hdc);
\r
8254 PostMessage(hwndConsole, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8259 LoadGameTimerRunning()
\r
8261 return loadGameTimerEvent != 0;
\r
8265 StopLoadGameTimer()
\r
8267 if (loadGameTimerEvent == 0) return FALSE;
\r
8268 KillTimer(hwndMain, loadGameTimerEvent);
\r
8269 loadGameTimerEvent = 0;
\r
8274 StartLoadGameTimer(long millisec)
\r
8276 loadGameTimerEvent = SetTimer(hwndMain, (UINT) LOAD_GAME_TIMER_ID,
\r
8277 (UINT) millisec, NULL);
\r
8285 char fileTitle[MSG_SIZ];
\r
8287 defName = DefaultFileName(appData.oldSaveStyle ? "gam" : "pgn");
\r
8288 f = OpenFileDialog(hwndMain, "a", defName,
\r
8289 appData.oldSaveStyle ? "gam" : "pgn",
\r
8291 "Save Game to File", NULL, fileTitle, NULL);
\r
8293 SaveGame(f, 0, "");
\r
8300 ScheduleDelayedEvent(DelayedEventCallback cb, long millisec)
\r
8302 if (delayedTimerEvent != 0) {
\r
8303 if (appData.debugMode && cb != delayedTimerCallback) { // [HGM] alive: not too much debug
\r
8304 fprintf(debugFP, "ScheduleDelayedEvent: event already scheduled\n");
\r
8306 KillTimer(hwndMain, delayedTimerEvent);
\r
8307 delayedTimerEvent = 0;
\r
8308 if(delayedTimerCallback != cb) // [HGM] alive: do not "flush" same event, just postpone it
\r
8309 delayedTimerCallback();
\r
8311 delayedTimerCallback = cb;
\r
8312 delayedTimerEvent = SetTimer(hwndMain, (UINT) DELAYED_TIMER_ID,
\r
8313 (UINT) millisec, NULL);
\r
8316 DelayedEventCallback
\r
8319 if (delayedTimerEvent) {
\r
8320 return delayedTimerCallback;
\r
8327 CancelDelayedEvent()
\r
8329 if (delayedTimerEvent) {
\r
8330 KillTimer(hwndMain, delayedTimerEvent);
\r
8331 delayedTimerEvent = 0;
\r
8335 DWORD GetWin32Priority(int nice)
\r
8336 { // [HGM] nice: translate Unix nice() value to indows priority class. (Code stolen from Polyglot 1.4w11)
\r
8338 REALTIME_PRIORITY_CLASS 0x00000100
\r
8339 HIGH_PRIORITY_CLASS 0x00000080
\r
8340 ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
\r
8341 NORMAL_PRIORITY_CLASS 0x00000020
\r
8342 BELOW_NORMAL_PRIORITY_CLASS 0x00004000
\r
8343 IDLE_PRIORITY_CLASS 0x00000040
\r
8345 if (nice < -15) return 0x00000080;
\r
8346 if (nice < 0) return 0x00008000;
\r
8347 if (nice == 0) return 0x00000020;
\r
8348 if (nice < 15) return 0x00004000;
\r
8349 return 0x00000040;
\r
8352 /* Start a child process running the given program.
\r
8353 The process's standard output can be read from "from", and its
\r
8354 standard input can be written to "to".
\r
8355 Exit with fatal error if anything goes wrong.
\r
8356 Returns an opaque pointer that can be used to destroy the process
\r
8360 StartChildProcess(char *cmdLine, char *dir, ProcRef *pr)
\r
8362 #define BUFSIZE 4096
\r
8364 HANDLE hChildStdinRd, hChildStdinWr,
\r
8365 hChildStdoutRd, hChildStdoutWr;
\r
8366 HANDLE hChildStdinWrDup, hChildStdoutRdDup;
\r
8367 SECURITY_ATTRIBUTES saAttr;
\r
8369 PROCESS_INFORMATION piProcInfo;
\r
8370 STARTUPINFO siStartInfo;
\r
8372 char buf[MSG_SIZ];
\r
8375 if (appData.debugMode) {
\r
8376 fprintf(debugFP, "StartChildProcess (dir=\"%s\") %s\n", dir, cmdLine);
\r
8381 /* Set the bInheritHandle flag so pipe handles are inherited. */
\r
8382 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
\r
8383 saAttr.bInheritHandle = TRUE;
\r
8384 saAttr.lpSecurityDescriptor = NULL;
\r
8387 * The steps for redirecting child's STDOUT:
\r
8388 * 1. Create anonymous pipe to be STDOUT for child.
\r
8389 * 2. Create a noninheritable duplicate of read handle,
\r
8390 * and close the inheritable read handle.
\r
8393 /* Create a pipe for the child's STDOUT. */
\r
8394 if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) {
\r
8395 return GetLastError();
\r
8398 /* Duplicate the read handle to the pipe, so it is not inherited. */
\r
8399 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,
\r
8400 GetCurrentProcess(), &hChildStdoutRdDup, 0,
\r
8401 FALSE, /* not inherited */
\r
8402 DUPLICATE_SAME_ACCESS);
\r
8404 return GetLastError();
\r
8406 CloseHandle(hChildStdoutRd);
\r
8409 * The steps for redirecting child's STDIN:
\r
8410 * 1. Create anonymous pipe to be STDIN for child.
\r
8411 * 2. Create a noninheritable duplicate of write handle,
\r
8412 * and close the inheritable write handle.
\r
8415 /* Create a pipe for the child's STDIN. */
\r
8416 if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
\r
8417 return GetLastError();
\r
8420 /* Duplicate the write handle to the pipe, so it is not inherited. */
\r
8421 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,
\r
8422 GetCurrentProcess(), &hChildStdinWrDup, 0,
\r
8423 FALSE, /* not inherited */
\r
8424 DUPLICATE_SAME_ACCESS);
\r
8426 return GetLastError();
\r
8428 CloseHandle(hChildStdinWr);
\r
8430 /* Arrange to (1) look in dir for the child .exe file, and
\r
8431 * (2) have dir be the child's working directory. Interpret
\r
8432 * dir relative to the directory WinBoard loaded from. */
\r
8433 GetCurrentDirectory(MSG_SIZ, buf);
\r
8434 SetCurrentDirectory(installDir);
\r
8435 SetCurrentDirectory(dir);
\r
8437 /* Now create the child process. */
\r
8439 siStartInfo.cb = sizeof(STARTUPINFO);
\r
8440 siStartInfo.lpReserved = NULL;
\r
8441 siStartInfo.lpDesktop = NULL;
\r
8442 siStartInfo.lpTitle = NULL;
\r
8443 siStartInfo.dwFlags = STARTF_USESTDHANDLES;
\r
8444 siStartInfo.cbReserved2 = 0;
\r
8445 siStartInfo.lpReserved2 = NULL;
\r
8446 siStartInfo.hStdInput = hChildStdinRd;
\r
8447 siStartInfo.hStdOutput = hChildStdoutWr;
\r
8448 siStartInfo.hStdError = hChildStdoutWr;
\r
8450 fSuccess = CreateProcess(NULL,
\r
8451 cmdLine, /* command line */
\r
8452 NULL, /* process security attributes */
\r
8453 NULL, /* primary thread security attrs */
\r
8454 TRUE, /* handles are inherited */
\r
8455 DETACHED_PROCESS|CREATE_NEW_PROCESS_GROUP,
\r
8456 NULL, /* use parent's environment */
\r
8458 &siStartInfo, /* STARTUPINFO pointer */
\r
8459 &piProcInfo); /* receives PROCESS_INFORMATION */
\r
8461 err = GetLastError();
\r
8462 SetCurrentDirectory(buf); /* return to prev directory */
\r
8467 if (appData.niceEngines){ // [HGM] nice: adjust engine proc priority
\r
8468 if(appData.debugMode) fprintf(debugFP, "nice engine proc to %d\n", appData.niceEngines);
\r
8469 SetPriorityClass(piProcInfo.hProcess, GetWin32Priority(appData.niceEngines));
\r
8472 /* Close the handles we don't need in the parent */
\r
8473 CloseHandle(piProcInfo.hThread);
\r
8474 CloseHandle(hChildStdinRd);
\r
8475 CloseHandle(hChildStdoutWr);
\r
8477 /* Prepare return value */
\r
8478 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8479 cp->kind = CPReal;
\r
8480 cp->hProcess = piProcInfo.hProcess;
\r
8481 cp->pid = piProcInfo.dwProcessId;
\r
8482 cp->hFrom = hChildStdoutRdDup;
\r
8483 cp->hTo = hChildStdinWrDup;
\r
8485 *pr = (void *) cp;
\r
8487 /* Klaus Friedel says that this Sleep solves a problem under Windows
\r
8488 2000 where engines sometimes don't see the initial command(s)
\r
8489 from WinBoard and hang. I don't understand how that can happen,
\r
8490 but the Sleep is harmless, so I've put it in. Others have also
\r
8491 reported what may be the same problem, so hopefully this will fix
\r
8492 it for them too. */
\r
8500 DestroyChildProcess(ProcRef pr, int/*boolean*/ signal)
\r
8502 ChildProc *cp; int result;
\r
8504 cp = (ChildProc *) pr;
\r
8505 if (cp == NULL) return;
\r
8507 switch (cp->kind) {
\r
8509 /* TerminateProcess is considered harmful, so... */
\r
8510 CloseHandle(cp->hTo); /* Closing this will give the child an EOF and hopefully kill it */
\r
8511 if (cp->hFrom) CloseHandle(cp->hFrom); /* if NULL, InputThread will close it */
\r
8512 /* The following doesn't work because the chess program
\r
8513 doesn't "have the same console" as WinBoard. Maybe
\r
8514 we could arrange for this even though neither WinBoard
\r
8515 nor the chess program uses a console for stdio? */
\r
8516 /*!!if (signal) GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, cp->pid);*/
\r
8518 /* [AS] Special termination modes for misbehaving programs... */
\r
8519 if( signal == 9 ) {
\r
8520 result = TerminateProcess( cp->hProcess, 0 );
\r
8522 if ( appData.debugMode) {
\r
8523 fprintf( debugFP, "Terminating process %lu, result=%d\n", cp->pid, result );
\r
8526 else if( signal == 10 ) {
\r
8527 DWORD dw = WaitForSingleObject( cp->hProcess, 3*1000 ); // Wait 3 seconds at most
\r
8529 if( dw != WAIT_OBJECT_0 ) {
\r
8530 result = TerminateProcess( cp->hProcess, 0 );
\r
8532 if ( appData.debugMode) {
\r
8533 fprintf( debugFP, "Process %lu still alive after timeout, killing... result=%d\n", cp->pid, result );
\r
8539 CloseHandle(cp->hProcess);
\r
8543 if (cp->hFrom) CloseHandle(cp->hFrom);
\r
8547 closesocket(cp->sock);
\r
8552 if (signal) send(cp->sock2, "\017", 1, 0); /* 017 = 15 = SIGTERM */
\r
8553 closesocket(cp->sock);
\r
8554 closesocket(cp->sock2);
\r
8562 InterruptChildProcess(ProcRef pr)
\r
8566 cp = (ChildProc *) pr;
\r
8567 if (cp == NULL) return;
\r
8568 switch (cp->kind) {
\r
8570 /* The following doesn't work because the chess program
\r
8571 doesn't "have the same console" as WinBoard. Maybe
\r
8572 we could arrange for this even though neither WinBoard
\r
8573 nor the chess program uses a console for stdio */
\r
8574 /*!!GenerateConsoleCtrlEvent(CTRL_C_EVENT, cp->pid);*/
\r
8579 /* Can't interrupt */
\r
8583 send(cp->sock2, "\002", 1, 0); /* 2 = SIGINT */
\r
8590 OpenTelnet(char *host, char *port, ProcRef *pr)
\r
8592 char cmdLine[MSG_SIZ];
\r
8594 if (port[0] == NULLCHAR) {
\r
8595 sprintf(cmdLine, "%s %s", appData.telnetProgram, host);
\r
8597 sprintf(cmdLine, "%s %s %s", appData.telnetProgram, host, port);
\r
8599 return StartChildProcess(cmdLine, "", pr);
\r
8603 /* Code to open TCP sockets */
\r
8606 OpenTCP(char *host, char *port, ProcRef *pr)
\r
8611 struct sockaddr_in sa, mysa;
\r
8612 struct hostent FAR *hp;
\r
8613 unsigned short uport;
\r
8614 WORD wVersionRequested;
\r
8617 /* Initialize socket DLL */
\r
8618 wVersionRequested = MAKEWORD(1, 1);
\r
8619 err = WSAStartup(wVersionRequested, &wsaData);
\r
8620 if (err != 0) return err;
\r
8623 if ((s = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8624 err = WSAGetLastError();
\r
8629 /* Bind local address using (mostly) don't-care values.
\r
8631 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8632 mysa.sin_family = AF_INET;
\r
8633 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8634 uport = (unsigned short) 0;
\r
8635 mysa.sin_port = htons(uport);
\r
8636 if (bind(s, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8637 == SOCKET_ERROR) {
\r
8638 err = WSAGetLastError();
\r
8643 /* Resolve remote host name */
\r
8644 memset((char *) &sa, 0, sizeof(struct sockaddr_in));
\r
8645 if (!(hp = gethostbyname(host))) {
\r
8646 unsigned int b0, b1, b2, b3;
\r
8648 err = WSAGetLastError();
\r
8650 if (sscanf(host, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) == 4) {
\r
8651 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
\r
8652 hp->h_addrtype = AF_INET;
\r
8654 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
\r
8655 hp->h_addr_list[0] = (char *) malloc(4);
\r
8656 hp->h_addr_list[0][0] = (char) b0;
\r
8657 hp->h_addr_list[0][1] = (char) b1;
\r
8658 hp->h_addr_list[0][2] = (char) b2;
\r
8659 hp->h_addr_list[0][3] = (char) b3;
\r
8665 sa.sin_family = hp->h_addrtype;
\r
8666 uport = (unsigned short) atoi(port);
\r
8667 sa.sin_port = htons(uport);
\r
8668 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
\r
8670 /* Make connection */
\r
8671 if (connect(s, (struct sockaddr *) &sa,
\r
8672 sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
\r
8673 err = WSAGetLastError();
\r
8678 /* Prepare return value */
\r
8679 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8680 cp->kind = CPSock;
\r
8682 *pr = (ProcRef *) cp;
\r
8688 OpenCommPort(char *name, ProcRef *pr)
\r
8693 char fullname[MSG_SIZ];
\r
8695 if (*name != '\\')
\r
8696 sprintf(fullname, "\\\\.\\%s", name);
\r
8698 strcpy(fullname, name);
\r
8700 h = CreateFile(name, GENERIC_READ | GENERIC_WRITE,
\r
8701 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
\r
8702 if (h == (HANDLE) -1) {
\r
8703 return GetLastError();
\r
8707 if (!SetCommState(h, (LPDCB) &dcb)) return GetLastError();
\r
8709 /* Accumulate characters until a 100ms pause, then parse */
\r
8710 ct.ReadIntervalTimeout = 100;
\r
8711 ct.ReadTotalTimeoutMultiplier = 0;
\r
8712 ct.ReadTotalTimeoutConstant = 0;
\r
8713 ct.WriteTotalTimeoutMultiplier = 0;
\r
8714 ct.WriteTotalTimeoutConstant = 0;
\r
8715 if (!SetCommTimeouts(h, (LPCOMMTIMEOUTS) &ct)) return GetLastError();
\r
8717 /* Prepare return value */
\r
8718 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8719 cp->kind = CPComm;
\r
8722 *pr = (ProcRef *) cp;
\r
8728 OpenLoopback(ProcRef *pr)
\r
8730 DisplayFatalError("Not implemented", 0, 1);
\r
8736 OpenRcmd(char* host, char* user, char* cmd, ProcRef* pr)
\r
8741 struct sockaddr_in sa, mysa;
\r
8742 struct hostent FAR *hp;
\r
8743 unsigned short uport;
\r
8744 WORD wVersionRequested;
\r
8747 char stderrPortStr[MSG_SIZ];
\r
8749 /* Initialize socket DLL */
\r
8750 wVersionRequested = MAKEWORD(1, 1);
\r
8751 err = WSAStartup(wVersionRequested, &wsaData);
\r
8752 if (err != 0) return err;
\r
8754 /* Resolve remote host name */
\r
8755 memset((char *) &sa, 0, sizeof(struct sockaddr_in));
\r
8756 if (!(hp = gethostbyname(host))) {
\r
8757 unsigned int b0, b1, b2, b3;
\r
8759 err = WSAGetLastError();
\r
8761 if (sscanf(host, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) == 4) {
\r
8762 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
\r
8763 hp->h_addrtype = AF_INET;
\r
8765 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
\r
8766 hp->h_addr_list[0] = (char *) malloc(4);
\r
8767 hp->h_addr_list[0][0] = (char) b0;
\r
8768 hp->h_addr_list[0][1] = (char) b1;
\r
8769 hp->h_addr_list[0][2] = (char) b2;
\r
8770 hp->h_addr_list[0][3] = (char) b3;
\r
8776 sa.sin_family = hp->h_addrtype;
\r
8777 uport = (unsigned short) 514;
\r
8778 sa.sin_port = htons(uport);
\r
8779 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
\r
8781 /* Bind local socket to unused "privileged" port address
\r
8783 s = INVALID_SOCKET;
\r
8784 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8785 mysa.sin_family = AF_INET;
\r
8786 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8787 for (fromPort = 1023;; fromPort--) {
\r
8788 if (fromPort < 0) {
\r
8790 return WSAEADDRINUSE;
\r
8792 if (s == INVALID_SOCKET) {
\r
8793 if ((s = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8794 err = WSAGetLastError();
\r
8799 uport = (unsigned short) fromPort;
\r
8800 mysa.sin_port = htons(uport);
\r
8801 if (bind(s, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8802 == SOCKET_ERROR) {
\r
8803 err = WSAGetLastError();
\r
8804 if (err == WSAEADDRINUSE) continue;
\r
8808 if (connect(s, (struct sockaddr *) &sa,
\r
8809 sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
\r
8810 err = WSAGetLastError();
\r
8811 if (err == WSAEADDRINUSE) {
\r
8822 /* Bind stderr local socket to unused "privileged" port address
\r
8824 s2 = INVALID_SOCKET;
\r
8825 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8826 mysa.sin_family = AF_INET;
\r
8827 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8828 for (fromPort = 1023;; fromPort--) {
\r
8829 if (fromPort == prevStderrPort) continue; // don't reuse port
\r
8830 if (fromPort < 0) {
\r
8831 (void) closesocket(s);
\r
8833 return WSAEADDRINUSE;
\r
8835 if (s2 == INVALID_SOCKET) {
\r
8836 if ((s2 = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8837 err = WSAGetLastError();
\r
8843 uport = (unsigned short) fromPort;
\r
8844 mysa.sin_port = htons(uport);
\r
8845 if (bind(s2, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8846 == SOCKET_ERROR) {
\r
8847 err = WSAGetLastError();
\r
8848 if (err == WSAEADDRINUSE) continue;
\r
8849 (void) closesocket(s);
\r
8853 if (listen(s2, 1) == SOCKET_ERROR) {
\r
8854 err = WSAGetLastError();
\r
8855 if (err == WSAEADDRINUSE) {
\r
8857 s2 = INVALID_SOCKET;
\r
8860 (void) closesocket(s);
\r
8861 (void) closesocket(s2);
\r
8867 prevStderrPort = fromPort; // remember port used
\r
8868 sprintf(stderrPortStr, "%d", fromPort);
\r
8870 if (send(s, stderrPortStr, strlen(stderrPortStr) + 1, 0) == SOCKET_ERROR) {
\r
8871 err = WSAGetLastError();
\r
8872 (void) closesocket(s);
\r
8873 (void) closesocket(s2);
\r
8878 if (send(s, UserName(), strlen(UserName()) + 1, 0) == SOCKET_ERROR) {
\r
8879 err = WSAGetLastError();
\r
8880 (void) closesocket(s);
\r
8881 (void) closesocket(s2);
\r
8885 if (*user == NULLCHAR) user = UserName();
\r
8886 if (send(s, user, strlen(user) + 1, 0) == SOCKET_ERROR) {
\r
8887 err = WSAGetLastError();
\r
8888 (void) closesocket(s);
\r
8889 (void) closesocket(s2);
\r
8893 if (send(s, cmd, strlen(cmd) + 1, 0) == SOCKET_ERROR) {
\r
8894 err = WSAGetLastError();
\r
8895 (void) closesocket(s);
\r
8896 (void) closesocket(s2);
\r
8901 if ((s3 = accept(s2, NULL, NULL)) == INVALID_SOCKET) {
\r
8902 err = WSAGetLastError();
\r
8903 (void) closesocket(s);
\r
8904 (void) closesocket(s2);
\r
8908 (void) closesocket(s2); /* Stop listening */
\r
8910 /* Prepare return value */
\r
8911 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8912 cp->kind = CPRcmd;
\r
8915 *pr = (ProcRef *) cp;
\r
8922 AddInputSource(ProcRef pr, int lineByLine,
\r
8923 InputCallback func, VOIDSTAR closure)
\r
8925 InputSource *is, *is2 = NULL;
\r
8926 ChildProc *cp = (ChildProc *) pr;
\r
8928 is = (InputSource *) calloc(1, sizeof(InputSource));
\r
8929 is->lineByLine = lineByLine;
\r
8931 is->closure = closure;
\r
8932 is->second = NULL;
\r
8933 is->next = is->buf;
\r
8934 if (pr == NoProc) {
\r
8935 is->kind = CPReal;
\r
8936 consoleInputSource = is;
\r
8938 is->kind = cp->kind;
\r
8940 [AS] Try to avoid a race condition if the thread is given control too early:
\r
8941 we create all threads suspended so that the is->hThread variable can be
\r
8942 safely assigned, then let the threads start with ResumeThread.
\r
8944 switch (cp->kind) {
\r
8946 is->hFile = cp->hFrom;
\r
8947 cp->hFrom = NULL; /* now owned by InputThread */
\r
8949 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) NonOvlInputThread,
\r
8950 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8954 is->hFile = cp->hFrom;
\r
8955 cp->hFrom = NULL; /* now owned by InputThread */
\r
8957 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) InputThread,
\r
8958 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8962 is->sock = cp->sock;
\r
8964 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8965 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8969 is2 = (InputSource *) calloc(1, sizeof(InputSource));
\r
8971 is->sock = cp->sock;
\r
8973 is2->sock = cp->sock2;
\r
8974 is2->second = is2;
\r
8976 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8977 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8979 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8980 (LPVOID) is2, CREATE_SUSPENDED, &is2->id);
\r
8984 if( is->hThread != NULL ) {
\r
8985 ResumeThread( is->hThread );
\r
8988 if( is2 != NULL && is2->hThread != NULL ) {
\r
8989 ResumeThread( is2->hThread );
\r
8993 return (InputSourceRef) is;
\r
8997 RemoveInputSource(InputSourceRef isr)
\r
9001 is = (InputSource *) isr;
\r
9002 is->hThread = NULL; /* tell thread to stop */
\r
9003 CloseHandle(is->hThread);
\r
9004 if (is->second != NULL) {
\r
9005 is->second->hThread = NULL;
\r
9006 CloseHandle(is->second->hThread);
\r
9010 int no_wrap(char *message, int count)
\r
9012 ConsoleOutput(message, count, FALSE);
\r
9017 OutputToProcess(ProcRef pr, char *message, int count, int *outError)
\r
9020 int outCount = SOCKET_ERROR;
\r
9021 ChildProc *cp = (ChildProc *) pr;
\r
9022 static OVERLAPPED ovl;
\r
9023 static int line = 0;
\r
9027 if (appData.noJoin || !appData.useInternalWrap)
\r
9028 return no_wrap(message, count);
\r
9031 int width = get_term_width();
\r
9032 int len = wrap(NULL, message, count, width, &line);
\r
9033 char *msg = malloc(len);
\r
9037 return no_wrap(message, count);
\r
9040 dbgchk = wrap(msg, message, count, width, &line);
\r
9041 if (dbgchk != len && appData.debugMode)
\r
9042 fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
\r
9043 ConsoleOutput(msg, len, FALSE);
\r
9050 if (ovl.hEvent == NULL) {
\r
9051 ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
\r
9053 ovl.Internal = ovl.InternalHigh = ovl.Offset = ovl.OffsetHigh = 0;
\r
9055 switch (cp->kind) {
\r
9058 outCount = send(cp->sock, message, count, 0);
\r
9059 if (outCount == SOCKET_ERROR) {
\r
9060 *outError = WSAGetLastError();
\r
9062 *outError = NO_ERROR;
\r
9067 if (WriteFile(((ChildProc *)pr)->hTo, message, count,
\r
9068 &dOutCount, NULL)) {
\r
9069 *outError = NO_ERROR;
\r
9070 outCount = (int) dOutCount;
\r
9072 *outError = GetLastError();
\r
9077 *outError = DoWriteFile(((ChildProc *)pr)->hTo, message, count,
\r
9078 &dOutCount, &ovl);
\r
9079 if (*outError == NO_ERROR) {
\r
9080 outCount = (int) dOutCount;
\r
9088 OutputToProcessDelayed(ProcRef pr, char *message, int count, int *outError,
\r
9091 /* Ignore delay, not implemented for WinBoard */
\r
9092 return OutputToProcess(pr, message, count, outError);
\r
9097 CmailSigHandlerCallBack(InputSourceRef isr, VOIDSTAR closure,
\r
9098 char *buf, int count, int error)
\r
9100 DisplayFatalError("Not implemented", 0, 1);
\r
9103 /* see wgamelist.c for Game List functions */
\r
9104 /* see wedittags.c for Edit Tags functions */
\r
9111 char buf[MSG_SIZ];
\r
9114 if (SearchPath(installDir, appData.icsLogon, NULL, MSG_SIZ, buf, &dummy)) {
\r
9115 f = fopen(buf, "r");
\r
9117 ProcessICSInitScript(f);
\r
9125 StartAnalysisClock()
\r
9127 if (analysisTimerEvent) return;
\r
9128 analysisTimerEvent = SetTimer(hwndMain, (UINT) ANALYSIS_TIMER_ID,
\r
9129 (UINT) 2000, NULL);
\r
9133 SetHighlights(int fromX, int fromY, int toX, int toY)
\r
9135 highlightInfo.sq[0].x = fromX;
\r
9136 highlightInfo.sq[0].y = fromY;
\r
9137 highlightInfo.sq[1].x = toX;
\r
9138 highlightInfo.sq[1].y = toY;
\r
9144 highlightInfo.sq[0].x = highlightInfo.sq[0].y =
\r
9145 highlightInfo.sq[1].x = highlightInfo.sq[1].y = -1;
\r
9149 SetPremoveHighlights(int fromX, int fromY, int toX, int toY)
\r
9151 premoveHighlightInfo.sq[0].x = fromX;
\r
9152 premoveHighlightInfo.sq[0].y = fromY;
\r
9153 premoveHighlightInfo.sq[1].x = toX;
\r
9154 premoveHighlightInfo.sq[1].y = toY;
\r
9158 ClearPremoveHighlights()
\r
9160 premoveHighlightInfo.sq[0].x = premoveHighlightInfo.sq[0].y =
\r
9161 premoveHighlightInfo.sq[1].x = premoveHighlightInfo.sq[1].y = -1;
\r
9165 ShutDownFrontEnd()
\r
9167 if (saveSettingsOnExit) SaveSettings(settingsFileName);
\r
9168 DeleteClipboardTempFiles();
\r
9174 if (IsIconic(hwndMain))
\r
9175 ShowWindow(hwndMain, SW_RESTORE);
\r
9177 SetActiveWindow(hwndMain);
\r
9181 * Prototypes for animation support routines
\r
9183 static void ScreenSquare(int column, int row, POINT * pt);
\r
9184 static void Tween( POINT * start, POINT * mid, POINT * finish, int factor,
\r
9185 POINT frames[], int * nFrames);
\r
9189 AnimateAtomicCapture(int fromX, int fromY, int toX, int toY, int nFrames)
\r
9190 { // [HGM] atomic: animate blast wave
\r
9192 if(appData.debugMode) fprintf(debugFP, "exploding (%d,%d)\n", toX, toY);
\r
9193 explodeInfo.fromX = fromX;
\r
9194 explodeInfo.fromY = fromY;
\r
9195 explodeInfo.toX = toX;
\r
9196 explodeInfo.toY = toY;
\r
9197 for(i=1; i<nFrames; i++) {
\r
9198 explodeInfo.radius = (i*180)/(nFrames-1);
\r
9199 DrawPosition(FALSE, NULL);
\r
9200 Sleep(appData.animSpeed);
\r
9202 explodeInfo.radius = 0;
\r
9203 DrawPosition(TRUE, NULL);
\r
9209 AnimateMove(board, fromX, fromY, toX, toY)
\r
9216 ChessSquare piece;
\r
9217 POINT start, finish, mid;
\r
9218 POINT frames[kFactor * 2 + 1];
\r
9221 if (!appData.animate) return;
\r
9222 if (doingSizing) return;
\r
9223 if (fromY < 0 || fromX < 0) return;
\r
9224 piece = board[fromY][fromX];
\r
9225 if (piece >= EmptySquare) return;
\r
9227 ScreenSquare(fromX, fromY, &start);
\r
9228 ScreenSquare(toX, toY, &finish);
\r
9230 /* All pieces except knights move in straight line */
\r
9231 if (piece != WhiteKnight && piece != BlackKnight) {
\r
9232 mid.x = start.x + (finish.x - start.x) / 2;
\r
9233 mid.y = start.y + (finish.y - start.y) / 2;
\r
9235 /* Knight: make diagonal movement then straight */
\r
9236 if (abs(toY - fromY) < abs(toX - fromX)) {
\r
9237 mid.x = start.x + (finish.x - start.x) / 2;
\r
9241 mid.y = start.y + (finish.y - start.y) / 2;
\r
9245 /* Don't use as many frames for very short moves */
\r
9246 if (abs(toY - fromY) + abs(toX - fromX) <= 2)
\r
9247 Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
\r
9249 Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
\r
9251 animInfo.from.x = fromX;
\r
9252 animInfo.from.y = fromY;
\r
9253 animInfo.to.x = toX;
\r
9254 animInfo.to.y = toY;
\r
9255 animInfo.lastpos = start;
\r
9256 animInfo.piece = piece;
\r
9257 for (n = 0; n < nFrames; n++) {
\r
9258 animInfo.pos = frames[n];
\r
9259 DrawPosition(FALSE, NULL);
\r
9260 animInfo.lastpos = animInfo.pos;
\r
9261 Sleep(appData.animSpeed);
\r
9263 animInfo.pos = finish;
\r
9264 DrawPosition(FALSE, NULL);
\r
9265 animInfo.piece = EmptySquare;
\r
9266 if(gameInfo.variant == VariantAtomic &&
\r
9267 (board[toY][toX] != EmptySquare || fromX != toX && (piece == WhitePawn || piece == BlackPawn) ) )
\r
9268 AnimateAtomicCapture(fromX, fromY, toX, toY, 2*nFrames);
\r
9271 /* Convert board position to corner of screen rect and color */
\r
9274 ScreenSquare(column, row, pt)
\r
9275 int column; int row; POINT * pt;
\r
9278 pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
\r
9279 pt->y = lineGap + row * (squareSize + lineGap);
\r
9281 pt->x = lineGap + column * (squareSize + lineGap);
\r
9282 pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
\r
9286 /* Generate a series of frame coords from start->mid->finish.
\r
9287 The movement rate doubles until the half way point is
\r
9288 reached, then halves back down to the final destination,
\r
9289 which gives a nice slow in/out effect. The algorithmn
\r
9290 may seem to generate too many intermediates for short
\r
9291 moves, but remember that the purpose is to attract the
\r
9292 viewers attention to the piece about to be moved and
\r
9293 then to where it ends up. Too few frames would be less
\r
9297 Tween(start, mid, finish, factor, frames, nFrames)
\r
9298 POINT * start; POINT * mid;
\r
9299 POINT * finish; int factor;
\r
9300 POINT frames[]; int * nFrames;
\r
9302 int n, fraction = 1, count = 0;
\r
9304 /* Slow in, stepping 1/16th, then 1/8th, ... */
\r
9305 for (n = 0; n < factor; n++)
\r
9307 for (n = 0; n < factor; n++) {
\r
9308 frames[count].x = start->x + (mid->x - start->x) / fraction;
\r
9309 frames[count].y = start->y + (mid->y - start->y) / fraction;
\r
9311 fraction = fraction / 2;
\r
9315 frames[count] = *mid;
\r
9318 /* Slow out, stepping 1/2, then 1/4, ... */
\r
9320 for (n = 0; n < factor; n++) {
\r
9321 frames[count].x = finish->x - (finish->x - mid->x) / fraction;
\r
9322 frames[count].y = finish->y - (finish->y - mid->y) / fraction;
\r
9324 fraction = fraction * 2;
\r
9330 HistorySet( char movelist[][2*MOVE_LEN], int first, int last, int current )
\r
9332 MoveHistorySet( movelist, first, last, current, pvInfoList );
\r
9334 EvalGraphSet( first, last, current, pvInfoList );
\r