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, 2010 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((char *s));
\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 if(!strcmp(command, "chat")) { ChatPopUp(name); return; }
\r
6392 sprintf(buf, "%s %s ", command, name); /* trailing space */
\r
6393 SetWindowText(hInput, buf);
\r
6394 sel.cpMin = 999999;
\r
6395 sel.cpMax = 999999;
\r
6396 SendMessage(hInput, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6402 ConsoleTextSubclass(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
6407 switch (message) {
\r
6409 if (!(GetKeyState(VK_CONTROL) & ~1)) break;
\r
6412 SendMessage(hwnd, EM_LINESCROLL, 0, -999999);
\r
6415 sel.cpMin = 999999;
\r
6416 sel.cpMax = 999999;
\r
6417 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6418 SendMessage(hwnd, EM_SCROLLCARET, 0, 0);
\r
6423 if(wParam != '\022') {
\r
6424 if (wParam == '\t') {
\r
6425 if (GetKeyState(VK_SHIFT) < 0) {
\r
6427 if (IsIconic(hwndMain)) ShowWindow(hwndMain, SW_RESTORE);
\r
6428 if (buttonDesc[0].hwnd) {
\r
6429 SetFocus(buttonDesc[0].hwnd);
\r
6431 SetFocus(hwndMain);
\r
6435 SetFocus(GetDlgItem(hwndConsole, OPT_ConsoleInput));
\r
6438 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6439 JAWS_DELETE( SetFocus(hInput); )
\r
6440 SendMessage(hInput, message, wParam, lParam);
\r
6443 } // [HGM] navigate: for Ctrl+R, flow into nex case (moved up here) to summon up menu
\r
6444 case WM_RBUTTONUP:
\r
6445 if (GetKeyState(VK_SHIFT) & ~1) {
\r
6446 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6447 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6450 HMENU hmenu = LoadIcsTextMenu(icsTextMenuEntry);
\r
6451 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6452 if (sel.cpMin == sel.cpMax) {
\r
6453 EnableMenuItem(hmenu, IDM_Copy, MF_BYCOMMAND|MF_GRAYED);
\r
6454 EnableMenuItem(hmenu, IDM_QuickPaste, MF_BYCOMMAND|MF_GRAYED);
\r
6456 if (!IsClipboardFormatAvailable(CF_TEXT)) {
\r
6457 EnableMenuItem(hmenu, IDM_Paste, MF_BYCOMMAND|MF_GRAYED);
\r
6459 pt.x = LOWORD(lParam);
\r
6460 pt.y = HIWORD(lParam);
\r
6461 MenuPopup(hwnd, pt, hmenu, -1);
\r
6465 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6467 return SendMessage(hInput, message, wParam, lParam);
\r
6468 case WM_MBUTTONDOWN:
\r
6469 return SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6470 case WM_RBUTTONDOWN:
\r
6471 if (!(GetKeyState(VK_SHIFT) & ~1)) {
\r
6472 /* Move selection here if it was empty */
\r
6474 pt.x = LOWORD(lParam);
\r
6475 pt.y = HIWORD(lParam);
\r
6476 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6477 if (sel.cpMin == sel.cpMax) {
\r
6478 sel.cpMin = SendMessage(hwnd, EM_CHARFROMPOS, 0, (LPARAM)&pt); /*doc is wrong*/
\r
6479 sel.cpMax = sel.cpMin;
\r
6480 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6482 SendMessage(hwnd, EM_HIDESELECTION, FALSE, FALSE);
\r
6486 switch (LOWORD(wParam)) {
\r
6487 case IDM_QuickPaste:
\r
6489 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6490 if (sel.cpMin == sel.cpMax) {
\r
6491 MessageBeep(MB_ICONEXCLAMATION);
\r
6494 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6495 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
6496 SendMessage(hInput, WM_PASTE, 0, 0);
\r
6501 SendMessage(hwnd, WM_CUT, 0, 0);
\r
6504 SendMessage(hwnd, WM_PASTE, 0, 0);
\r
6507 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6511 int i = LOWORD(wParam) - IDM_CommandX;
\r
6512 if (i >= 0 && i < ICS_TEXT_MENU_SIZE &&
\r
6513 icsTextMenuEntry[i].command != NULL) {
\r
6514 CommandX(hwnd, icsTextMenuEntry[i].command,
\r
6515 icsTextMenuEntry[i].getname,
\r
6516 icsTextMenuEntry[i].immediate);
\r
6524 return (*consoleTextWindowProc)(hwnd, message, wParam, lParam);
\r
6527 WNDPROC consoleInputWindowProc;
\r
6530 ConsoleInputSubclass(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
6532 char buf[MSG_SIZ];
\r
6534 static BOOL sendNextChar = FALSE;
\r
6535 static BOOL quoteNextChar = FALSE;
\r
6536 InputSource *is = consoleInputSource;
\r
6540 switch (message) {
\r
6542 if (!appData.localLineEditing || sendNextChar) {
\r
6543 is->buf[0] = (CHAR) wParam;
\r
6545 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
6546 sendNextChar = FALSE;
\r
6549 if (quoteNextChar) {
\r
6550 buf[0] = (char) wParam;
\r
6551 buf[1] = NULLCHAR;
\r
6552 SendMessage(hwnd, EM_REPLACESEL, TRUE, (LPARAM) buf);
\r
6553 quoteNextChar = FALSE;
\r
6557 case '\r': /* Enter key */
\r
6558 is->count = GetWindowText(hwnd, is->buf, INPUT_SOURCE_BUF_SIZE-1);
\r
6559 if (consoleEcho) SaveInHistory(is->buf);
\r
6560 is->buf[is->count++] = '\n';
\r
6561 is->buf[is->count] = NULLCHAR;
\r
6562 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
6563 if (consoleEcho) {
\r
6564 ConsoleOutput(is->buf, is->count, TRUE);
\r
6565 } else if (appData.localLineEditing) {
\r
6566 ConsoleOutput("\n", 1, TRUE);
\r
6569 case '\033': /* Escape key */
\r
6570 SetWindowText(hwnd, "");
\r
6571 cf.cbSize = sizeof(CHARFORMAT);
\r
6572 cf.dwMask = CFM_COLOR|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT;
\r
6573 if (consoleEcho) {
\r
6574 cf.crTextColor = textAttribs[ColorNormal].color;
\r
6576 cf.crTextColor = COLOR_ECHOOFF;
\r
6578 cf.dwEffects = textAttribs[ColorNormal].effects;
\r
6579 SendMessage(hwnd, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
\r
6581 case '\t': /* Tab key */
\r
6582 if (GetKeyState(VK_SHIFT) < 0) {
\r
6584 SetFocus(GetDlgItem(hwndConsole, OPT_ConsoleText));
\r
6587 if (IsIconic(hwndMain)) ShowWindow(hwndMain, SW_RESTORE);
\r
6588 if (buttonDesc[0].hwnd) {
\r
6589 SetFocus(buttonDesc[0].hwnd);
\r
6591 SetFocus(hwndMain);
\r
6595 case '\023': /* Ctrl+S */
\r
6596 sendNextChar = TRUE;
\r
6598 case '\021': /* Ctrl+Q */
\r
6599 quoteNextChar = TRUE;
\r
6609 GetWindowText(hwnd, buf, MSG_SIZ);
\r
6610 p = PrevInHistory(buf);
\r
6612 SetWindowText(hwnd, p);
\r
6613 sel.cpMin = 999999;
\r
6614 sel.cpMax = 999999;
\r
6615 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6620 p = NextInHistory();
\r
6622 SetWindowText(hwnd, p);
\r
6623 sel.cpMin = 999999;
\r
6624 sel.cpMax = 999999;
\r
6625 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6631 if (!(GetKeyState(VK_CONTROL) & ~1)) break;
\r
6635 SendDlgItemMessage(hwndConsole, OPT_ConsoleText, message, wParam, lParam);
\r
6639 case WM_MBUTTONDOWN:
\r
6640 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6641 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6643 case WM_RBUTTONUP:
\r
6644 if (GetKeyState(VK_SHIFT) & ~1) {
\r
6645 SendDlgItemMessage(hwndConsole, OPT_ConsoleText,
\r
6646 WM_COMMAND, MAKEWPARAM(IDM_QuickPaste, 0), 0);
\r
6650 hmenu = LoadMenu(hInst, "InputMenu");
\r
6651 SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM)&sel);
\r
6652 if (sel.cpMin == sel.cpMax) {
\r
6653 EnableMenuItem(hmenu, IDM_Copy, MF_BYCOMMAND|MF_GRAYED);
\r
6654 EnableMenuItem(hmenu, IDM_Cut, MF_BYCOMMAND|MF_GRAYED);
\r
6656 if (!IsClipboardFormatAvailable(CF_TEXT)) {
\r
6657 EnableMenuItem(hmenu, IDM_Paste, MF_BYCOMMAND|MF_GRAYED);
\r
6659 pt.x = LOWORD(lParam);
\r
6660 pt.y = HIWORD(lParam);
\r
6661 MenuPopup(hwnd, pt, hmenu, -1);
\r
6665 switch (LOWORD(wParam)) {
\r
6667 SendMessage(hwnd, EM_UNDO, 0, 0);
\r
6669 case IDM_SelectAll:
\r
6671 sel.cpMax = -1; /*999999?*/
\r
6672 SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6675 SendMessage(hwnd, WM_CUT, 0, 0);
\r
6678 SendMessage(hwnd, WM_PASTE, 0, 0);
\r
6681 SendMessage(hwnd, WM_COPY, 0, 0);
\r
6686 return (*consoleInputWindowProc)(hwnd, message, wParam, lParam);
\r
6689 #define CO_MAX 100000
\r
6690 #define CO_TRIM 1000
\r
6693 ConsoleWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
6695 static SnapData sd;
\r
6696 HWND hText, hInput;
\r
6698 static int sizeX, sizeY;
\r
6699 int newSizeX, newSizeY;
\r
6703 hText = GetDlgItem(hDlg, OPT_ConsoleText);
\r
6704 hInput = GetDlgItem(hDlg, OPT_ConsoleInput);
\r
6706 switch (message) {
\r
6708 if (((NMHDR*)lParam)->code == EN_LINK)
\r
6710 ENLINK *pLink = (ENLINK*)lParam;
\r
6711 if (pLink->msg == WM_LBUTTONUP)
\r
6715 tr.chrg = pLink->chrg;
\r
6716 tr.lpstrText = malloc(1+tr.chrg.cpMax-tr.chrg.cpMin);
\r
6717 SendMessage(hText, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
\r
6718 ShellExecute(NULL, "open", tr.lpstrText, NULL, NULL, SW_SHOW);
\r
6719 free(tr.lpstrText);
\r
6723 case WM_INITDIALOG: /* message: initialize dialog box */
\r
6724 hwndConsole = hDlg;
\r
6726 consoleTextWindowProc = (WNDPROC)
\r
6727 SetWindowLong(hText, GWL_WNDPROC, (LONG) ConsoleTextSubclass);
\r
6728 SendMessage(hText, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
6729 consoleInputWindowProc = (WNDPROC)
\r
6730 SetWindowLong(hInput, GWL_WNDPROC, (LONG) ConsoleInputSubclass);
\r
6731 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
6732 Colorize(ColorNormal, TRUE);
\r
6733 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM) &consoleCF);
\r
6734 ChangedConsoleFont();
\r
6735 GetClientRect(hDlg, &rect);
\r
6736 sizeX = rect.right;
\r
6737 sizeY = rect.bottom;
\r
6738 if (wpConsole.x != CW_USEDEFAULT && wpConsole.y != CW_USEDEFAULT &&
\r
6739 wpConsole.width != CW_USEDEFAULT && wpConsole.height != CW_USEDEFAULT) {
\r
6740 WINDOWPLACEMENT wp;
\r
6741 EnsureOnScreen(&wpConsole.x, &wpConsole.y, 0, 0);
\r
6742 wp.length = sizeof(WINDOWPLACEMENT);
\r
6744 wp.showCmd = SW_SHOW;
\r
6745 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
6746 wp.rcNormalPosition.left = wpConsole.x;
\r
6747 wp.rcNormalPosition.right = wpConsole.x + wpConsole.width;
\r
6748 wp.rcNormalPosition.top = wpConsole.y;
\r
6749 wp.rcNormalPosition.bottom = wpConsole.y + wpConsole.height;
\r
6750 SetWindowPlacement(hDlg, &wp);
\r
6753 // [HGM] Chessknight's change 2004-07-13
\r
6754 else { /* Determine Defaults */
\r
6755 WINDOWPLACEMENT wp;
\r
6756 wpConsole.x = wpMain.width + 1;
\r
6757 wpConsole.y = wpMain.y;
\r
6758 wpConsole.width = screenWidth - wpMain.width;
\r
6759 wpConsole.height = wpMain.height;
\r
6760 EnsureOnScreen(&wpConsole.x, &wpConsole.y, 0, 0);
\r
6761 wp.length = sizeof(WINDOWPLACEMENT);
\r
6763 wp.showCmd = SW_SHOW;
\r
6764 wp.ptMaxPosition.x = wp.ptMaxPosition.y = 0;
\r
6765 wp.rcNormalPosition.left = wpConsole.x;
\r
6766 wp.rcNormalPosition.right = wpConsole.x + wpConsole.width;
\r
6767 wp.rcNormalPosition.top = wpConsole.y;
\r
6768 wp.rcNormalPosition.bottom = wpConsole.y + wpConsole.height;
\r
6769 SetWindowPlacement(hDlg, &wp);
\r
6772 // Allow hText to highlight URLs and send notifications on them
\r
6773 wMask = (WORD) SendMessage(hText, EM_GETEVENTMASK, 0, 0L);
\r
6774 SendMessage(hText, EM_SETEVENTMASK, 0, wMask | ENM_LINK);
\r
6775 SendMessage(hText, EM_AUTOURLDETECT, TRUE, 0L);
\r
6776 SetWindowLong(hText, GWL_USERDATA, 79); // initialize the text window's width
\r
6790 if (IsIconic(hDlg)) break;
\r
6791 newSizeX = LOWORD(lParam);
\r
6792 newSizeY = HIWORD(lParam);
\r
6793 if (sizeX != newSizeX || sizeY != newSizeY) {
\r
6794 RECT rectText, rectInput;
\r
6796 int newTextHeight, newTextWidth;
\r
6797 GetWindowRect(hText, &rectText);
\r
6798 newTextWidth = rectText.right - rectText.left + newSizeX - sizeX;
\r
6799 newTextHeight = rectText.bottom - rectText.top + newSizeY - sizeY;
\r
6800 if (newTextHeight < 0) {
\r
6801 newSizeY += -newTextHeight;
\r
6802 newTextHeight = 0;
\r
6804 SetWindowPos(hText, NULL, 0, 0,
\r
6805 newTextWidth, newTextHeight, SWP_NOZORDER|SWP_NOMOVE);
\r
6806 GetWindowRect(hInput, &rectInput); /* gives screen coords */
\r
6807 pt.x = rectInput.left;
\r
6808 pt.y = rectInput.top + newSizeY - sizeY;
\r
6809 ScreenToClient(hDlg, &pt);
\r
6810 SetWindowPos(hInput, NULL,
\r
6811 pt.x, pt.y, /* needs client coords */
\r
6812 rectInput.right - rectInput.left + newSizeX - sizeX,
\r
6813 rectInput.bottom - rectInput.top, SWP_NOZORDER);
\r
6819 case WM_GETMINMAXINFO:
\r
6820 /* Prevent resizing window too small */
\r
6821 mmi = (MINMAXINFO *) lParam;
\r
6822 mmi->ptMinTrackSize.x = 100;
\r
6823 mmi->ptMinTrackSize.y = 100;
\r
6826 /* [AS] Snapping */
\r
6827 case WM_ENTERSIZEMOVE:
\r
6828 return OnEnterSizeMove( &sd, hDlg, wParam, lParam );
\r
6831 return OnSizing( &sd, hDlg, wParam, lParam );
\r
6834 return OnMoving( &sd, hDlg, wParam, lParam );
\r
6836 case WM_EXITSIZEMOVE:
\r
6837 UpdateICSWidth(hText);
\r
6838 return OnExitSizeMove( &sd, hDlg, wParam, lParam );
\r
6841 return DefWindowProc(hDlg, message, wParam, lParam);
\r
6849 if (hwndConsole) return;
\r
6850 hCons = CreateDialog(hInst, szConsoleName, 0, NULL);
\r
6851 SendMessage(hCons, WM_INITDIALOG, 0, 0);
\r
6856 ConsoleOutput(char* data, int length, int forceVisible)
\r
6861 char buf[CO_MAX+1];
\r
6864 static int delayLF = 0;
\r
6865 CHARRANGE savesel, sel;
\r
6867 if (hwndConsole == NULL || length > CO_MAX-100 || length == 0) return;
\r
6875 while (length--) {
\r
6883 } else if (*p == '\007') {
\r
6884 MyPlaySound(&sounds[(int)SoundBell]);
\r
6891 hText = GetDlgItem(hwndConsole, OPT_ConsoleText);
\r
6892 SendMessage(hText, EM_HIDESELECTION, TRUE, FALSE);
\r
6893 /* Save current selection */
\r
6894 SendMessage(hText, EM_EXGETSEL, 0, (LPARAM)&savesel);
\r
6895 exlen = GetWindowTextLength(hText);
\r
6896 /* Find out whether current end of text is visible */
\r
6897 SendMessage(hText, EM_GETRECT, 0, (LPARAM) &rect);
\r
6898 SendMessage(hText, EM_POSFROMCHAR, (WPARAM) &pEnd, exlen);
\r
6899 /* Trim existing text if it's too long */
\r
6900 if (exlen + (q - buf) > CO_MAX) {
\r
6901 trim = (CO_TRIM > (q - buf)) ? CO_TRIM : (q - buf);
\r
6904 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6905 SendMessage(hText, EM_REPLACESEL, 0, (LPARAM)"");
\r
6907 savesel.cpMin -= trim;
\r
6908 savesel.cpMax -= trim;
\r
6909 if (exlen < 0) exlen = 0;
\r
6910 if (savesel.cpMin < 0) savesel.cpMin = 0;
\r
6911 if (savesel.cpMax < savesel.cpMin) savesel.cpMax = savesel.cpMin;
\r
6913 /* Append the new text */
\r
6914 sel.cpMin = exlen;
\r
6915 sel.cpMax = exlen;
\r
6916 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6917 SendMessage(hText, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&consoleCF);
\r
6918 SendMessage(hText, EM_REPLACESEL, 0, (LPARAM) buf);
\r
6919 if (forceVisible || exlen == 0 ||
\r
6920 (rect.left <= pEnd.x && pEnd.x < rect.right &&
\r
6921 rect.top <= pEnd.y && pEnd.y < rect.bottom)) {
\r
6922 /* Scroll to make new end of text visible if old end of text
\r
6923 was visible or new text is an echo of user typein */
\r
6924 sel.cpMin = 9999999;
\r
6925 sel.cpMax = 9999999;
\r
6926 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6927 SendMessage(hText, EM_HIDESELECTION, FALSE, FALSE);
\r
6928 SendMessage(hText, EM_SCROLLCARET, 0, 0);
\r
6929 SendMessage(hText, EM_HIDESELECTION, TRUE, FALSE);
\r
6931 if (savesel.cpMax == exlen || forceVisible) {
\r
6932 /* Move insert point to new end of text if it was at the old
\r
6933 end of text or if the new text is an echo of user typein */
\r
6934 sel.cpMin = 9999999;
\r
6935 sel.cpMax = 9999999;
\r
6936 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&sel);
\r
6938 /* Restore previous selection */
\r
6939 SendMessage(hText, EM_EXSETSEL, 0, (LPARAM)&savesel);
\r
6941 SendMessage(hText, EM_HIDESELECTION, FALSE, FALSE);
\r
6948 DisplayHoldingsCount(HDC hdc, int x, int y, int rightAlign, int copyNumber)
\r
6952 COLORREF oldFg, oldBg;
\r
6956 if(copyNumber > 1) sprintf(buf, "%d", copyNumber); else buf[0] = 0;
\r
6958 oldFg = SetTextColor(hdc, RGB(255, 255, 255)); /* white */
\r
6959 oldBg = SetBkColor(hdc, RGB(0, 0, 0)); /* black */
\r
6960 oldFont = SelectObject(hdc, font[boardSize][CLOCK_FONT]->hf);
\r
6963 rect.right = x + squareSize;
\r
6965 rect.bottom = y + squareSize;
\r
6968 ExtTextOut(hdc, x + MESSAGE_LINE_LEFTMARGIN
\r
6969 + (rightAlign ? (squareSize*2)/3 : 0),
\r
6970 y, ETO_CLIPPED|ETO_OPAQUE,
\r
6971 &rect, str, strlen(str), NULL);
\r
6973 (void) SetTextColor(hdc, oldFg);
\r
6974 (void) SetBkColor(hdc, oldBg);
\r
6975 (void) SelectObject(hdc, oldFont);
\r
6979 DisplayAClock(HDC hdc, int timeRemaining, int highlight,
\r
6980 RECT *rect, char *color, char *flagFell)
\r
6984 COLORREF oldFg, oldBg;
\r
6987 if (appData.clockMode) {
\r
6989 sprintf(buf, "%c %s %s", color[0], TimeString(timeRemaining), flagFell);
\r
6991 sprintf(buf, "%s:%c%s %s", color, (logoHeight>0 ? 0 : ' '), TimeString(timeRemaining), flagFell);
\r
6998 oldFg = SetTextColor(hdc, RGB(255, 255, 255)); /* white */
\r
6999 oldBg = SetBkColor(hdc, RGB(0, 0, 0)); /* black */
\r
7001 oldFg = SetTextColor(hdc, RGB(0, 0, 0)); /* black */
\r
7002 oldBg = SetBkColor(hdc, RGB(255, 255, 255)); /* white */
\r
7004 oldFont = SelectObject(hdc, font[boardSize][CLOCK_FONT]->hf);
\r
7008 ExtTextOut(hdc, rect->left + MESSAGE_LINE_LEFTMARGIN,
\r
7009 rect->top, ETO_CLIPPED|ETO_OPAQUE,
\r
7010 rect, str, strlen(str), NULL);
\r
7011 if(logoHeight > 0 && appData.clockMode) {
\r
7013 sprintf(buf, "%s %s", buf+7, flagFell);
\r
7014 r.top = rect->top + logoHeight/2;
\r
7015 r.left = rect->left;
\r
7016 r.right = rect->right;
\r
7017 r.bottom = rect->bottom;
\r
7018 ExtTextOut(hdc, rect->left + MESSAGE_LINE_LEFTMARGIN,
\r
7019 r.top, ETO_CLIPPED|ETO_OPAQUE,
\r
7020 &r, str, strlen(str), NULL);
\r
7022 (void) SetTextColor(hdc, oldFg);
\r
7023 (void) SetBkColor(hdc, oldBg);
\r
7024 (void) SelectObject(hdc, oldFont);
\r
7029 DoReadFile(HANDLE hFile, char *buf, int count, DWORD *outCount,
\r
7035 if( count <= 0 ) {
\r
7036 if (appData.debugMode) {
\r
7037 fprintf( debugFP, "DoReadFile: trying to read past end of buffer, overflow = %d\n", count );
\r
7040 return ERROR_INVALID_USER_BUFFER;
\r
7043 ResetEvent(ovl->hEvent);
\r
7044 ovl->Offset = ovl->OffsetHigh = 0;
\r
7045 ok = ReadFile(hFile, buf, count, outCount, ovl);
\r
7049 err = GetLastError();
\r
7050 if (err == ERROR_IO_PENDING) {
\r
7051 ok = GetOverlappedResult(hFile, ovl, outCount, TRUE);
\r
7055 err = GetLastError();
\r
7062 DoWriteFile(HANDLE hFile, char *buf, int count, DWORD *outCount,
\r
7067 ResetEvent(ovl->hEvent);
\r
7068 ovl->Offset = ovl->OffsetHigh = 0;
\r
7069 ok = WriteFile(hFile, buf, count, outCount, ovl);
\r
7073 err = GetLastError();
\r
7074 if (err == ERROR_IO_PENDING) {
\r
7075 ok = GetOverlappedResult(hFile, ovl, outCount, TRUE);
\r
7079 err = GetLastError();
\r
7085 /* [AS] If input is line by line and a line exceed the buffer size, force an error */
\r
7086 void CheckForInputBufferFull( InputSource * is )
\r
7088 if( is->lineByLine && (is->next - is->buf) >= INPUT_SOURCE_BUF_SIZE ) {
\r
7089 /* Look for end of line */
\r
7090 char * p = is->buf;
\r
7092 while( p < is->next && *p != '\n' ) {
\r
7096 if( p >= is->next ) {
\r
7097 if (appData.debugMode) {
\r
7098 fprintf( debugFP, "Input line exceeded buffer size (source id=%lu)\n", is->id );
\r
7101 is->error = ERROR_BROKEN_PIPE; /* [AS] Just any non-successful code! */
\r
7102 is->count = (DWORD) -1;
\r
7103 is->next = is->buf;
\r
7109 InputThread(LPVOID arg)
\r
7114 is = (InputSource *) arg;
\r
7115 ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
\r
7116 ovl.Internal = ovl.InternalHigh = ovl.Offset = ovl.OffsetHigh = 0;
\r
7117 while (is->hThread != NULL) {
\r
7118 is->error = DoReadFile(is->hFile, is->next,
\r
7119 INPUT_SOURCE_BUF_SIZE - (is->next - is->buf),
\r
7120 &is->count, &ovl);
\r
7121 if (is->error == NO_ERROR) {
\r
7122 is->next += is->count;
\r
7124 if (is->error == ERROR_BROKEN_PIPE) {
\r
7125 /* Correct for MS brain damage. EOF reading a pipe is not an error. */
\r
7128 is->count = (DWORD) -1;
\r
7129 /* [AS] The (is->count <= 0) check below is not useful for unsigned values! */
\r
7134 CheckForInputBufferFull( is );
\r
7136 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7138 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7140 if (is->count <= 0) break; /* Quit on EOF or error */
\r
7143 CloseHandle(ovl.hEvent);
\r
7144 CloseHandle(is->hFile);
\r
7146 if (appData.debugMode) {
\r
7147 fprintf( debugFP, "Input thread terminated (id=%lu, error=%d, count=%ld)\n", is->id, is->error, is->count );
\r
7154 /* Windows 95 beta 2 won't let you do overlapped i/o on a console or pipe */
\r
7156 NonOvlInputThread(LPVOID arg)
\r
7163 is = (InputSource *) arg;
\r
7164 while (is->hThread != NULL) {
\r
7165 is->error = ReadFile(is->hFile, is->next,
\r
7166 INPUT_SOURCE_BUF_SIZE - (is->next - is->buf),
\r
7167 &is->count, NULL) ? NO_ERROR : GetLastError();
\r
7168 if (is->error == NO_ERROR) {
\r
7169 /* Change CRLF to LF */
\r
7170 if (is->next > is->buf) {
\r
7172 i = is->count + 1;
\r
7180 if (prev == '\r' && *p == '\n') {
\r
7192 if (is->error == ERROR_BROKEN_PIPE) {
\r
7193 /* Correct for MS brain damage. EOF reading a pipe is not an error. */
\r
7196 is->count = (DWORD) -1;
\r
7200 CheckForInputBufferFull( is );
\r
7202 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7204 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7206 if (is->count < 0) break; /* Quit on error */
\r
7208 CloseHandle(is->hFile);
\r
7213 SocketInputThread(LPVOID arg)
\r
7217 is = (InputSource *) arg;
\r
7218 while (is->hThread != NULL) {
\r
7219 is->count = recv(is->sock, is->buf, INPUT_SOURCE_BUF_SIZE, 0);
\r
7220 if ((int)is->count == SOCKET_ERROR) {
\r
7221 is->count = (DWORD) -1;
\r
7222 is->error = WSAGetLastError();
\r
7224 is->error = NO_ERROR;
\r
7225 is->next += is->count;
\r
7226 if (is->count == 0 && is->second == is) {
\r
7227 /* End of file on stderr; quit with no message */
\r
7231 SendMessage(hwndMain, WM_USER_Input, 0, (LPARAM) is);
\r
7233 if( is->count == ((DWORD) -1) ) break; /* [AS] */
\r
7235 if (is->count <= 0) break; /* Quit on EOF or error */
\r
7241 InputEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
\r
7245 is = (InputSource *) lParam;
\r
7246 if (is->lineByLine) {
\r
7247 /* Feed in lines one by one */
\r
7248 char *p = is->buf;
\r
7250 while (q < is->next) {
\r
7251 if (*q++ == '\n') {
\r
7252 (is->func)(is, is->closure, p, q - p, NO_ERROR);
\r
7257 /* Move any partial line to the start of the buffer */
\r
7259 while (p < is->next) {
\r
7264 if (is->error != NO_ERROR || is->count == 0) {
\r
7265 /* Notify backend of the error. Note: If there was a partial
\r
7266 line at the end, it is not flushed through. */
\r
7267 (is->func)(is, is->closure, is->buf, is->count, is->error);
\r
7270 /* Feed in the whole chunk of input at once */
\r
7271 (is->func)(is, is->closure, is->buf, is->count, is->error);
\r
7272 is->next = is->buf;
\r
7276 /*---------------------------------------------------------------------------*\
\r
7278 * Menu enables. Used when setting various modes.
\r
7280 \*---------------------------------------------------------------------------*/
\r
7288 GreyRevert(Boolean grey)
\r
7289 { // [HGM] vari: for retracting variations in local mode
\r
7290 HMENU hmenu = GetMenu(hwndMain);
\r
7291 EnableMenuItem(hmenu, IDM_Revert, MF_BYCOMMAND|(grey ? MF_GRAYED : MF_ENABLED));
\r
7295 SetMenuEnables(HMENU hmenu, Enables *enab)
\r
7297 while (enab->item > 0) {
\r
7298 (void) EnableMenuItem(hmenu, enab->item, enab->flags);
\r
7303 Enables gnuEnables[] = {
\r
7304 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7305 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7306 { IDM_IcsClient, MF_BYCOMMAND|MF_GRAYED },
\r
7307 { IDM_Accept, MF_BYCOMMAND|MF_GRAYED },
\r
7308 { IDM_Decline, MF_BYCOMMAND|MF_GRAYED },
\r
7309 { IDM_Rematch, MF_BYCOMMAND|MF_GRAYED },
\r
7310 { IDM_Adjourn, MF_BYCOMMAND|MF_GRAYED },
\r
7311 { IDM_StopExamining, MF_BYCOMMAND|MF_GRAYED },
\r
7312 { IDM_StopObserving, MF_BYCOMMAND|MF_GRAYED },
\r
7313 { IDM_Revert, MF_BYCOMMAND|MF_GRAYED },
\r
7314 { IDM_NewChat, MF_BYCOMMAND|MF_GRAYED },
\r
7318 Enables icsEnables[] = {
\r
7319 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7320 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7321 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7322 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7323 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7324 { IDM_MachineBoth, MF_BYCOMMAND|MF_GRAYED },
\r
7325 { IDM_AnalysisMode, MF_BYCOMMAND|MF_ENABLED },
\r
7326 { IDM_AnalyzeFile, MF_BYCOMMAND|MF_GRAYED },
\r
7327 { IDM_TimeControl, MF_BYCOMMAND|MF_GRAYED },
\r
7328 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7329 { IDM_Hint, MF_BYCOMMAND|MF_GRAYED },
\r
7330 { IDM_Book, MF_BYCOMMAND|MF_GRAYED },
\r
7331 { IDM_IcsOptions, MF_BYCOMMAND|MF_ENABLED },
\r
7332 { IDM_Engine1Options, MF_BYCOMMAND|MF_GRAYED },
\r
7333 { IDM_Engine2Options, MF_BYCOMMAND|MF_GRAYED },
\r
7338 Enables zippyEnables[] = {
\r
7339 { IDM_MoveNow, MF_BYCOMMAND|MF_ENABLED },
\r
7340 { IDM_Hint, MF_BYCOMMAND|MF_ENABLED },
\r
7341 { IDM_Book, MF_BYCOMMAND|MF_ENABLED },
\r
7342 { IDM_Engine1Options, MF_BYCOMMAND|MF_ENABLED },
\r
7347 Enables ncpEnables[] = {
\r
7348 { IDM_MailMove, MF_BYCOMMAND|MF_GRAYED },
\r
7349 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_GRAYED },
\r
7350 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7351 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7352 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7353 { IDM_AnalysisMode, MF_BYCOMMAND|MF_GRAYED },
\r
7354 { IDM_AnalyzeFile, MF_BYCOMMAND|MF_GRAYED },
\r
7355 { IDM_IcsClient, MF_BYCOMMAND|MF_GRAYED },
\r
7356 { ACTION_POS, MF_BYPOSITION|MF_GRAYED },
\r
7357 { IDM_Revert, MF_BYCOMMAND|MF_GRAYED },
\r
7358 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7359 { IDM_RetractMove, MF_BYCOMMAND|MF_GRAYED },
\r
7360 { IDM_TimeControl, MF_BYCOMMAND|MF_GRAYED },
\r
7361 { IDM_Hint, MF_BYCOMMAND|MF_GRAYED },
\r
7362 { IDM_Book, MF_BYCOMMAND|MF_GRAYED },
\r
7363 { IDM_MachineBoth, MF_BYCOMMAND|MF_GRAYED },
\r
7364 { IDM_NewChat, MF_BYCOMMAND|MF_GRAYED },
\r
7365 { IDM_Engine1Options, MF_BYCOMMAND|MF_GRAYED },
\r
7366 { IDM_Engine2Options, MF_BYCOMMAND|MF_GRAYED },
\r
7370 Enables trainingOnEnables[] = {
\r
7371 { IDM_EditComment, MF_BYCOMMAND|MF_GRAYED },
\r
7372 { IDM_Pause, MF_BYCOMMAND|MF_GRAYED },
\r
7373 { IDM_Forward, MF_BYCOMMAND|MF_GRAYED },
\r
7374 { IDM_Backward, MF_BYCOMMAND|MF_GRAYED },
\r
7375 { IDM_ToEnd, MF_BYCOMMAND|MF_GRAYED },
\r
7376 { IDM_ToStart, MF_BYCOMMAND|MF_GRAYED },
\r
7377 { IDM_MoveNow, MF_BYCOMMAND|MF_GRAYED },
\r
7378 { IDM_TruncateGame, MF_BYCOMMAND|MF_GRAYED },
\r
7382 Enables trainingOffEnables[] = {
\r
7383 { IDM_EditComment, MF_BYCOMMAND|MF_ENABLED },
\r
7384 { IDM_Pause, MF_BYCOMMAND|MF_ENABLED },
\r
7385 { IDM_Forward, MF_BYCOMMAND|MF_ENABLED },
\r
7386 { IDM_Backward, MF_BYCOMMAND|MF_ENABLED },
\r
7387 { IDM_ToEnd, MF_BYCOMMAND|MF_ENABLED },
\r
7388 { IDM_ToStart, MF_BYCOMMAND|MF_ENABLED },
\r
7389 { IDM_MoveNow, MF_BYCOMMAND|MF_ENABLED },
\r
7390 { IDM_TruncateGame, MF_BYCOMMAND|MF_ENABLED },
\r
7394 /* These modify either ncpEnables or gnuEnables */
\r
7395 Enables cmailEnables[] = {
\r
7396 { IDM_MailMove, MF_BYCOMMAND|MF_ENABLED },
\r
7397 { IDM_ReloadCMailMsg, MF_BYCOMMAND|MF_ENABLED },
\r
7398 { ACTION_POS, MF_BYPOSITION|MF_ENABLED },
\r
7399 { IDM_CallFlag, MF_BYCOMMAND|MF_GRAYED },
\r
7400 { IDM_Draw, MF_BYCOMMAND|MF_ENABLED },
\r
7401 { IDM_Adjourn, MF_BYCOMMAND|MF_GRAYED },
\r
7402 { IDM_Abort, MF_BYCOMMAND|MF_GRAYED },
\r
7406 Enables machineThinkingEnables[] = {
\r
7407 { IDM_LoadGame, MF_BYCOMMAND|MF_GRAYED },
\r
7408 { IDM_LoadNextGame, MF_BYCOMMAND|MF_GRAYED },
\r
7409 { IDM_LoadPrevGame, MF_BYCOMMAND|MF_GRAYED },
\r
7410 { IDM_ReloadGame, MF_BYCOMMAND|MF_GRAYED },
\r
7411 { IDM_PasteGame, MF_BYCOMMAND|MF_GRAYED },
\r
7412 { IDM_LoadPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7413 { IDM_LoadNextPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7414 { IDM_LoadPrevPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7415 { IDM_ReloadPosition, MF_BYCOMMAND|MF_GRAYED },
\r
7416 { IDM_PastePosition, MF_BYCOMMAND|MF_GRAYED },
\r
7417 { IDM_MachineWhite, MF_BYCOMMAND|MF_GRAYED },
\r
7418 { IDM_MachineBlack, MF_BYCOMMAND|MF_GRAYED },
\r
7419 { IDM_TwoMachines, MF_BYCOMMAND|MF_GRAYED },
\r
7420 { IDM_TypeInMove, MF_BYCOMMAND|MF_GRAYED },
\r
7421 { IDM_RetractMove, MF_BYCOMMAND|MF_GRAYED },
\r
7425 Enables userThinkingEnables[] = {
\r
7426 { IDM_LoadGame, MF_BYCOMMAND|MF_ENABLED },
\r
7427 { IDM_LoadNextGame, MF_BYCOMMAND|MF_ENABLED },
\r
7428 { IDM_LoadPrevGame, MF_BYCOMMAND|MF_ENABLED },
\r
7429 { IDM_ReloadGame, MF_BYCOMMAND|MF_ENABLED },
\r
7430 { IDM_PasteGame, MF_BYCOMMAND|MF_ENABLED },
\r
7431 { IDM_LoadPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7432 { IDM_LoadNextPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7433 { IDM_LoadPrevPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7434 { IDM_ReloadPosition, MF_BYCOMMAND|MF_ENABLED },
\r
7435 { IDM_PastePosition, MF_BYCOMMAND|MF_ENABLED },
\r
7436 { IDM_MachineWhite, MF_BYCOMMAND|MF_ENABLED },
\r
7437 { IDM_MachineBlack, MF_BYCOMMAND|MF_ENABLED },
\r
7438 { IDM_TwoMachines, MF_BYCOMMAND|MF_ENABLED },
\r
7439 { IDM_TypeInMove, MF_BYCOMMAND|MF_ENABLED },
\r
7440 { IDM_RetractMove, MF_BYCOMMAND|MF_ENABLED },
\r
7444 /*---------------------------------------------------------------------------*\
\r
7446 * Front-end interface functions exported by XBoard.
\r
7447 * Functions appear in same order as prototypes in frontend.h.
\r
7449 \*---------------------------------------------------------------------------*/
\r
7453 static UINT prevChecked = 0;
\r
7454 static int prevPausing = 0;
\r
7457 if (pausing != prevPausing) {
\r
7458 prevPausing = pausing;
\r
7459 (void) CheckMenuItem(GetMenu(hwndMain), IDM_Pause,
\r
7460 MF_BYCOMMAND|(pausing ? MF_CHECKED : MF_UNCHECKED));
\r
7461 if (hwndPause) SetWindowText(hwndPause, pausing ? "C" : "P");
\r
7464 switch (gameMode) {
\r
7465 case BeginningOfGame:
\r
7466 if (appData.icsActive)
\r
7467 nowChecked = IDM_IcsClient;
\r
7468 else if (appData.noChessProgram)
\r
7469 nowChecked = IDM_EditGame;
\r
7471 nowChecked = IDM_MachineBlack;
\r
7473 case MachinePlaysBlack:
\r
7474 nowChecked = IDM_MachineBlack;
\r
7476 case MachinePlaysWhite:
\r
7477 nowChecked = IDM_MachineWhite;
\r
7479 case TwoMachinesPlay:
\r
7480 nowChecked = IDM_TwoMachines;
\r
7483 nowChecked = IDM_AnalysisMode;
\r
7486 nowChecked = IDM_AnalyzeFile;
\r
7489 nowChecked = IDM_EditGame;
\r
7491 case PlayFromGameFile:
\r
7492 nowChecked = IDM_LoadGame;
\r
7494 case EditPosition:
\r
7495 nowChecked = IDM_EditPosition;
\r
7498 nowChecked = IDM_Training;
\r
7500 case IcsPlayingWhite:
\r
7501 case IcsPlayingBlack:
\r
7502 case IcsObserving:
\r
7504 nowChecked = IDM_IcsClient;
\r
7511 if (prevChecked != 0)
\r
7512 (void) CheckMenuItem(GetMenu(hwndMain),
\r
7513 prevChecked, MF_BYCOMMAND|MF_UNCHECKED);
\r
7514 if (nowChecked != 0)
\r
7515 (void) CheckMenuItem(GetMenu(hwndMain),
\r
7516 nowChecked, MF_BYCOMMAND|MF_CHECKED);
\r
7518 if (nowChecked == IDM_LoadGame || nowChecked == IDM_Training) {
\r
7519 (void) EnableMenuItem(GetMenu(hwndMain), IDM_Training,
\r
7520 MF_BYCOMMAND|MF_ENABLED);
\r
7522 (void) EnableMenuItem(GetMenu(hwndMain),
\r
7523 IDM_Training, MF_BYCOMMAND|MF_GRAYED);
\r
7526 prevChecked = nowChecked;
\r
7528 /* [DM] icsEngineAnalyze - Do a sceure check too */
\r
7529 if (appData.icsActive) {
\r
7530 if (appData.icsEngineAnalyze) {
\r
7531 (void) CheckMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7532 MF_BYCOMMAND|MF_CHECKED);
\r
7534 (void) CheckMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7535 MF_BYCOMMAND|MF_UNCHECKED);
\r
7543 HMENU hmenu = GetMenu(hwndMain);
\r
7544 SetMenuEnables(hmenu, icsEnables);
\r
7545 EnableMenuItem(GetSubMenu(hmenu, OPTIONS_POS), ICS_POS,
\r
7546 MF_BYPOSITION|MF_ENABLED);
\r
7548 if (appData.zippyPlay) {
\r
7549 SetMenuEnables(hmenu, zippyEnables);
\r
7550 if (!appData.noChessProgram) /* [DM] icsEngineAnalyze */
\r
7551 (void) EnableMenuItem(GetMenu(hwndMain), IDM_AnalysisMode,
\r
7552 MF_BYCOMMAND|MF_ENABLED);
\r
7560 SetMenuEnables(GetMenu(hwndMain), gnuEnables);
\r
7566 HMENU hmenu = GetMenu(hwndMain);
\r
7567 SetMenuEnables(hmenu, ncpEnables);
\r
7568 EnableMenuItem(GetSubMenu(hmenu, OPTIONS_POS), SOUNDS_POS,
\r
7569 MF_BYPOSITION|MF_GRAYED);
\r
7570 DrawMenuBar(hwndMain);
\r
7576 SetMenuEnables(GetMenu(hwndMain), cmailEnables);
\r
7580 SetTrainingModeOn()
\r
7583 SetMenuEnables(GetMenu(hwndMain), trainingOnEnables);
\r
7584 for (i = 0; i < N_BUTTONS; i++) {
\r
7585 if (buttonDesc[i].hwnd != NULL)
\r
7586 EnableWindow(buttonDesc[i].hwnd, FALSE);
\r
7591 VOID SetTrainingModeOff()
\r
7594 SetMenuEnables(GetMenu(hwndMain), trainingOffEnables);
\r
7595 for (i = 0; i < N_BUTTONS; i++) {
\r
7596 if (buttonDesc[i].hwnd != NULL)
\r
7597 EnableWindow(buttonDesc[i].hwnd, TRUE);
\r
7603 SetUserThinkingEnables()
\r
7605 SetMenuEnables(GetMenu(hwndMain), userThinkingEnables);
\r
7609 SetMachineThinkingEnables()
\r
7611 HMENU hMenu = GetMenu(hwndMain);
\r
7612 int flags = MF_BYCOMMAND|MF_ENABLED;
\r
7614 SetMenuEnables(hMenu, machineThinkingEnables);
\r
7616 if (gameMode == MachinePlaysBlack) {
\r
7617 (void)EnableMenuItem(hMenu, IDM_MachineBlack, flags);
\r
7618 } else if (gameMode == MachinePlaysWhite) {
\r
7619 (void)EnableMenuItem(hMenu, IDM_MachineWhite, flags);
\r
7620 } else if (gameMode == TwoMachinesPlay) {
\r
7621 (void)EnableMenuItem(hMenu, IDM_TwoMachines, flags);
\r
7627 DisplayTitle(char *str)
\r
7629 char title[MSG_SIZ], *host;
\r
7630 if (str[0] != NULLCHAR) {
\r
7631 strcpy(title, str);
\r
7632 } else if (appData.icsActive) {
\r
7633 if (appData.icsCommPort[0] != NULLCHAR)
\r
7636 host = appData.icsHost;
\r
7637 sprintf(title, "%s: %s", szTitle, host);
\r
7638 } else if (appData.noChessProgram) {
\r
7639 strcpy(title, szTitle);
\r
7641 strcpy(title, szTitle);
\r
7642 strcat(title, ": ");
\r
7643 strcat(title, first.tidy);
\r
7645 SetWindowText(hwndMain, title);
\r
7650 DisplayMessage(char *str1, char *str2)
\r
7654 int remain = MESSAGE_TEXT_MAX - 1;
\r
7657 moveErrorMessageUp = FALSE; /* turned on later by caller if needed */
\r
7658 messageText[0] = NULLCHAR;
\r
7660 len = strlen(str1);
\r
7661 if (len > remain) len = remain;
\r
7662 strncpy(messageText, str1, len);
\r
7663 messageText[len] = NULLCHAR;
\r
7666 if (*str2 && remain >= 2) {
\r
7668 strcat(messageText, " ");
\r
7671 len = strlen(str2);
\r
7672 if (len > remain) len = remain;
\r
7673 strncat(messageText, str2, len);
\r
7675 messageText[MESSAGE_TEXT_MAX - 1] = NULLCHAR;
\r
7677 if (hwndMain == NULL || IsIconic(hwndMain)) return;
\r
7681 hdc = GetDC(hwndMain);
\r
7682 oldFont = SelectObject(hdc, font[boardSize][MESSAGE_FONT]->hf);
\r
7683 ExtTextOut(hdc, messageRect.left, messageRect.top, ETO_CLIPPED|ETO_OPAQUE,
\r
7684 &messageRect, messageText, strlen(messageText), NULL);
\r
7685 (void) SelectObject(hdc, oldFont);
\r
7686 (void) ReleaseDC(hwndMain, hdc);
\r
7690 DisplayError(char *str, int error)
\r
7692 char buf[MSG_SIZ*2], buf2[MSG_SIZ];
\r
7698 len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
\r
7699 NULL, error, LANG_NEUTRAL,
\r
7700 (LPSTR) buf2, MSG_SIZ, NULL);
\r
7702 sprintf(buf, "%s:\n%s", str, buf2);
\r
7704 ErrorMap *em = errmap;
\r
7705 while (em->err != 0 && em->err != error) em++;
\r
7706 if (em->err != 0) {
\r
7707 sprintf(buf, "%s:\n%s", str, em->msg);
\r
7709 sprintf(buf, "%s:\nError code %d", str, error);
\r
7714 ErrorPopUp("Error", buf);
\r
7719 DisplayMoveError(char *str)
\r
7721 fromX = fromY = -1;
\r
7722 ClearHighlights();
\r
7723 DrawPosition(FALSE, NULL);
\r
7724 if (appData.popupMoveErrors) {
\r
7725 ErrorPopUp("Error", str);
\r
7727 DisplayMessage(str, "");
\r
7728 moveErrorMessageUp = TRUE;
\r
7733 DisplayFatalError(char *str, int error, int exitStatus)
\r
7735 char buf[2*MSG_SIZ], buf2[MSG_SIZ];
\r
7737 char *label = exitStatus ? "Fatal Error" : "Exiting";
\r
7740 len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
\r
7741 NULL, error, LANG_NEUTRAL,
\r
7742 (LPSTR) buf2, MSG_SIZ, NULL);
\r
7744 sprintf(buf, "%s:\n%s", str, buf2);
\r
7746 ErrorMap *em = errmap;
\r
7747 while (em->err != 0 && em->err != error) em++;
\r
7748 if (em->err != 0) {
\r
7749 sprintf(buf, "%s:\n%s", str, em->msg);
\r
7751 sprintf(buf, "%s:\nError code %d", str, error);
\r
7756 if (appData.debugMode) {
\r
7757 fprintf(debugFP, "%s: %s\n", label, str);
\r
7759 if (appData.popupExitMessage) {
\r
7760 (void) MessageBox(hwndMain, str, label, MB_OK|
\r
7761 (exitStatus ? MB_ICONSTOP : MB_ICONINFORMATION));
\r
7763 ExitEvent(exitStatus);
\r
7768 DisplayInformation(char *str)
\r
7770 (void) MessageBox(hwndMain, str, "Information", MB_OK|MB_ICONINFORMATION);
\r
7775 DisplayNote(char *str)
\r
7777 ErrorPopUp("Note", str);
\r
7782 char *title, *question, *replyPrefix;
\r
7787 QuestionDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7789 static QuestionParams *qp;
\r
7790 char reply[MSG_SIZ];
\r
7793 switch (message) {
\r
7794 case WM_INITDIALOG:
\r
7795 qp = (QuestionParams *) lParam;
\r
7796 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7797 SetWindowText(hDlg, qp->title);
\r
7798 SetDlgItemText(hDlg, OPT_QuestionText, qp->question);
\r
7799 SetFocus(GetDlgItem(hDlg, OPT_QuestionInput));
\r
7803 switch (LOWORD(wParam)) {
\r
7805 strcpy(reply, qp->replyPrefix);
\r
7806 if (*reply) strcat(reply, " ");
\r
7807 len = strlen(reply);
\r
7808 GetDlgItemText(hDlg, OPT_QuestionInput, reply + len, sizeof(reply) - len);
\r
7809 strcat(reply, "\n");
\r
7810 OutputToProcess(qp->pr, reply, strlen(reply), &err);
\r
7811 EndDialog(hDlg, TRUE);
\r
7812 if (err) DisplayFatalError("Error writing to chess program", err, 1);
\r
7815 EndDialog(hDlg, FALSE);
\r
7826 AskQuestion(char* title, char *question, char *replyPrefix, ProcRef pr)
\r
7828 QuestionParams qp;
\r
7832 qp.question = question;
\r
7833 qp.replyPrefix = replyPrefix;
\r
7835 lpProc = MakeProcInstance((FARPROC)QuestionDialog, hInst);
\r
7836 DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_Question),
\r
7837 hwndMain, (DLGPROC)lpProc, (LPARAM)&qp);
\r
7838 FreeProcInstance(lpProc);
\r
7841 /* [AS] Pick FRC position */
\r
7842 LRESULT CALLBACK NewGameFRC_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7844 static int * lpIndexFRC;
\r
7850 case WM_INITDIALOG:
\r
7851 lpIndexFRC = (int *) lParam;
\r
7853 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7855 SendDlgItemMessage( hDlg, IDC_NFG_Edit, EM_SETLIMITTEXT, sizeof(buf)-1, 0 );
\r
7856 SetDlgItemInt( hDlg, IDC_NFG_Edit, *lpIndexFRC, TRUE );
\r
7857 SendDlgItemMessage( hDlg, IDC_NFG_Edit, EM_SETSEL, 0, -1 );
\r
7858 SetFocus(GetDlgItem(hDlg, IDC_NFG_Edit));
\r
7863 switch( LOWORD(wParam) ) {
\r
7865 *lpIndexFRC = GetDlgItemInt(hDlg, IDC_NFG_Edit, &index_is_ok, TRUE );
\r
7866 EndDialog( hDlg, 0 );
\r
7867 shuffleOpenings = TRUE; /* [HGM] shuffle: switch shuffling on for as long as we stay in current variant */
\r
7870 EndDialog( hDlg, 1 );
\r
7872 case IDC_NFG_Edit:
\r
7873 if( HIWORD(wParam) == EN_CHANGE ) {
\r
7874 GetDlgItemInt(hDlg, IDC_NFG_Edit, &index_is_ok, TRUE );
\r
7876 EnableWindow( GetDlgItem(hDlg, IDOK), index_is_ok );
\r
7879 case IDC_NFG_Random:
\r
7880 sprintf( buf, "%d", myrandom() ); /* [HGM] shuffle: no longer limit to 960 */
\r
7881 SetDlgItemText(hDlg, IDC_NFG_Edit, buf );
\r
7894 int index = appData.defaultFrcPosition;
\r
7895 FARPROC lpProc = MakeProcInstance( (FARPROC) NewGameFRC_Proc, hInst );
\r
7897 result = DialogBoxParam( hInst, MAKEINTRESOURCE(DLG_NewGameFRC), hwndMain, (DLGPROC)lpProc, (LPARAM)&index );
\r
7899 if( result == 0 ) {
\r
7900 appData.defaultFrcPosition = index;
\r
7906 /* [AS] Game list options. Refactored by HGM */
\r
7908 HWND gameListOptionsDialog;
\r
7910 // low-level front-end: clear text edit / list widget
\r
7914 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_RESETCONTENT, 0, 0 );
\r
7917 // low-level front-end: clear text edit / list widget
\r
7919 GLT_DeSelectList()
\r
7921 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_SETCURSEL, 0, 0 );
\r
7924 // low-level front-end: append line to text edit / list widget
\r
7926 GLT_AddToList( char *name )
\r
7929 SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_ADDSTRING, 0, (LPARAM) name );
\r
7933 // low-level front-end: get line from text edit / list widget
\r
7935 GLT_GetFromList( int index, char *name )
\r
7938 if( SendDlgItemMessage( gameListOptionsDialog, IDC_GameListTags, LB_GETTEXT, index, (LPARAM) name ) != LB_ERR )
\r
7944 void GLT_MoveSelection( HWND hDlg, int delta )
\r
7946 int idx1 = (int) SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETCURSEL, 0, 0 );
\r
7947 int idx2 = idx1 + delta;
\r
7948 int count = (int) SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETCOUNT, 0, 0 );
\r
7950 if( idx1 >=0 && idx1 < count && idx2 >= 0 && idx2 < count ) {
\r
7953 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_GETTEXT, idx1, (LPARAM) buf );
\r
7954 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_DELETESTRING, idx1, 0 );
\r
7955 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_INSERTSTRING, idx2, (LPARAM) buf );
\r
7956 SendDlgItemMessage( hDlg, IDC_GameListTags, LB_SETCURSEL, idx2, 0 );
\r
7960 LRESULT CALLBACK GameListOptions_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
\r
7964 case WM_INITDIALOG:
\r
7965 gameListOptionsDialog = hDlg; // [HGM] pass through global to keep out off back-end
\r
7967 CenterWindow(hDlg, GetWindow(hDlg, GW_OWNER));
\r
7969 /* Initialize list */
\r
7970 GLT_TagsToList( lpUserGLT );
\r
7972 SetFocus( GetDlgItem(hDlg, IDC_GameListTags) );
\r
7977 switch( LOWORD(wParam) ) {
\r
7980 EndDialog( hDlg, 0 );
\r
7983 EndDialog( hDlg, 1 );
\r
7986 case IDC_GLT_Default:
\r
7987 GLT_TagsToList( GLT_DEFAULT_TAGS );
\r
7990 case IDC_GLT_Restore:
\r
7991 GLT_TagsToList( appData.gameListTags );
\r
7995 GLT_MoveSelection( hDlg, -1 );
\r
7998 case IDC_GLT_Down:
\r
7999 GLT_MoveSelection( hDlg, +1 );
\r
8009 int GameListOptions()
\r
8012 FARPROC lpProc = MakeProcInstance( (FARPROC) GameListOptions_Proc, hInst );
\r
8014 strcpy( lpUserGLT, appData.gameListTags );
\r
8016 result = DialogBoxParam( hInst, MAKEINTRESOURCE(DLG_GameListOptions), hwndMain, (DLGPROC)lpProc, (LPARAM)lpUserGLT );
\r
8018 if( result == 0 ) {
\r
8019 /* [AS] Memory leak here! */
\r
8020 appData.gameListTags = strdup( lpUserGLT );
\r
8027 DisplayIcsInteractionTitle(char *str)
\r
8029 char consoleTitle[MSG_SIZ];
\r
8031 sprintf(consoleTitle, "%s: %s", szConsoleTitle, str);
\r
8032 SetWindowText(hwndConsole, consoleTitle);
\r
8036 DrawPosition(int fullRedraw, Board board)
\r
8038 HDCDrawPosition(NULL, (BOOLEAN) fullRedraw, board);
\r
8041 void NotifyFrontendLogin()
\r
8044 UpdateICSWidth(GetDlgItem(hwndConsole, OPT_ConsoleText));
\r
8050 fromX = fromY = -1;
\r
8051 if (dragInfo.pos.x != -1 || dragInfo.pos.y != -1) {
\r
8052 dragInfo.pos.x = dragInfo.pos.y = -1;
\r
8053 dragInfo.pos.x = dragInfo.pos.y = -1;
\r
8054 dragInfo.lastpos = dragInfo.pos;
\r
8055 dragInfo.start.x = dragInfo.start.y = -1;
\r
8056 dragInfo.from = dragInfo.start;
\r
8058 DrawPosition(TRUE, NULL);
\r
8064 CommentPopUp(char *title, char *str)
\r
8066 HWND hwnd = GetActiveWindow();
\r
8067 EitherCommentPopUp(0, title, str, FALSE);
\r
8069 SetActiveWindow(hwnd);
\r
8073 CommentPopDown(void)
\r
8075 CheckMenuItem(GetMenu(hwndMain), IDM_EditComment, MF_UNCHECKED);
\r
8076 if (commentDialog) {
\r
8077 ShowWindow(commentDialog, SW_HIDE);
\r
8079 commentUp = FALSE;
\r
8083 EditCommentPopUp(int index, char *title, char *str)
\r
8085 EitherCommentPopUp(index, title, str, TRUE);
\r
8092 MyPlaySound(&sounds[(int)SoundMove]);
\r
8095 VOID PlayIcsWinSound()
\r
8097 MyPlaySound(&sounds[(int)SoundIcsWin]);
\r
8100 VOID PlayIcsLossSound()
\r
8102 MyPlaySound(&sounds[(int)SoundIcsLoss]);
\r
8105 VOID PlayIcsDrawSound()
\r
8107 MyPlaySound(&sounds[(int)SoundIcsDraw]);
\r
8110 VOID PlayIcsUnfinishedSound()
\r
8112 MyPlaySound(&sounds[(int)SoundIcsUnfinished]);
\r
8118 MyPlaySound(&sounds[(int)SoundAlarm]);
\r
8126 consoleEcho = TRUE;
\r
8127 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
8128 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&consoleCF);
\r
8129 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, consoleBackgroundColor);
\r
8138 consoleEcho = FALSE;
\r
8139 hInput = GetDlgItem(hwndConsole, OPT_ConsoleInput);
\r
8140 /* This works OK: set text and background both to the same color */
\r
8142 cf.crTextColor = COLOR_ECHOOFF;
\r
8143 SendMessage(hInput, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
\r
8144 SendMessage(hInput, EM_SETBKGNDCOLOR, FALSE, cf.crTextColor);
\r
8147 /* No Raw()...? */
\r
8149 void Colorize(ColorClass cc, int continuation)
\r
8151 currentColorClass = cc;
\r
8152 consoleCF.dwMask = CFM_COLOR|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT;
\r
8153 consoleCF.crTextColor = textAttribs[cc].color;
\r
8154 consoleCF.dwEffects = textAttribs[cc].effects;
\r
8155 if (!continuation) MyPlaySound(&textAttribs[cc].sound);
\r
8161 static char buf[MSG_SIZ];
\r
8162 DWORD bufsiz = MSG_SIZ;
\r
8164 if(appData.userName != NULL && appData.userName[0] != 0) {
\r
8165 return appData.userName; /* [HGM] username: prefer name selected by user over his system login */
\r
8167 if (!GetUserName(buf, &bufsiz)) {
\r
8168 /*DisplayError("Error getting user name", GetLastError());*/
\r
8169 strcpy(buf, "User");
\r
8177 static char buf[MSG_SIZ];
\r
8178 DWORD bufsiz = MSG_SIZ;
\r
8180 if (!GetComputerName(buf, &bufsiz)) {
\r
8181 /*DisplayError("Error getting host name", GetLastError());*/
\r
8182 strcpy(buf, "Unknown");
\r
8189 ClockTimerRunning()
\r
8191 return clockTimerEvent != 0;
\r
8197 if (clockTimerEvent == 0) return FALSE;
\r
8198 KillTimer(hwndMain, clockTimerEvent);
\r
8199 clockTimerEvent = 0;
\r
8204 StartClockTimer(long millisec)
\r
8206 clockTimerEvent = SetTimer(hwndMain, (UINT) CLOCK_TIMER_ID,
\r
8207 (UINT) millisec, NULL);
\r
8211 DisplayWhiteClock(long timeRemaining, int highlight)
\r
8214 char *flag = whiteFlag && gameMode == TwoMachinesPlay ? "(!)" : "";
\r
8216 if(appData.noGUI) return;
\r
8217 hdc = GetDC(hwndMain);
\r
8218 if (!IsIconic(hwndMain)) {
\r
8219 DisplayAClock(hdc, timeRemaining, highlight,
\r
8220 flipClock ? &blackRect : &whiteRect, "White", flag);
\r
8222 if (highlight && iconCurrent == iconBlack) {
\r
8223 iconCurrent = iconWhite;
\r
8224 PostMessage(hwndMain, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8225 if (IsIconic(hwndMain)) {
\r
8226 DrawIcon(hdc, 2, 2, iconCurrent);
\r
8229 (void) ReleaseDC(hwndMain, hdc);
\r
8231 PostMessage(hwndConsole, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8235 DisplayBlackClock(long timeRemaining, int highlight)
\r
8238 char *flag = blackFlag && gameMode == TwoMachinesPlay ? "(!)" : "";
\r
8240 if(appData.noGUI) return;
\r
8241 hdc = GetDC(hwndMain);
\r
8242 if (!IsIconic(hwndMain)) {
\r
8243 DisplayAClock(hdc, timeRemaining, highlight,
\r
8244 flipClock ? &whiteRect : &blackRect, "Black", flag);
\r
8246 if (highlight && iconCurrent == iconWhite) {
\r
8247 iconCurrent = iconBlack;
\r
8248 PostMessage(hwndMain, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8249 if (IsIconic(hwndMain)) {
\r
8250 DrawIcon(hdc, 2, 2, iconCurrent);
\r
8253 (void) ReleaseDC(hwndMain, hdc);
\r
8255 PostMessage(hwndConsole, WM_SETICON, (WPARAM) TRUE, (LPARAM) iconCurrent);
\r
8260 LoadGameTimerRunning()
\r
8262 return loadGameTimerEvent != 0;
\r
8266 StopLoadGameTimer()
\r
8268 if (loadGameTimerEvent == 0) return FALSE;
\r
8269 KillTimer(hwndMain, loadGameTimerEvent);
\r
8270 loadGameTimerEvent = 0;
\r
8275 StartLoadGameTimer(long millisec)
\r
8277 loadGameTimerEvent = SetTimer(hwndMain, (UINT) LOAD_GAME_TIMER_ID,
\r
8278 (UINT) millisec, NULL);
\r
8286 char fileTitle[MSG_SIZ];
\r
8288 defName = DefaultFileName(appData.oldSaveStyle ? "gam" : "pgn");
\r
8289 f = OpenFileDialog(hwndMain, "a", defName,
\r
8290 appData.oldSaveStyle ? "gam" : "pgn",
\r
8292 "Save Game to File", NULL, fileTitle, NULL);
\r
8294 SaveGame(f, 0, "");
\r
8301 ScheduleDelayedEvent(DelayedEventCallback cb, long millisec)
\r
8303 if (delayedTimerEvent != 0) {
\r
8304 if (appData.debugMode && cb != delayedTimerCallback) { // [HGM] alive: not too much debug
\r
8305 fprintf(debugFP, "ScheduleDelayedEvent: event already scheduled\n");
\r
8307 KillTimer(hwndMain, delayedTimerEvent);
\r
8308 delayedTimerEvent = 0;
\r
8309 if(delayedTimerCallback != cb) // [HGM] alive: do not "flush" same event, just postpone it
\r
8310 delayedTimerCallback();
\r
8312 delayedTimerCallback = cb;
\r
8313 delayedTimerEvent = SetTimer(hwndMain, (UINT) DELAYED_TIMER_ID,
\r
8314 (UINT) millisec, NULL);
\r
8317 DelayedEventCallback
\r
8320 if (delayedTimerEvent) {
\r
8321 return delayedTimerCallback;
\r
8328 CancelDelayedEvent()
\r
8330 if (delayedTimerEvent) {
\r
8331 KillTimer(hwndMain, delayedTimerEvent);
\r
8332 delayedTimerEvent = 0;
\r
8336 DWORD GetWin32Priority(int nice)
\r
8337 { // [HGM] nice: translate Unix nice() value to indows priority class. (Code stolen from Polyglot 1.4w11)
\r
8339 REALTIME_PRIORITY_CLASS 0x00000100
\r
8340 HIGH_PRIORITY_CLASS 0x00000080
\r
8341 ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
\r
8342 NORMAL_PRIORITY_CLASS 0x00000020
\r
8343 BELOW_NORMAL_PRIORITY_CLASS 0x00004000
\r
8344 IDLE_PRIORITY_CLASS 0x00000040
\r
8346 if (nice < -15) return 0x00000080;
\r
8347 if (nice < 0) return 0x00008000;
\r
8348 if (nice == 0) return 0x00000020;
\r
8349 if (nice < 15) return 0x00004000;
\r
8350 return 0x00000040;
\r
8353 /* Start a child process running the given program.
\r
8354 The process's standard output can be read from "from", and its
\r
8355 standard input can be written to "to".
\r
8356 Exit with fatal error if anything goes wrong.
\r
8357 Returns an opaque pointer that can be used to destroy the process
\r
8361 StartChildProcess(char *cmdLine, char *dir, ProcRef *pr)
\r
8363 #define BUFSIZE 4096
\r
8365 HANDLE hChildStdinRd, hChildStdinWr,
\r
8366 hChildStdoutRd, hChildStdoutWr;
\r
8367 HANDLE hChildStdinWrDup, hChildStdoutRdDup;
\r
8368 SECURITY_ATTRIBUTES saAttr;
\r
8370 PROCESS_INFORMATION piProcInfo;
\r
8371 STARTUPINFO siStartInfo;
\r
8373 char buf[MSG_SIZ];
\r
8376 if (appData.debugMode) {
\r
8377 fprintf(debugFP, "StartChildProcess (dir=\"%s\") %s\n", dir, cmdLine);
\r
8382 /* Set the bInheritHandle flag so pipe handles are inherited. */
\r
8383 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
\r
8384 saAttr.bInheritHandle = TRUE;
\r
8385 saAttr.lpSecurityDescriptor = NULL;
\r
8388 * The steps for redirecting child's STDOUT:
\r
8389 * 1. Create anonymous pipe to be STDOUT for child.
\r
8390 * 2. Create a noninheritable duplicate of read handle,
\r
8391 * and close the inheritable read handle.
\r
8394 /* Create a pipe for the child's STDOUT. */
\r
8395 if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) {
\r
8396 return GetLastError();
\r
8399 /* Duplicate the read handle to the pipe, so it is not inherited. */
\r
8400 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,
\r
8401 GetCurrentProcess(), &hChildStdoutRdDup, 0,
\r
8402 FALSE, /* not inherited */
\r
8403 DUPLICATE_SAME_ACCESS);
\r
8405 return GetLastError();
\r
8407 CloseHandle(hChildStdoutRd);
\r
8410 * The steps for redirecting child's STDIN:
\r
8411 * 1. Create anonymous pipe to be STDIN for child.
\r
8412 * 2. Create a noninheritable duplicate of write handle,
\r
8413 * and close the inheritable write handle.
\r
8416 /* Create a pipe for the child's STDIN. */
\r
8417 if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
\r
8418 return GetLastError();
\r
8421 /* Duplicate the write handle to the pipe, so it is not inherited. */
\r
8422 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,
\r
8423 GetCurrentProcess(), &hChildStdinWrDup, 0,
\r
8424 FALSE, /* not inherited */
\r
8425 DUPLICATE_SAME_ACCESS);
\r
8427 return GetLastError();
\r
8429 CloseHandle(hChildStdinWr);
\r
8431 /* Arrange to (1) look in dir for the child .exe file, and
\r
8432 * (2) have dir be the child's working directory. Interpret
\r
8433 * dir relative to the directory WinBoard loaded from. */
\r
8434 GetCurrentDirectory(MSG_SIZ, buf);
\r
8435 SetCurrentDirectory(installDir);
\r
8436 SetCurrentDirectory(dir);
\r
8438 /* Now create the child process. */
\r
8440 siStartInfo.cb = sizeof(STARTUPINFO);
\r
8441 siStartInfo.lpReserved = NULL;
\r
8442 siStartInfo.lpDesktop = NULL;
\r
8443 siStartInfo.lpTitle = NULL;
\r
8444 siStartInfo.dwFlags = STARTF_USESTDHANDLES;
\r
8445 siStartInfo.cbReserved2 = 0;
\r
8446 siStartInfo.lpReserved2 = NULL;
\r
8447 siStartInfo.hStdInput = hChildStdinRd;
\r
8448 siStartInfo.hStdOutput = hChildStdoutWr;
\r
8449 siStartInfo.hStdError = hChildStdoutWr;
\r
8451 fSuccess = CreateProcess(NULL,
\r
8452 cmdLine, /* command line */
\r
8453 NULL, /* process security attributes */
\r
8454 NULL, /* primary thread security attrs */
\r
8455 TRUE, /* handles are inherited */
\r
8456 DETACHED_PROCESS|CREATE_NEW_PROCESS_GROUP,
\r
8457 NULL, /* use parent's environment */
\r
8459 &siStartInfo, /* STARTUPINFO pointer */
\r
8460 &piProcInfo); /* receives PROCESS_INFORMATION */
\r
8462 err = GetLastError();
\r
8463 SetCurrentDirectory(buf); /* return to prev directory */
\r
8468 if (appData.niceEngines){ // [HGM] nice: adjust engine proc priority
\r
8469 if(appData.debugMode) fprintf(debugFP, "nice engine proc to %d\n", appData.niceEngines);
\r
8470 SetPriorityClass(piProcInfo.hProcess, GetWin32Priority(appData.niceEngines));
\r
8473 /* Close the handles we don't need in the parent */
\r
8474 CloseHandle(piProcInfo.hThread);
\r
8475 CloseHandle(hChildStdinRd);
\r
8476 CloseHandle(hChildStdoutWr);
\r
8478 /* Prepare return value */
\r
8479 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8480 cp->kind = CPReal;
\r
8481 cp->hProcess = piProcInfo.hProcess;
\r
8482 cp->pid = piProcInfo.dwProcessId;
\r
8483 cp->hFrom = hChildStdoutRdDup;
\r
8484 cp->hTo = hChildStdinWrDup;
\r
8486 *pr = (void *) cp;
\r
8488 /* Klaus Friedel says that this Sleep solves a problem under Windows
\r
8489 2000 where engines sometimes don't see the initial command(s)
\r
8490 from WinBoard and hang. I don't understand how that can happen,
\r
8491 but the Sleep is harmless, so I've put it in. Others have also
\r
8492 reported what may be the same problem, so hopefully this will fix
\r
8493 it for them too. */
\r
8501 DestroyChildProcess(ProcRef pr, int/*boolean*/ signal)
\r
8503 ChildProc *cp; int result;
\r
8505 cp = (ChildProc *) pr;
\r
8506 if (cp == NULL) return;
\r
8508 switch (cp->kind) {
\r
8510 /* TerminateProcess is considered harmful, so... */
\r
8511 CloseHandle(cp->hTo); /* Closing this will give the child an EOF and hopefully kill it */
\r
8512 if (cp->hFrom) CloseHandle(cp->hFrom); /* if NULL, InputThread will close it */
\r
8513 /* The following doesn't work because the chess program
\r
8514 doesn't "have the same console" as WinBoard. Maybe
\r
8515 we could arrange for this even though neither WinBoard
\r
8516 nor the chess program uses a console for stdio? */
\r
8517 /*!!if (signal) GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, cp->pid);*/
\r
8519 /* [AS] Special termination modes for misbehaving programs... */
\r
8520 if( signal == 9 ) {
\r
8521 result = TerminateProcess( cp->hProcess, 0 );
\r
8523 if ( appData.debugMode) {
\r
8524 fprintf( debugFP, "Terminating process %lu, result=%d\n", cp->pid, result );
\r
8527 else if( signal == 10 ) {
\r
8528 DWORD dw = WaitForSingleObject( cp->hProcess, 3*1000 ); // Wait 3 seconds at most
\r
8530 if( dw != WAIT_OBJECT_0 ) {
\r
8531 result = TerminateProcess( cp->hProcess, 0 );
\r
8533 if ( appData.debugMode) {
\r
8534 fprintf( debugFP, "Process %lu still alive after timeout, killing... result=%d\n", cp->pid, result );
\r
8540 CloseHandle(cp->hProcess);
\r
8544 if (cp->hFrom) CloseHandle(cp->hFrom);
\r
8548 closesocket(cp->sock);
\r
8553 if (signal) send(cp->sock2, "\017", 1, 0); /* 017 = 15 = SIGTERM */
\r
8554 closesocket(cp->sock);
\r
8555 closesocket(cp->sock2);
\r
8563 InterruptChildProcess(ProcRef pr)
\r
8567 cp = (ChildProc *) pr;
\r
8568 if (cp == NULL) return;
\r
8569 switch (cp->kind) {
\r
8571 /* The following doesn't work because the chess program
\r
8572 doesn't "have the same console" as WinBoard. Maybe
\r
8573 we could arrange for this even though neither WinBoard
\r
8574 nor the chess program uses a console for stdio */
\r
8575 /*!!GenerateConsoleCtrlEvent(CTRL_C_EVENT, cp->pid);*/
\r
8580 /* Can't interrupt */
\r
8584 send(cp->sock2, "\002", 1, 0); /* 2 = SIGINT */
\r
8591 OpenTelnet(char *host, char *port, ProcRef *pr)
\r
8593 char cmdLine[MSG_SIZ];
\r
8595 if (port[0] == NULLCHAR) {
\r
8596 sprintf(cmdLine, "%s %s", appData.telnetProgram, host);
\r
8598 sprintf(cmdLine, "%s %s %s", appData.telnetProgram, host, port);
\r
8600 return StartChildProcess(cmdLine, "", pr);
\r
8604 /* Code to open TCP sockets */
\r
8607 OpenTCP(char *host, char *port, ProcRef *pr)
\r
8612 struct sockaddr_in sa, mysa;
\r
8613 struct hostent FAR *hp;
\r
8614 unsigned short uport;
\r
8615 WORD wVersionRequested;
\r
8618 /* Initialize socket DLL */
\r
8619 wVersionRequested = MAKEWORD(1, 1);
\r
8620 err = WSAStartup(wVersionRequested, &wsaData);
\r
8621 if (err != 0) return err;
\r
8624 if ((s = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8625 err = WSAGetLastError();
\r
8630 /* Bind local address using (mostly) don't-care values.
\r
8632 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8633 mysa.sin_family = AF_INET;
\r
8634 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8635 uport = (unsigned short) 0;
\r
8636 mysa.sin_port = htons(uport);
\r
8637 if (bind(s, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8638 == SOCKET_ERROR) {
\r
8639 err = WSAGetLastError();
\r
8644 /* Resolve remote host name */
\r
8645 memset((char *) &sa, 0, sizeof(struct sockaddr_in));
\r
8646 if (!(hp = gethostbyname(host))) {
\r
8647 unsigned int b0, b1, b2, b3;
\r
8649 err = WSAGetLastError();
\r
8651 if (sscanf(host, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) == 4) {
\r
8652 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
\r
8653 hp->h_addrtype = AF_INET;
\r
8655 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
\r
8656 hp->h_addr_list[0] = (char *) malloc(4);
\r
8657 hp->h_addr_list[0][0] = (char) b0;
\r
8658 hp->h_addr_list[0][1] = (char) b1;
\r
8659 hp->h_addr_list[0][2] = (char) b2;
\r
8660 hp->h_addr_list[0][3] = (char) b3;
\r
8666 sa.sin_family = hp->h_addrtype;
\r
8667 uport = (unsigned short) atoi(port);
\r
8668 sa.sin_port = htons(uport);
\r
8669 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
\r
8671 /* Make connection */
\r
8672 if (connect(s, (struct sockaddr *) &sa,
\r
8673 sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
\r
8674 err = WSAGetLastError();
\r
8679 /* Prepare return value */
\r
8680 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8681 cp->kind = CPSock;
\r
8683 *pr = (ProcRef *) cp;
\r
8689 OpenCommPort(char *name, ProcRef *pr)
\r
8694 char fullname[MSG_SIZ];
\r
8696 if (*name != '\\')
\r
8697 sprintf(fullname, "\\\\.\\%s", name);
\r
8699 strcpy(fullname, name);
\r
8701 h = CreateFile(name, GENERIC_READ | GENERIC_WRITE,
\r
8702 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
\r
8703 if (h == (HANDLE) -1) {
\r
8704 return GetLastError();
\r
8708 if (!SetCommState(h, (LPDCB) &dcb)) return GetLastError();
\r
8710 /* Accumulate characters until a 100ms pause, then parse */
\r
8711 ct.ReadIntervalTimeout = 100;
\r
8712 ct.ReadTotalTimeoutMultiplier = 0;
\r
8713 ct.ReadTotalTimeoutConstant = 0;
\r
8714 ct.WriteTotalTimeoutMultiplier = 0;
\r
8715 ct.WriteTotalTimeoutConstant = 0;
\r
8716 if (!SetCommTimeouts(h, (LPCOMMTIMEOUTS) &ct)) return GetLastError();
\r
8718 /* Prepare return value */
\r
8719 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8720 cp->kind = CPComm;
\r
8723 *pr = (ProcRef *) cp;
\r
8729 OpenLoopback(ProcRef *pr)
\r
8731 DisplayFatalError("Not implemented", 0, 1);
\r
8737 OpenRcmd(char* host, char* user, char* cmd, ProcRef* pr)
\r
8742 struct sockaddr_in sa, mysa;
\r
8743 struct hostent FAR *hp;
\r
8744 unsigned short uport;
\r
8745 WORD wVersionRequested;
\r
8748 char stderrPortStr[MSG_SIZ];
\r
8750 /* Initialize socket DLL */
\r
8751 wVersionRequested = MAKEWORD(1, 1);
\r
8752 err = WSAStartup(wVersionRequested, &wsaData);
\r
8753 if (err != 0) return err;
\r
8755 /* Resolve remote host name */
\r
8756 memset((char *) &sa, 0, sizeof(struct sockaddr_in));
\r
8757 if (!(hp = gethostbyname(host))) {
\r
8758 unsigned int b0, b1, b2, b3;
\r
8760 err = WSAGetLastError();
\r
8762 if (sscanf(host, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) == 4) {
\r
8763 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
\r
8764 hp->h_addrtype = AF_INET;
\r
8766 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
\r
8767 hp->h_addr_list[0] = (char *) malloc(4);
\r
8768 hp->h_addr_list[0][0] = (char) b0;
\r
8769 hp->h_addr_list[0][1] = (char) b1;
\r
8770 hp->h_addr_list[0][2] = (char) b2;
\r
8771 hp->h_addr_list[0][3] = (char) b3;
\r
8777 sa.sin_family = hp->h_addrtype;
\r
8778 uport = (unsigned short) 514;
\r
8779 sa.sin_port = htons(uport);
\r
8780 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
\r
8782 /* Bind local socket to unused "privileged" port address
\r
8784 s = INVALID_SOCKET;
\r
8785 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8786 mysa.sin_family = AF_INET;
\r
8787 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8788 for (fromPort = 1023;; fromPort--) {
\r
8789 if (fromPort < 0) {
\r
8791 return WSAEADDRINUSE;
\r
8793 if (s == INVALID_SOCKET) {
\r
8794 if ((s = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8795 err = WSAGetLastError();
\r
8800 uport = (unsigned short) fromPort;
\r
8801 mysa.sin_port = htons(uport);
\r
8802 if (bind(s, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8803 == SOCKET_ERROR) {
\r
8804 err = WSAGetLastError();
\r
8805 if (err == WSAEADDRINUSE) continue;
\r
8809 if (connect(s, (struct sockaddr *) &sa,
\r
8810 sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
\r
8811 err = WSAGetLastError();
\r
8812 if (err == WSAEADDRINUSE) {
\r
8823 /* Bind stderr local socket to unused "privileged" port address
\r
8825 s2 = INVALID_SOCKET;
\r
8826 memset((char *) &mysa, 0, sizeof(struct sockaddr_in));
\r
8827 mysa.sin_family = AF_INET;
\r
8828 mysa.sin_addr.s_addr = INADDR_ANY;
\r
8829 for (fromPort = 1023;; fromPort--) {
\r
8830 if (fromPort == prevStderrPort) continue; // don't reuse port
\r
8831 if (fromPort < 0) {
\r
8832 (void) closesocket(s);
\r
8834 return WSAEADDRINUSE;
\r
8836 if (s2 == INVALID_SOCKET) {
\r
8837 if ((s2 = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
\r
8838 err = WSAGetLastError();
\r
8844 uport = (unsigned short) fromPort;
\r
8845 mysa.sin_port = htons(uport);
\r
8846 if (bind(s2, (struct sockaddr *) &mysa, sizeof(struct sockaddr_in))
\r
8847 == SOCKET_ERROR) {
\r
8848 err = WSAGetLastError();
\r
8849 if (err == WSAEADDRINUSE) continue;
\r
8850 (void) closesocket(s);
\r
8854 if (listen(s2, 1) == SOCKET_ERROR) {
\r
8855 err = WSAGetLastError();
\r
8856 if (err == WSAEADDRINUSE) {
\r
8858 s2 = INVALID_SOCKET;
\r
8861 (void) closesocket(s);
\r
8862 (void) closesocket(s2);
\r
8868 prevStderrPort = fromPort; // remember port used
\r
8869 sprintf(stderrPortStr, "%d", fromPort);
\r
8871 if (send(s, stderrPortStr, strlen(stderrPortStr) + 1, 0) == SOCKET_ERROR) {
\r
8872 err = WSAGetLastError();
\r
8873 (void) closesocket(s);
\r
8874 (void) closesocket(s2);
\r
8879 if (send(s, UserName(), strlen(UserName()) + 1, 0) == SOCKET_ERROR) {
\r
8880 err = WSAGetLastError();
\r
8881 (void) closesocket(s);
\r
8882 (void) closesocket(s2);
\r
8886 if (*user == NULLCHAR) user = UserName();
\r
8887 if (send(s, user, strlen(user) + 1, 0) == SOCKET_ERROR) {
\r
8888 err = WSAGetLastError();
\r
8889 (void) closesocket(s);
\r
8890 (void) closesocket(s2);
\r
8894 if (send(s, cmd, strlen(cmd) + 1, 0) == SOCKET_ERROR) {
\r
8895 err = WSAGetLastError();
\r
8896 (void) closesocket(s);
\r
8897 (void) closesocket(s2);
\r
8902 if ((s3 = accept(s2, NULL, NULL)) == INVALID_SOCKET) {
\r
8903 err = WSAGetLastError();
\r
8904 (void) closesocket(s);
\r
8905 (void) closesocket(s2);
\r
8909 (void) closesocket(s2); /* Stop listening */
\r
8911 /* Prepare return value */
\r
8912 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
\r
8913 cp->kind = CPRcmd;
\r
8916 *pr = (ProcRef *) cp;
\r
8923 AddInputSource(ProcRef pr, int lineByLine,
\r
8924 InputCallback func, VOIDSTAR closure)
\r
8926 InputSource *is, *is2 = NULL;
\r
8927 ChildProc *cp = (ChildProc *) pr;
\r
8929 is = (InputSource *) calloc(1, sizeof(InputSource));
\r
8930 is->lineByLine = lineByLine;
\r
8932 is->closure = closure;
\r
8933 is->second = NULL;
\r
8934 is->next = is->buf;
\r
8935 if (pr == NoProc) {
\r
8936 is->kind = CPReal;
\r
8937 consoleInputSource = is;
\r
8939 is->kind = cp->kind;
\r
8941 [AS] Try to avoid a race condition if the thread is given control too early:
\r
8942 we create all threads suspended so that the is->hThread variable can be
\r
8943 safely assigned, then let the threads start with ResumeThread.
\r
8945 switch (cp->kind) {
\r
8947 is->hFile = cp->hFrom;
\r
8948 cp->hFrom = NULL; /* now owned by InputThread */
\r
8950 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) NonOvlInputThread,
\r
8951 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8955 is->hFile = cp->hFrom;
\r
8956 cp->hFrom = NULL; /* now owned by InputThread */
\r
8958 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) InputThread,
\r
8959 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8963 is->sock = cp->sock;
\r
8965 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8966 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8970 is2 = (InputSource *) calloc(1, sizeof(InputSource));
\r
8972 is->sock = cp->sock;
\r
8974 is2->sock = cp->sock2;
\r
8975 is2->second = is2;
\r
8977 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8978 (LPVOID) is, CREATE_SUSPENDED, &is->id);
\r
8980 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SocketInputThread,
\r
8981 (LPVOID) is2, CREATE_SUSPENDED, &is2->id);
\r
8985 if( is->hThread != NULL ) {
\r
8986 ResumeThread( is->hThread );
\r
8989 if( is2 != NULL && is2->hThread != NULL ) {
\r
8990 ResumeThread( is2->hThread );
\r
8994 return (InputSourceRef) is;
\r
8998 RemoveInputSource(InputSourceRef isr)
\r
9002 is = (InputSource *) isr;
\r
9003 is->hThread = NULL; /* tell thread to stop */
\r
9004 CloseHandle(is->hThread);
\r
9005 if (is->second != NULL) {
\r
9006 is->second->hThread = NULL;
\r
9007 CloseHandle(is->second->hThread);
\r
9011 int no_wrap(char *message, int count)
\r
9013 ConsoleOutput(message, count, FALSE);
\r
9018 OutputToProcess(ProcRef pr, char *message, int count, int *outError)
\r
9021 int outCount = SOCKET_ERROR;
\r
9022 ChildProc *cp = (ChildProc *) pr;
\r
9023 static OVERLAPPED ovl;
\r
9024 static int line = 0;
\r
9028 if (appData.noJoin || !appData.useInternalWrap)
\r
9029 return no_wrap(message, count);
\r
9032 int width = get_term_width();
\r
9033 int len = wrap(NULL, message, count, width, &line);
\r
9034 char *msg = malloc(len);
\r
9038 return no_wrap(message, count);
\r
9041 dbgchk = wrap(msg, message, count, width, &line);
\r
9042 if (dbgchk != len && appData.debugMode)
\r
9043 fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
\r
9044 ConsoleOutput(msg, len, FALSE);
\r
9051 if (ovl.hEvent == NULL) {
\r
9052 ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
\r
9054 ovl.Internal = ovl.InternalHigh = ovl.Offset = ovl.OffsetHigh = 0;
\r
9056 switch (cp->kind) {
\r
9059 outCount = send(cp->sock, message, count, 0);
\r
9060 if (outCount == SOCKET_ERROR) {
\r
9061 *outError = WSAGetLastError();
\r
9063 *outError = NO_ERROR;
\r
9068 if (WriteFile(((ChildProc *)pr)->hTo, message, count,
\r
9069 &dOutCount, NULL)) {
\r
9070 *outError = NO_ERROR;
\r
9071 outCount = (int) dOutCount;
\r
9073 *outError = GetLastError();
\r
9078 *outError = DoWriteFile(((ChildProc *)pr)->hTo, message, count,
\r
9079 &dOutCount, &ovl);
\r
9080 if (*outError == NO_ERROR) {
\r
9081 outCount = (int) dOutCount;
\r
9089 OutputToProcessDelayed(ProcRef pr, char *message, int count, int *outError,
\r
9092 /* Ignore delay, not implemented for WinBoard */
\r
9093 return OutputToProcess(pr, message, count, outError);
\r
9098 CmailSigHandlerCallBack(InputSourceRef isr, VOIDSTAR closure,
\r
9099 char *buf, int count, int error)
\r
9101 DisplayFatalError("Not implemented", 0, 1);
\r
9104 /* see wgamelist.c for Game List functions */
\r
9105 /* see wedittags.c for Edit Tags functions */
\r
9112 char buf[MSG_SIZ];
\r
9115 if (SearchPath(installDir, appData.icsLogon, NULL, MSG_SIZ, buf, &dummy)) {
\r
9116 f = fopen(buf, "r");
\r
9118 ProcessICSInitScript(f);
\r
9126 StartAnalysisClock()
\r
9128 if (analysisTimerEvent) return;
\r
9129 analysisTimerEvent = SetTimer(hwndMain, (UINT) ANALYSIS_TIMER_ID,
\r
9130 (UINT) 2000, NULL);
\r
9134 SetHighlights(int fromX, int fromY, int toX, int toY)
\r
9136 highlightInfo.sq[0].x = fromX;
\r
9137 highlightInfo.sq[0].y = fromY;
\r
9138 highlightInfo.sq[1].x = toX;
\r
9139 highlightInfo.sq[1].y = toY;
\r
9145 highlightInfo.sq[0].x = highlightInfo.sq[0].y =
\r
9146 highlightInfo.sq[1].x = highlightInfo.sq[1].y = -1;
\r
9150 SetPremoveHighlights(int fromX, int fromY, int toX, int toY)
\r
9152 premoveHighlightInfo.sq[0].x = fromX;
\r
9153 premoveHighlightInfo.sq[0].y = fromY;
\r
9154 premoveHighlightInfo.sq[1].x = toX;
\r
9155 premoveHighlightInfo.sq[1].y = toY;
\r
9159 ClearPremoveHighlights()
\r
9161 premoveHighlightInfo.sq[0].x = premoveHighlightInfo.sq[0].y =
\r
9162 premoveHighlightInfo.sq[1].x = premoveHighlightInfo.sq[1].y = -1;
\r
9166 ShutDownFrontEnd()
\r
9168 if (saveSettingsOnExit) SaveSettings(settingsFileName);
\r
9169 DeleteClipboardTempFiles();
\r
9175 if (IsIconic(hwndMain))
\r
9176 ShowWindow(hwndMain, SW_RESTORE);
\r
9178 SetActiveWindow(hwndMain);
\r
9182 * Prototypes for animation support routines
\r
9184 static void ScreenSquare(int column, int row, POINT * pt);
\r
9185 static void Tween( POINT * start, POINT * mid, POINT * finish, int factor,
\r
9186 POINT frames[], int * nFrames);
\r
9190 AnimateAtomicCapture(int fromX, int fromY, int toX, int toY, int nFrames)
\r
9191 { // [HGM] atomic: animate blast wave
\r
9193 if(appData.debugMode) fprintf(debugFP, "exploding (%d,%d)\n", toX, toY);
\r
9194 explodeInfo.fromX = fromX;
\r
9195 explodeInfo.fromY = fromY;
\r
9196 explodeInfo.toX = toX;
\r
9197 explodeInfo.toY = toY;
\r
9198 for(i=1; i<nFrames; i++) {
\r
9199 explodeInfo.radius = (i*180)/(nFrames-1);
\r
9200 DrawPosition(FALSE, NULL);
\r
9201 Sleep(appData.animSpeed);
\r
9203 explodeInfo.radius = 0;
\r
9204 DrawPosition(TRUE, NULL);
\r
9210 AnimateMove(board, fromX, fromY, toX, toY)
\r
9217 ChessSquare piece;
\r
9218 POINT start, finish, mid;
\r
9219 POINT frames[kFactor * 2 + 1];
\r
9222 if (!appData.animate) return;
\r
9223 if (doingSizing) return;
\r
9224 if (fromY < 0 || fromX < 0) return;
\r
9225 piece = board[fromY][fromX];
\r
9226 if (piece >= EmptySquare) return;
\r
9228 ScreenSquare(fromX, fromY, &start);
\r
9229 ScreenSquare(toX, toY, &finish);
\r
9231 /* All pieces except knights move in straight line */
\r
9232 if (piece != WhiteKnight && piece != BlackKnight) {
\r
9233 mid.x = start.x + (finish.x - start.x) / 2;
\r
9234 mid.y = start.y + (finish.y - start.y) / 2;
\r
9236 /* Knight: make diagonal movement then straight */
\r
9237 if (abs(toY - fromY) < abs(toX - fromX)) {
\r
9238 mid.x = start.x + (finish.x - start.x) / 2;
\r
9242 mid.y = start.y + (finish.y - start.y) / 2;
\r
9246 /* Don't use as many frames for very short moves */
\r
9247 if (abs(toY - fromY) + abs(toX - fromX) <= 2)
\r
9248 Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
\r
9250 Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
\r
9252 animInfo.from.x = fromX;
\r
9253 animInfo.from.y = fromY;
\r
9254 animInfo.to.x = toX;
\r
9255 animInfo.to.y = toY;
\r
9256 animInfo.lastpos = start;
\r
9257 animInfo.piece = piece;
\r
9258 for (n = 0; n < nFrames; n++) {
\r
9259 animInfo.pos = frames[n];
\r
9260 DrawPosition(FALSE, NULL);
\r
9261 animInfo.lastpos = animInfo.pos;
\r
9262 Sleep(appData.animSpeed);
\r
9264 animInfo.pos = finish;
\r
9265 DrawPosition(FALSE, NULL);
\r
9266 animInfo.piece = EmptySquare;
\r
9267 if(gameInfo.variant == VariantAtomic &&
\r
9268 (board[toY][toX] != EmptySquare || fromX != toX && (piece == WhitePawn || piece == BlackPawn) ) )
\r
9269 AnimateAtomicCapture(fromX, fromY, toX, toY, 2*nFrames);
\r
9272 /* Convert board position to corner of screen rect and color */
\r
9275 ScreenSquare(column, row, pt)
\r
9276 int column; int row; POINT * pt;
\r
9279 pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
\r
9280 pt->y = lineGap + row * (squareSize + lineGap);
\r
9282 pt->x = lineGap + column * (squareSize + lineGap);
\r
9283 pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
\r
9287 /* Generate a series of frame coords from start->mid->finish.
\r
9288 The movement rate doubles until the half way point is
\r
9289 reached, then halves back down to the final destination,
\r
9290 which gives a nice slow in/out effect. The algorithmn
\r
9291 may seem to generate too many intermediates for short
\r
9292 moves, but remember that the purpose is to attract the
\r
9293 viewers attention to the piece about to be moved and
\r
9294 then to where it ends up. Too few frames would be less
\r
9298 Tween(start, mid, finish, factor, frames, nFrames)
\r
9299 POINT * start; POINT * mid;
\r
9300 POINT * finish; int factor;
\r
9301 POINT frames[]; int * nFrames;
\r
9303 int n, fraction = 1, count = 0;
\r
9305 /* Slow in, stepping 1/16th, then 1/8th, ... */
\r
9306 for (n = 0; n < factor; n++)
\r
9308 for (n = 0; n < factor; n++) {
\r
9309 frames[count].x = start->x + (mid->x - start->x) / fraction;
\r
9310 frames[count].y = start->y + (mid->y - start->y) / fraction;
\r
9312 fraction = fraction / 2;
\r
9316 frames[count] = *mid;
\r
9319 /* Slow out, stepping 1/2, then 1/4, ... */
\r
9321 for (n = 0; n < factor; n++) {
\r
9322 frames[count].x = finish->x - (finish->x - mid->x) / fraction;
\r
9323 frames[count].y = finish->y - (finish->y - mid->y) / fraction;
\r
9325 fraction = fraction * 2;
\r
9331 HistorySet( char movelist[][2*MOVE_LEN], int first, int last, int current )
\r
9333 MoveHistorySet( movelist, first, last, current, pvInfoList );
\r
9335 EvalGraphSet( first, last, current, pvInfoList );
\r