X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=winboard%2Fwinboard.c;h=139a984a8f7c0ef2fca278ee80dc40a78d902720;hb=refs%2Ftags%2Fv4.3.14;hp=73695204307be95151b6220d1d020708ae53e52b;hpb=062fb2bd92324706eed1fba8d5f7b4015ef2b058;p=xboard.git

diff --git a/winboard/winboard.c b/winboard/winboard.c
index 7369520..139a984 100644
--- a/winboard/winboard.c
+++ b/winboard/winboard.c
@@ -388,6 +388,7 @@ LRESULT CALLBACK
 VOID APIENTRY MenuPopup(HWND hwnd, POINT pt, HMENU hmenu, UINT def);
 void ParseIcsTextMenu(char *icsTextMenuString);
 VOID PopUpMoveDialog(char firstchar);
+VOID PopUpNameDialog(char firstchar);
 VOID UpdateSampleText(HWND hDlg, int id, MyColorizeAttribs *mca);
 
 /* [AS] */
@@ -424,7 +425,7 @@ VOID EngineOutputPopDown();
 BOOL EngineOutputIsUp();
 VOID EngineOutputUpdate( FrontEndProgramStats * stats );
 
-VOID GothicPopUp(char *title, char up);
+VOID GothicPopUp(char *title, VariantClass variant);
 /*
  * Setting "frozen" should disable all user input other than deleting
  * the window.  We do this while engines are initializing themselves.
@@ -691,11 +692,12 @@ InitInstance(HINSTANCE hInstance, int nCmdShow, LPSTR lpCmdLine)
   SetWindowPos(hwndMain, alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
                0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 
+#if 0
   /* [AS] Disable the FRC stuff if not playing the proper variant */
   if( gameInfo.variant != VariantFischeRandom ) {
       EnableMenuItem( GetMenu(hwndMain), IDM_NewGameFRC, MF_GRAYED );
   }
-
+#endif
   if (hwndConsole) {
 #if AOT_CONSOLE
     SetWindowPos(hwndConsole, alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST,
@@ -1168,7 +1170,7 @@ ArgDescriptor argDescriptors[] = {
   { "holdingsSize", ArgInt, (LPVOID) &appData.holdingsSize, TRUE },
   { "matchPause", ArgInt, (LPVOID) &appData.matchPause, TRUE },
   { "pieceToCharTable", ArgString, (LPVOID) &appData.pieceToCharTable, FALSE },
-  { "flipBlack", ArgBoolean, (LPVOID) &appData.allWhite, TRUE },
+  { "flipBlack", ArgBoolean, (LPVOID) &appData.upsideDown, TRUE },
   { "allWhite", ArgBoolean, (LPVOID) &appData.allWhite, TRUE },
   { "alphaRank", ArgBoolean, (LPVOID) &appData.alphaRank, FALSE },
   { "testClaims", ArgBoolean, (LPVOID) &appData.testClaims, TRUE },
@@ -1177,6 +1179,9 @@ ArgDescriptor argDescriptors[] = {
   { "trivialDraws", ArgBoolean, (LPVOID) &appData.trivialDraws, TRUE },
   { "ruleMoves", ArgInt, (LPVOID) &appData.ruleMoves, TRUE },
   { "repeatsToDraw", ArgInt, (LPVOID) &appData.drawRepeats, TRUE },
+  { "autoKibitz", ArgTrue, (LPVOID) &appData.autoKibitz, FALSE },
+  { "engineDebugOutput", ArgInt, (LPVOID) &appData.engineComments, FALSE },
+  { "userName", ArgString, (LPVOID) &appData.userName, FALSE },
 
 #ifdef ZIPPY
   { "zippyTalk", ArgBoolean, (LPVOID) &appData.zippyTalk, FALSE },
@@ -1220,6 +1225,17 @@ ArgDescriptor argDescriptors[] = {
   /* Kludge to allow winboard.ini files from buggy 4.0.4 to be read: */
   { "zippyReplyTimeout", ArgInt, (LPVOID)&junk, FALSE },
 #endif
+  /* [HGM] options for broadcasting and time odds */
+  { "serverMoves", ArgString, (LPVOID) &appData.serverMovesName, FALSE },
+  { "suppressLoadMoves", ArgBoolean, (LPVOID) &appData.suppressLoadMoves, FALSE },
+  { "serverPause", ArgInt, (LPVOID) &appData.serverPause, FALSE },
+  { "firstTimeOdds", ArgInt, (LPVOID) &appData.firstTimeOdds, FALSE },
+  { "secondTimeOdds", ArgInt, (LPVOID) &appData.secondTimeOdds, FALSE },
+  { "timeOddsMode", ArgInt, (LPVOID) &appData.timeOddsMode, TRUE },
+  { "firstAccumulateTC", ArgInt, (LPVOID) &appData.firstAccumulateTC, FALSE },
+  { "secondAccumulateTC", ArgInt, (LPVOID) &appData.secondAccumulateTC, FALSE },
+  { "firstNPS", ArgInt, (LPVOID) &appData.firstNPS, FALSE },
+  { "secondNPS", ArgInt, (LPVOID) &appData.secondNPS, FALSE },
   { NULL, ArgNone, NULL, FALSE }
 };
 
@@ -1896,6 +1912,17 @@ InitAppData(LPSTR lpCmdLine)
   appData.alphaRank    = FALSE;
   appData.allWhite     = FALSE;
   appData.upsideDown   = FALSE;
+  appData.serverPause  = 15;
+  appData.serverMovesName   = NULL;
+  appData.suppressLoadMoves = FALSE;
+  appData.firstTimeOdds  = 1;
+  appData.secondTimeOdds = 1;
+  appData.firstAccumulateTC  = 1; // combine previous and current sessions
+  appData.secondAccumulateTC = 1;
+  appData.firstNPS  = -1; // [HGM] nps: use wall-clock time
+  appData.secondNPS = -1;
+  appData.engineComments = 1;
+
 
 #ifdef ZIPPY
   appData.zippyTalk = ZIPPY_TALK;
@@ -1940,6 +1967,35 @@ InitAppData(LPSTR lpCmdLine)
      appData.NrRanks > BOARD_SIZE   )
       DisplayFatalError("Recompile with BOARD_SIZE > 12, to support this size", 0, 2);
 
+  /* [HGM] After parsing the options from the .ini file, and overruling them
+   * with options from the command line, we now make an even higher priority
+   * overrule by WB options attached to the engine command line. This so that
+   * tournament managers can use WB options (such as /timeOdds) that follow
+   * the engines.
+   */
+  if(appData.firstChessProgram != NULL) {
+      char *p = StrStr(appData.firstChessProgram, "WBopt");
+      static char *f = "first";
+      char buf[MSG_SIZ], *q = buf;
+      if(p != NULL) { // engine command line contains WinBoard options
+          sprintf(buf, p+6, f, f, f, f, f, f, f, f, f, f); // replace %s in them by "first"
+          ParseArgs(StringGet, &q);
+          p[-1] = 0; // cut them offengine command line
+      }
+  }
+  // now do same for second chess program
+  if(appData.secondChessProgram != NULL) {
+      char *p = StrStr(appData.secondChessProgram, "WBopt");
+      static char *s = "second";
+      char buf[MSG_SIZ], *q = buf;
+      if(p != NULL) { // engine command line contains WinBoard options
+          sprintf(buf, p+6, s, s, s, s, s, s, s, s, s, s); // replace %s in them by "first"
+          ParseArgs(StringGet, &q);
+          p[-1] = 0; // cut them offengine command line
+      }
+  }
+
+
   /* Propagate options that affect others */
   if (appData.matchMode || appData.matchGames) chessProgram = TRUE;
   if (appData.icsActive || appData.noChessProgram) {
@@ -2307,7 +2363,7 @@ enum {
     PM_WO = (int) WhiteCannon, 
     PM_WU = (int) WhiteUnicorn, 
     PM_WH = (int) WhiteNightrider, 
-    PM_WA = (int) WhiteCardinal, 
+    PM_WA = (int) WhiteAngel, 
     PM_WC = (int) WhiteMarshall, 
     PM_WG = (int) WhiteGrasshopper, 
     PM_WK = (int) WhiteKing,
@@ -2323,7 +2379,7 @@ enum {
     PM_BO = (int) BlackCannon, 
     PM_BU = (int) BlackUnicorn, 
     PM_BH = (int) BlackNightrider, 
-    PM_BA = (int) BlackCardinal, 
+    PM_BA = (int) BlackAngel, 
     PM_BC = (int) BlackMarshall, 
     PM_BG = (int) BlackGrasshopper, 
     PM_BK = (int) BlackKing
@@ -2554,8 +2610,7 @@ static int TranslatePieceToFontPiece( int piece )
         return PM_WQ;
     case WhiteKing:
         return PM_WK;
-#ifdef FAIRY
-    case BlackCardinal:
+    case BlackAngel:
         return PM_BA;
     case BlackMarshall:
         return PM_BC;
@@ -2575,7 +2630,7 @@ static int TranslatePieceToFontPiece( int piece )
         return PM_BG;
     case BlackMan:
         return PM_BM;
-    case WhiteCardinal:
+    case WhiteAngel:
         return PM_WA;
     case WhiteMarshall:
         return PM_WC;
@@ -2595,7 +2650,6 @@ static int TranslatePieceToFontPiece( int piece )
         return PM_WG;
     case WhiteMan:
         return PM_WM;
-#endif
     }
 
     return 0;
@@ -2677,7 +2731,7 @@ void CreatePiecesFromFont()
                 }
                 else if( strstr(lf.lfFaceName,"WinboardF") != NULL ) {
                     /* Fairy symbols */
-                     SetCharTable(pieceToFontChar, "PNBRQFWEMOUHACGSKpnbrqfwemouhacgsk");
+                     SetCharTable(pieceToFontChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
                 }
                 else if( strstr(lf.lfFaceName,"GC2004D") != NULL ) {
                     /* Good Companion (Some characters get warped as literal :-( */
@@ -3057,10 +3111,15 @@ InitDrawingSizes(BoardSize boardSize, int flags)
     }
   }
 
+  /* [HGM] Licensing requirement */
 #ifdef GOTHIC
-  /* [HGM] Gothic licensing requirement */
-  GothicPopUp( GOTHIC, gameInfo.variant == VariantGothic );
+  if(gameInfo.variant == VariantGothic) GothicPopUp( GOTHIC, VariantGothic); else
+#endif
+#ifdef FALCON
+  if(gameInfo.variant == VariantFalcon) GothicPopUp( FALCON, VariantFalcon); else
 #endif
+  GothicPopUp( "", VariantNormal);
+
 
 /*  if (boardSize == oldBoardSize) return; [HGM] variant might have changed */
   oldBoardSize = boardSize;
@@ -3076,6 +3135,7 @@ InitDrawingSizes(BoardSize boardSize, int flags)
     }
   }
 
+  // Orthodox Chess pieces
   pieceBitmap[0][WhitePawn] = DoLoadBitmap(hInst, "p", squareSize, "s");
   pieceBitmap[0][WhiteKnight] = DoLoadBitmap(hInst, "n", squareSize, "s");
   pieceBitmap[0][WhiteBishop] = DoLoadBitmap(hInst, "b", squareSize, "s");
@@ -3092,84 +3152,179 @@ InitDrawingSizes(BoardSize boardSize, int flags)
   pieceBitmap[2][WhiteRook] = DoLoadBitmap(hInst, "r", squareSize, "w");
   pieceBitmap[2][WhiteKing] = DoLoadBitmap(hInst, "k", squareSize, "w");
   if( !strcmp(appData.variant, "shogi") && (squareSize==72 || squareSize==49)) {
-  pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "s");
-  pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "o");
-  pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "w");
+    // in Shogi, Hijack the unused Queen for Lance
+    pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "s");
+    pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "o");
+    pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "l", squareSize, "w");
   } else {
-  pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "s");
-  pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "o");
-  pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "w");
-  }
-  if(squareSize==72 || squareSize==49) { /* experiment with some home-made bitmaps */
-  pieceBitmap[0][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "s");
-  pieceBitmap[1][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "o");
-  pieceBitmap[2][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "w");
-  pieceBitmap[0][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "s");
-  pieceBitmap[1][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "o");
-  pieceBitmap[2][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "w");
-  pieceBitmap[0][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "s");
-  pieceBitmap[1][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "o");
-  pieceBitmap[2][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "w");
-  pieceBitmap[0][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "s");
-  pieceBitmap[1][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "o");
-  pieceBitmap[2][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "w");
-  pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "s");
-  pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "o");
-  pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "w");
-  pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "s");
-  pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "o");
-  pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "w");
-  if(gameInfo.variant == VariantShogi) { /* promoted Gold represemtations */
-  pieceBitmap[0][WhiteUnicorn] = DoLoadBitmap(hInst, "wp", squareSize, "s");
-  pieceBitmap[1][WhiteUnicorn] = DoLoadBitmap(hInst, "wp", squareSize, "o");
-  pieceBitmap[2][WhiteUnicorn] = DoLoadBitmap(hInst, "w", squareSize, "w");
-  pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "s");
-  pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "o");
-  pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "w", squareSize, "w");
-  pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "s");
-  pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "o");
-  pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "w", squareSize, "w");
-  pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "s");
-  pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "o");
-  pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "w", squareSize, "w");
-  } else {
-  pieceBitmap[0][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "s");
-  pieceBitmap[1][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "o");
-  pieceBitmap[2][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "w");
-  pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "s");
-  pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "o");
-  pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "w");
-  pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "s");
-  pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "o");
-  pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "w");
-  pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "l", squareSize, "s");
-  pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "l", squareSize, "o");
-  pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "l", squareSize, "w");
-  }
-  if(gameInfo.variant != VariantCrazyhouse && gameInfo.variant != VariantShogi) {
-  pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "s");
-  pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "o");
-  pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "w");
-  } else {
-  pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "dk", squareSize, "s");
-  pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "dk", squareSize, "o");
-  pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "dk", squareSize, "w");
-  }
+    pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "s");
+    pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "o");
+    pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "q", squareSize, "w");
+  }
+
+  if(squareSize <= 72 && squareSize >= 33) { 
+    /* A & C are available in most sizes now */
+    if(squareSize != 49 && squareSize != 72 && squareSize != 33) { // Vortex-like
+      pieceBitmap[0][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "s");
+      pieceBitmap[1][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "o");
+      pieceBitmap[2][WhiteAngel] = DoLoadBitmap(hInst, "a", squareSize, "w");
+      pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "s");
+      pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "o");
+      pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "w");
+      pieceBitmap[0][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "s");
+      pieceBitmap[1][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "o");
+      pieceBitmap[2][WhiteCobra] = DoLoadBitmap(hInst, "cv", squareSize, "w");
+      pieceBitmap[0][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "s");
+      pieceBitmap[1][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "o");
+      pieceBitmap[2][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "w");
+    } else { // Smirf-like
+      pieceBitmap[0][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "s");
+      pieceBitmap[1][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "o");
+      pieceBitmap[2][WhiteAngel] = DoLoadBitmap(hInst, "aa", squareSize, "w");
+    }
+    if(gameInfo.variant == VariantGothic) { // Vortex-like
+      pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "s");
+      pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "o");
+      pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "cv", squareSize, "w");
+    } else { // WinBoard standard
+      pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "s");
+      pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "o");
+      pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "c", squareSize, "w");
+    }
+  }
+
+
+  if(squareSize==72 || squareSize==49 || squareSize==33) { /* experiment with some home-made bitmaps */
+    pieceBitmap[0][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "s");
+    pieceBitmap[1][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "o");
+    pieceBitmap[2][WhiteFerz] = DoLoadBitmap(hInst, "f", squareSize, "w");
+    pieceBitmap[0][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "s");
+    pieceBitmap[1][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "o");
+    pieceBitmap[2][WhiteWazir] = DoLoadBitmap(hInst, "w", squareSize, "w");
+    pieceBitmap[0][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "s");
+    pieceBitmap[1][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "o");
+    pieceBitmap[2][WhiteAlfil] = DoLoadBitmap(hInst, "e", squareSize, "w");
+    pieceBitmap[0][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "s");
+    pieceBitmap[1][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "o");
+    pieceBitmap[2][WhiteMan] = DoLoadBitmap(hInst, "m", squareSize, "w");
+    pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "s");
+    pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "o");
+    pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "a", squareSize, "w");
+    pieceBitmap[0][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "s");
+    pieceBitmap[1][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "o");
+    pieceBitmap[2][WhiteDragon] = DoLoadBitmap(hInst, "dk", squareSize, "w");
+    pieceBitmap[0][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "s");
+    pieceBitmap[1][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "o");
+    pieceBitmap[2][WhiteFalcon] = DoLoadBitmap(hInst, "v", squareSize, "w");
+    pieceBitmap[0][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "s");
+    pieceBitmap[1][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "o");
+    pieceBitmap[2][WhiteCobra] = DoLoadBitmap(hInst, "s", squareSize, "w");
+    pieceBitmap[0][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "s");
+    pieceBitmap[1][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "o");
+    pieceBitmap[2][WhiteLance] = DoLoadBitmap(hInst, "l", squareSize, "w");
+    pieceBitmap[0][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "s");
+    pieceBitmap[1][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "o");
+    pieceBitmap[2][WhiteUnicorn] = DoLoadBitmap(hInst, "u", squareSize, "w");
+
+    if(gameInfo.variant == VariantShogi) { /* promoted Gold represemtations */
+      pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "wp", squareSize, "s");
+      pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "wp", squareSize, "o");
+      pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "w", squareSize, "w");
+      pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "s");
+      pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "wn", squareSize, "o");
+      pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "w", squareSize, "w");
+      pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "s");
+      pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "ws", squareSize, "o");
+      pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "w", squareSize, "w");
+      pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "s");
+      pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "wl", squareSize, "o");
+      pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "w", squareSize, "w");
+    } else {
+      pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "s");
+      pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "o");
+      pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "o", squareSize, "w");
+      pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "s");
+      pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "o");
+      pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "h", squareSize, "w");
+      pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "s");
+      pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "o");
+      pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "cv", squareSize, "w");
+      pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "s");
+      pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "o");
+      pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "g", squareSize, "w");
+    }
+
   } else { /* other size, no special bitmaps available. Use smaller symbols */
-      if((int)boardSize < 2) minorSize = sizeInfo[0].squareSize;
-      else  minorSize = sizeInfo[(int)boardSize - 2].squareSize;
-  pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "s");
-  pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "o");
-  pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "w");
-  pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "s");
-  pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "o");
-  pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "b", minorSize, "w");
-  pieceBitmap[0][WhiteMarshall] = DoLoadBitmap(hInst, "r", minorSize, "s");
-  pieceBitmap[1][WhiteMarshall] = DoLoadBitmap(hInst, "r", minorSize, "o");
-  pieceBitmap[2][WhiteMarshall] = DoLoadBitmap(hInst, "r", minorSize, "w");
-  pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "s");
-  pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "o");
-  pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "w");
+    if((int)boardSize < 2) minorSize = sizeInfo[0].squareSize;
+    else  minorSize = sizeInfo[(int)boardSize - 2].squareSize;
+    pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "s");
+    pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "o");
+    pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "n", minorSize, "w");
+    pieceBitmap[0][WhiteCardinal]   = DoLoadBitmap(hInst, "b", minorSize, "s");
+    pieceBitmap[1][WhiteCardinal]   = DoLoadBitmap(hInst, "b", minorSize, "o");
+    pieceBitmap[2][WhiteCardinal]   = DoLoadBitmap(hInst, "b", minorSize, "w");
+    pieceBitmap[0][WhiteDragon]   = DoLoadBitmap(hInst, "r", minorSize, "s");
+    pieceBitmap[1][WhiteDragon]   = DoLoadBitmap(hInst, "r", minorSize, "o");
+    pieceBitmap[2][WhiteDragon]   = DoLoadBitmap(hInst, "r", minorSize, "w");
+    pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "s");
+    pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "o");
+    pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "q", minorSize, "w");
+  }
+
+
+  if(gameInfo.variant == VariantShogi && squareSize == 58)
+  /* special Shogi support in this size */
+  { for (i=0; i<=2; i++) { /* replace all bitmaps */
+      for (piece = WhitePawn;
+           (int) piece < (int) BlackPawn;
+           piece = (ChessSquare) ((int) piece + 1)) {
+        if (pieceBitmap[i][piece] != NULL)
+          DeleteObject(pieceBitmap[i][piece]);
+      }
+    }
+  pieceBitmap[0][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "o");
+  pieceBitmap[0][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "o");
+  pieceBitmap[0][WhiteBishop] = DoLoadBitmap(hInst, "sb", squareSize, "o");
+  pieceBitmap[0][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "o");
+  pieceBitmap[0][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "o");
+  pieceBitmap[0][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "o");
+  pieceBitmap[0][WhiteFerz] = DoLoadBitmap(hInst, "sf", squareSize, "o");
+  pieceBitmap[0][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "o");
+  pieceBitmap[0][WhiteCannon] = DoLoadBitmap(hInst, "su", squareSize, "o");
+  pieceBitmap[0][WhiteNightrider] = DoLoadBitmap(hInst, "sh", squareSize, "o");
+  pieceBitmap[0][WhiteCardinal] = DoLoadBitmap(hInst, "sa", squareSize, "o");
+  pieceBitmap[0][WhiteDragon] = DoLoadBitmap(hInst, "sc", squareSize, "o");
+  pieceBitmap[0][WhiteGrasshopper] = DoLoadBitmap(hInst, "sg", squareSize, "o");
+  pieceBitmap[0][WhiteSilver] = DoLoadBitmap(hInst, "ss", squareSize, "o");
+  pieceBitmap[1][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "o");
+  pieceBitmap[1][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "o");
+  pieceBitmap[1][WhiteBishop] = DoLoadBitmap(hInst, "sb", squareSize, "o");
+  pieceBitmap[1][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "o");
+  pieceBitmap[1][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "o");
+  pieceBitmap[1][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "o");
+  pieceBitmap[1][WhiteFerz] = DoLoadBitmap(hInst, "sf", squareSize, "o");
+  pieceBitmap[1][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "o");
+  pieceBitmap[1][WhiteCannon] = DoLoadBitmap(hInst, "su", squareSize, "o");
+  pieceBitmap[1][WhiteNightrider] = DoLoadBitmap(hInst, "sh", squareSize, "o");
+  pieceBitmap[1][WhiteCardinal] = DoLoadBitmap(hInst, "sa", squareSize, "o");
+  pieceBitmap[1][WhiteDragon] = DoLoadBitmap(hInst, "sc", squareSize, "o");
+  pieceBitmap[1][WhiteGrasshopper] = DoLoadBitmap(hInst, "sg", squareSize, "o");
+  pieceBitmap[1][WhiteSilver] = DoLoadBitmap(hInst, "ss", squareSize, "o");
+  pieceBitmap[2][WhitePawn] = DoLoadBitmap(hInst, "sp", squareSize, "w");
+  pieceBitmap[2][WhiteKnight] = DoLoadBitmap(hInst, "sn", squareSize, "w");
+  pieceBitmap[2][WhiteBishop] = DoLoadBitmap(hInst, "sr", squareSize, "w");
+  pieceBitmap[2][WhiteRook] = DoLoadBitmap(hInst, "sr", squareSize, "w");
+  pieceBitmap[2][WhiteQueen] = DoLoadBitmap(hInst, "sl", squareSize, "w");
+  pieceBitmap[2][WhiteKing] = DoLoadBitmap(hInst, "sk", squareSize, "w");
+  pieceBitmap[2][WhiteFerz] = DoLoadBitmap(hInst, "sw", squareSize, "w");
+  pieceBitmap[2][WhiteWazir] = DoLoadBitmap(hInst, "sw", squareSize, "w");
+  pieceBitmap[2][WhiteCannon] = DoLoadBitmap(hInst, "sp", squareSize, "w");
+  pieceBitmap[2][WhiteNightrider] = DoLoadBitmap(hInst, "sn", squareSize, "w");
+  pieceBitmap[2][WhiteCardinal] = DoLoadBitmap(hInst, "sr", squareSize, "w");
+  pieceBitmap[2][WhiteDragon] = DoLoadBitmap(hInst, "sr", squareSize, "w");
+  pieceBitmap[2][WhiteGrasshopper] = DoLoadBitmap(hInst, "sl", squareSize, "w");
+  pieceBitmap[2][WhiteSilver] = DoLoadBitmap(hInst, "sw", squareSize, "w");
+  minorSize = 0;
   }
 }
 
@@ -3224,7 +3379,7 @@ DrawCoordsOnDC(HDC hdc)
   oldFont = SelectObject(hdc, font[boardSize][COORD_FONT]->hf);
 
   y = boardRect.top + lineGap;
-  x = boardRect.left + lineGap;
+  x = boardRect.left + lineGap + gameInfo.holdingsWidth*(squareSize + lineGap);
 
   SetTextAlign(hdc, TA_LEFT|TA_TOP);
   for (i = 0; i < BOARD_HEIGHT; i++) {
@@ -3233,10 +3388,10 @@ DrawCoordsOnDC(HDC hdc)
     y += squareSize + lineGap;
   }
 
-  start = flipView ? 12-BOARD_WIDTH : 12;
+  start = flipView ? 12-(BOARD_RGHT-BOARD_LEFT) : 12;
 
   SetTextAlign(hdc, TA_RIGHT|TA_BOTTOM);
-  for (i = 0; i < BOARD_WIDTH; i++) {
+  for (i = 0; i < BOARD_RGHT - BOARD_LEFT; i++) {
     str[0] = ranks[start + i];
     ExtTextOut(hdc, x + squareSize - 2, y - 1, 0, NULL, str, 1, NULL);
     x += squareSize + lineGap;
@@ -3319,6 +3474,7 @@ DrawPieceOnDC(HDC hdc, ChessSquare piece, int color, int sqcolor, int x, int y,
 {
   HBITMAP oldBitmap;
   HBRUSH oldBrush;
+  int tmpSize;
 
   if (appData.blindfold) return;
 
@@ -3358,6 +3514,7 @@ DrawPieceOnDC(HDC hdc, ChessSquare piece, int color, int sqcolor, int x, int y,
     BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0,
 	   sqcolor ? SRCCOPY : NOTSRCCOPY);
   } else {
+    tmpSize = squareSize;
     if(minorSize &&
         (piece >= (int)WhiteNightrider && piece <= WhiteGrasshopper ||
          piece >= (int)BlackNightrider && piece <= BlackGrasshopper)  ) {
@@ -3365,24 +3522,31 @@ DrawPieceOnDC(HDC hdc, ChessSquare piece, int color, int sqcolor, int x, int y,
       /* Bitmaps of smaller size are substituted, but we have to align them */
       x += (squareSize - minorSize)>>1;
       y += squareSize - minorSize - 2;
+      tmpSize = minorSize;
     }
     if (color || appData.allWhite ) {
       oldBitmap = SelectObject(tmphdc, PieceBitmap(piece, WHITE_PIECE));
       if( color )
               oldBrush = SelectObject(hdc, whitePieceBrush);
       else    oldBrush = SelectObject(hdc, blackPieceBrush);
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, 0x00B8074A);
+      if(appData.upsideDown && color==flipView)
+        StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, 0x00B8074A);
+      else
+        BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
 #if 0
       /* Use black piece color for outline of white pieces */
       /* Not sure this looks really good (though xboard does it).
 	 Maybe better to have another selectable color, default black */
       SelectObject(hdc, blackPieceBrush); /* could have own brush */
       SelectObject(tmphdc, PieceBitmap(piece, OUTLINE_PIECE));
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, 0x00B8074A);
+      BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
 #else
       /* Use black for outline of white pieces */
       SelectObject(tmphdc, PieceBitmap(piece, OUTLINE_PIECE));
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, SRCAND);
+      if(appData.upsideDown && color==flipView)
+        StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, SRCAND);
+      else
+        BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, SRCAND);
 #endif
     } else {
 #if 0
@@ -3393,15 +3557,18 @@ DrawPieceOnDC(HDC hdc, ChessSquare piece, int color, int sqcolor, int x, int y,
 	 Maybe better to have another selectable color, default medium gray? */
       oldBitmap = SelectObject(tmphdc, PieceBitmap(piece, BLACK_PIECE));
       oldBrush = SelectObject(hdc, whitePieceBrush); /* could have own brush */
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, 0x00B8074A);
+      BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
       SelectObject(tmphdc, PieceBitmap(piece, SOLID_PIECE));
       SelectObject(hdc, blackPieceBrush);
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, 0x00B8074A);
+      BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
 #else
       /* Use square color for details of black pieces */
       oldBitmap = SelectObject(tmphdc, PieceBitmap(piece, SOLID_PIECE));
       oldBrush = SelectObject(hdc, blackPieceBrush);
-      BitBlt(hdc, x, y, squareSize, squareSize, tmphdc, 0, 0, 0x00B8074A);
+      if(appData.upsideDown && !flipView)
+        StretchBlt(hdc, x+tmpSize, y+tmpSize, -tmpSize, -tmpSize, tmphdc, 0, 0, tmpSize, tmpSize, 0x00B8074A);
+      else
+        BitBlt(hdc, x, y, tmpSize, tmpSize, tmphdc, 0, 0, 0x00B8074A);
 #endif
     }
     SelectObject(hdc, oldBrush);
@@ -3802,7 +3969,6 @@ DrawBoardOnDC(HDC hdc, Board board, HDC tmphdc)
       piece_color = (int) piece < (int) BlackPawn;
 
 
-#ifdef FAIRY
       /* [HGM] holdings file: light square or black */
       if(column == BOARD_LEFT-2) {
             if( row > BOARD_HEIGHT - gameInfo.holdingsSize - 1 )
@@ -3825,7 +3991,6 @@ DrawBoardOnDC(HDC hdc, Board board, HDC tmphdc)
       else if( column == BOARD_RGHT) /* right align */
             DisplayHoldingsCount(hdc, x, y, 1, (int) board[row][column]);
       else
-#endif
       if (appData.monoMode) {
         if (piece == EmptySquare) {
           BitBlt(hdc, x, y, squareSize, squareSize, 0, 0, 0,
@@ -3869,6 +4034,15 @@ DrawBoardOnDC(HDC hdc, Board board, HDC tmphdc)
   }
 }
 
+int saveDiagFlag = 0; FILE *diagFile; // [HGM] diag
+void fputDW(FILE *f, int x)
+{
+	fputc(x     & 255, f);
+	fputc(x>>8  & 255, f);
+	fputc(x>>16 & 255, f);
+	fputc(x>>24 & 255, f);
+}
+
 #define MAX_CLIPS 200   /* more than enough */
 
 VOID
@@ -4183,6 +4357,81 @@ HDCDrawPosition(HDC hdc, BOOLEAN repaint, Board board)
 	 boardRect.right - boardRect.left,
 	 boardRect.bottom - boardRect.top,
 	 tmphdc, boardRect.left, boardRect.top, SRCCOPY);
+
+  if(saveDiagFlag) { 
+    BITMAP b; int i, j, m, w, wb, fac=0; char pData[1000000]; 
+    BITMAPINFOHEADER bih; int color[16], nrColors=0;
+
+    GetObject(bufferBitmap, sizeof(b), &b);
+    if(b.bmWidthBytes*b.bmHeight <= 990000) {
+	bih.biSize = sizeof(BITMAPINFOHEADER);
+	bih.biWidth = b.bmWidth;
+	bih.biHeight = b.bmHeight;
+	bih.biPlanes = 1;
+	bih.biBitCount = b.bmBitsPixel;
+	bih.biCompression = 0;
+	bih.biSizeImage = b.bmWidthBytes*b.bmHeight;
+	bih.biXPelsPerMeter = 0;
+	bih.biYPelsPerMeter = 0;
+	bih.biClrUsed = 0;
+	bih.biClrImportant = 0;
+//	fprintf(diagFile, "t=%d\nw=%d\nh=%d\nB=%d\nP=%d\nX=%d\n", 
+//		b.bmType,  b.bmWidth,  b.bmHeight, b.bmWidthBytes,  b.bmPlanes,  b.bmBitsPixel);
+	GetDIBits(tmphdc,bufferBitmap,0,b.bmHeight,pData,(BITMAPINFO*)&bih,DIB_RGB_COLORS);
+//	fprintf(diagFile, "%8x\n", (int) pData);
+
+#if 1
+	wb = b.bmWidthBytes;
+	// count colors
+	for(i=0; i<wb*(b.bmHeight - boardRect.top + OUTER_MARGIN)>>2; i++) {
+		int k = ((int*) pData)[i];
+		for(j=0; j<nrColors; j++) if(color[j] == k) break;
+		if(j >= 16) break;
+		color[j] = k;
+		if(j >= nrColors) nrColors = j+1;
+	}
+	if(j<16) { // 16 colors is enough. Compress to 4 bits per pixel
+		INT p = 0;
+		for(i=0; i<b.bmHeight - boardRect.top + OUTER_MARGIN; i++) {
+		    for(w=0; w<(wb>>2); w+=2) {
+			int k = ((int*) pData)[(wb*i>>2) + w];
+			for(j=0; j<nrColors; j++) if(color[j] == k) break;
+			k = ((int*) pData)[(wb*i>>2) + w + 1];
+			for(m=0; m<nrColors; m++) if(color[m] == k) break;
+			pData[p++] = m | j<<4;
+		    }
+		    while(p&3) pData[p++] = 0;
+		}
+		fac = 3;
+		wb = (wb+31>>5)<<2;
+	}
+	// write BITMAPFILEHEADER
+	fprintf(diagFile, "BM");
+        fputDW(diagFile, wb*(b.bmHeight - boardRect.top + OUTER_MARGIN)+0x36 + (fac?64:0));
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0x36 + (fac?64:0));
+	// write BITMAPINFOHEADER
+        fputDW(diagFile, 40);
+        fputDW(diagFile, b.bmWidth);
+        fputDW(diagFile, b.bmHeight - boardRect.top + OUTER_MARGIN);
+	if(fac) fputDW(diagFile, 0x040001);   // planes and bits/pixel
+        else    fputDW(diagFile, 0x200001);   // planes and bits/pixel
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0);
+        fputDW(diagFile, 0);
+	// write color table
+	if(fac)
+	for(i=0; i<16; i++) fputDW(diagFile, color[i]);
+	// write bitmap data
+	for(i=0; i<wb*(b.bmHeight - boardRect.top + OUTER_MARGIN); i++) 
+		fputc(pData[i], diagFile);
+#endif
+     }
+  }
+
   SelectObject(tmphdc, oldBitmap);
 
   /* Massive cleanup */
@@ -4209,6 +4458,25 @@ HDCDrawPosition(HDC hdc, BOOLEAN repaint, Board board)
   lastDrawnValid = 1;
 }
 
+/* [HGM] diag: Save the current board display to the given open file and close the file */
+int
+SaveDiagram(f)
+     FILE *f;
+{
+    time_t tm;
+    char *fen;
+
+    saveDiagFlag = 1; diagFile = f;
+    HDCDrawPosition(NULL, TRUE, NULL);
+
+    saveDiagFlag = 0;
+
+//    if(f != NULL) fprintf(f, "Sorry, but this feature is still in preparation\n");
+    
+    fclose(f);
+    return TRUE;
+}
+
 
 /*---------------------------------------------------------------------------*\
 | CLIENT PAINT PROCEDURE
@@ -4431,10 +4699,14 @@ MouseEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                   DrawPosition(forceFullRepaint || FALSE, NULL);
              }
           }
+          break;
+        }
+        if (gotPremove) {
+            /* [HGM] it seemed that braces were missing here */
+            SetPremoveHighlights(fromX, fromY, toX, toY);
+            fromX = fromY = -1;
+            break;
         }
-	if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
-	fromX = fromY = -1;
-	break;
       }
       ClearHighlights();
       DrawPosition(forceFullRepaint || FALSE, NULL);
@@ -4460,6 +4732,7 @@ MouseEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
     ReleaseCapture();
     if (fromX == -1) break;
     if (x == fromX && y == fromY) {
+      dragInfo.from.x = dragInfo.from.y = -1;
       /* Upclick on same square */
       if (sameAgain) {
 	/* Clicked same square twice: abort click-click move */
@@ -4470,7 +4743,6 @@ MouseEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 	/* First square clicked: start click-click move */
 	SetHighlights(fromX, fromY, -1, -1);
       }
-      dragInfo.from.x = dragInfo.from.y = -1;
       DrawPosition(forceFullRepaint || FALSE, NULL);
     } else if (dragInfo.from.x < 0 || dragInfo.from.y < 0) {
       /* Errant click; ignore */
@@ -4692,12 +4964,16 @@ Promotion(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 	       SW_SHOW : SW_HIDE);
     /* [HGM] Only allow C & A promotions if these pieces are defined */
     ShowWindow(GetDlgItem(hDlg, PB_Archbishop),
-       (PieceToChar(WhiteCardinal) != '.' ||
-        PieceToChar(BlackCardinal) != '.'   ) ?
+       (PieceToChar(WhiteAngel) >= 'A' &&
+        PieceToChar(WhiteAngel) != '~' ||
+        PieceToChar(BlackAngel) >= 'A' &&
+        PieceToChar(BlackAngel) != '~'   ) ?
 	       SW_SHOW : SW_HIDE);
     ShowWindow(GetDlgItem(hDlg, PB_Chancellor), 
-       (PieceToChar(WhiteMarshall) != '.' ||
-        PieceToChar(BlackMarshall) != '.'   ) ?
+       (PieceToChar(WhiteMarshall) >= 'A' &&
+        PieceToChar(WhiteMarshall) != '~' ||
+        PieceToChar(BlackMarshall) >= 'A' &&
+        PieceToChar(BlackMarshall) != '~'   ) ?
 	       SW_SHOW : SW_HIDE);
     /* [HGM] Hide B & R button in Shogi, use Q as promote, N as defer */
     ShowWindow(GetDlgItem(hDlg, PB_Rook),
@@ -4706,6 +4982,12 @@ Promotion(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
     ShowWindow(GetDlgItem(hDlg, PB_Bishop), 
        gameInfo.variant != VariantShogi ?
 	       SW_SHOW : SW_HIDE);
+    ShowWindow(GetDlgItem(hDlg, IDC_Yes), 
+       gameInfo.variant == VariantShogi ?
+	       SW_SHOW : SW_HIDE);
+    ShowWindow(GetDlgItem(hDlg, IDC_No), 
+       gameInfo.variant == VariantShogi ?
+	       SW_SHOW : SW_HIDE);
     return TRUE;
 
   case WM_COMMAND: /* message: received a command */
@@ -4731,7 +5013,7 @@ Promotion(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
       promoChar = PieceToChar(BlackMarshall);
       break;
     case PB_Archbishop:
-      promoChar = PieceToChar(BlackCardinal);
+      promoChar = PieceToChar(BlackAngel);
       break;
     case PB_Knight:
       promoChar = gameInfo.variant == VariantShogi ? '=' : PieceToChar(BlackKnight);
@@ -4779,7 +5061,7 @@ LoadGameDialog(HWND hwnd, char* title)
   UINT number = 0;
   FILE *f;
   char fileTitle[MSG_SIZ];
-  f = OpenFileDialog(hwnd, FALSE, "",
+  f = OpenFileDialog(hwnd, "rb", "",
  	             appData.oldSaveStyle ? "gam" : "pgn",
 		     GAME_FILT,
 		     title, &number, fileTitle, NULL);
@@ -4986,7 +5268,7 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
         Reset(FALSE, TRUE);
       }
       number = 1;
-      f = OpenFileDialog(hwnd, FALSE, "",
+      f = OpenFileDialog(hwnd, "rb", "",
 			 appData.oldSaveStyle ? "pos" : "fen",
 			 POSITION_FILT,
 			 "Load Position from File", &number, fileTitle, NULL);
@@ -5009,7 +5291,7 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
     case IDM_SaveGame:
       defName = DefaultFileName(appData.oldSaveStyle ? "gam" : "pgn");
-      f = OpenFileDialog(hwnd, TRUE, defName,
+      f = OpenFileDialog(hwnd, "a", defName,
 			 appData.oldSaveStyle ? "gam" : "pgn",
 			 GAME_FILT,
 			 "Save Game to File", NULL, fileTitle, NULL);
@@ -5020,7 +5302,7 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
     case IDM_SavePosition:
       defName = DefaultFileName(appData.oldSaveStyle ? "pos" : "fen");
-      f = OpenFileDialog(hwnd, TRUE, defName,
+      f = OpenFileDialog(hwnd, "a", defName,
 			 appData.oldSaveStyle ? "pos" : "fen",
 			 POSITION_FILT,
 			 "Save Position to File", NULL, fileTitle, NULL);
@@ -5029,6 +5311,17 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
       }
       break;
 
+    case IDM_SaveDiagram:
+      defName = "diagram";
+      f = OpenFileDialog(hwnd, "wb", defName,
+			 "bmp",
+			 DIAGRAM_FILT,
+			 "Save Diagram to File", NULL, fileTitle, NULL);
+      if (f != NULL) {
+	SaveDiagram(f);
+      }
+      break;
+
     case IDM_CopyGame:
       CopyGameToClipboard();
       break;
@@ -5262,6 +5555,10 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
       PopUpMoveDialog('\000');
       break;
 
+    case IDM_TypeInName:
+      PopUpNameDialog('\000');
+      break;
+
     case IDM_Backward:
       BackwardEvent();
       SetFocus(hwndMain);
@@ -5478,7 +5775,7 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
       break;
 
     case EP_WhiteCardinal:
-      EditPositionMenuEvent(WhiteCardinal, fromX, fromY);
+      EditPositionMenuEvent(WhiteAngel, fromX, fromY);
       fromX = fromY = -1;
       break;
 
@@ -5538,7 +5835,7 @@ WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
       break;
 
     case EP_BlackCardinal:
-      EditPositionMenuEvent(BlackCardinal, fromX, fromY);
+      EditPositionMenuEvent(BlackAngel, fromX, fromY);
       fromX = fromY = -1;
       break;
 
@@ -5936,7 +6233,7 @@ OpenFileHook(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
 
 
 FILE *
-OpenFileDialog(HWND hwnd, BOOL write, char *defName, char *defExt,
+OpenFileDialog(HWND hwnd, char *write, char *defName, char *defExt, // [HGM] diag: type of 'write' now string
 	       char *nameFilt, char *dlgTitle, UINT *number,
 	       char fileTitle[MSG_SIZ], char fileName[MSG_SIZ])
 {
@@ -5968,7 +6265,7 @@ OpenFileDialog(HWND hwnd, BOOL write, char *defName, char *defExt,
   openFileName.lpstrInitialDir   = NULL;
   openFileName.lpstrTitle        = dlgTitle;
   openFileName.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY 
-    | (write ? 0 : OFN_FILEMUSTEXIST) 
+    | (write[0] != 'r' ? 0 : OFN_FILEMUSTEXIST) 
     | (number ? OFN_ENABLETEMPLATE | OFN_ENABLEHOOK: 0)
     | (oldDialog ? 0 : OFN_EXPLORER);
   openFileName.nFileOffset       = 0;
@@ -5979,10 +6276,10 @@ OpenFileDialog(HWND hwnd, BOOL write, char *defName, char *defExt,
     (LPOFNHOOKPROC) OldOpenFileHook : (LPOFNHOOKPROC) OpenFileHook;
   openFileName.lpTemplateName    = (LPSTR)(oldDialog ? 1536 : DLG_IndexNumber);
 
-  if (write ? GetSaveFileName(&openFileName) : 
-              GetOpenFileName(&openFileName)) {
+  if (write[0] != 'r' ? GetSaveFileName(&openFileName) : 
+                        GetOpenFileName(&openFileName)) {
     /* open the file */
-    f = fopen(openFileName.lpstrFile, write ? "a" : "rb");
+    f = fopen(openFileName.lpstrFile, write);
     if (f == NULL) {
       MessageBox(hwnd, "File open failed", NULL,
 		 MB_OK|MB_ICONEXCLAMATION);
@@ -6616,6 +6913,59 @@ PopUpMoveDialog(char firstchar)
 
 /*---------------------------------------------------------------------------*\
  *
+ * Type-in name dialog functions
+ * 
+\*---------------------------------------------------------------------------*/
+
+LRESULT CALLBACK
+TypeInNameDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
+{
+  char move[MSG_SIZ];
+  HWND hInput;
+
+  switch (message) {
+  case WM_INITDIALOG:
+    move[0] = (char) lParam;
+    move[1] = NULLCHAR;
+    CenterWindowEx(hDlg, GetWindow(hDlg, GW_OWNER), 1 );
+    hInput = GetDlgItem(hDlg, OPT_Name);
+    SetWindowText(hInput, move);
+    SetFocus(hInput);
+    SendMessage(hInput, EM_SETSEL, (WPARAM)9999, (LPARAM)9999);
+    return FALSE;
+
+  case WM_COMMAND:
+    switch (LOWORD(wParam)) {
+    case IDOK:
+      GetDlgItemText(hDlg, OPT_Name, move, sizeof(move));
+      appData.userName = strdup(move);
+
+      EndDialog(hDlg, TRUE);
+      return TRUE;
+    case IDCANCEL:
+      EndDialog(hDlg, FALSE);
+      return TRUE;
+    default:
+      break;
+    }
+    break;
+  }
+  return FALSE;
+}
+
+VOID
+PopUpNameDialog(char firstchar)
+{
+    FARPROC lpProc;
+    
+      lpProc = MakeProcInstance((FARPROC)TypeInNameDialog, hInst);
+      DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_TypeInName),
+	hwndMain, (DLGPROC)lpProc, (LPARAM)firstchar);
+      FreeProcInstance(lpProc);
+}
+
+/*---------------------------------------------------------------------------*\
+ *
  *  Error dialogs
  * 
 \*---------------------------------------------------------------------------*/
@@ -6761,23 +7111,26 @@ GothicDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 }
 
 VOID
-GothicPopUp(char *title, char up)
+GothicPopUp(char *title, VariantClass variant)
 {
   FARPROC lpProc;
   char *p, *q;
   BOOLEAN modal = hwndMain == NULL;
+  static char *lastTitle;
 
   strncpy(errorTitle, title, sizeof(errorTitle));
   errorTitle[sizeof(errorTitle) - 1] = '\0';
 
-  if(up && gothicDialog == NULL) {
+  if(lastTitle != title && gothicDialog != NULL) {
+    DestroyWindow(gothicDialog);
+    gothicDialog = NULL;
+  }
+  if(variant != VariantNormal && gothicDialog == NULL) {
+    title = lastTitle;
     lpProc = MakeProcInstance((FARPROC)GothicDialog, hInst);
     CreateDialog(hInst, MAKEINTRESOURCE(DLG_Error),
 		 hwndMain, (DLGPROC)lpProc);
     FreeProcInstance(lpProc);
-  } else if(!up && gothicDialog != NULL) {
-    DestroyWindow(gothicDialog);
-    gothicDialog = NULL;
   }
 }
 #endif
@@ -7535,7 +7888,7 @@ DisplayAClock(HDC hdc, int timeRemaining, int highlight,
 
   if (appData.clockMode) {
     if (tinyLayout)
-      sprintf(buf, "%c %s %s %s", color[0], TimeString(timeRemaining), flagFell);
+      sprintf(buf, "%c %s %s", color[0], TimeString(timeRemaining), flagFell);
     else
       sprintf(buf, "%s: %s %s", color, TimeString(timeRemaining), flagFell);
     str = buf;
@@ -8368,6 +8721,7 @@ LRESULT CALLBACK NewGameFRC_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM
         case IDOK:
             *lpIndexFRC = GetDlgItemInt(hDlg, IDC_NFG_Edit, &index_is_ok, TRUE );
             EndDialog( hDlg, 0 );
+	    shuffleOpenings = TRUE; /* [HGM] shuffle: switch shuffling on for as long as we stay in current variant */
             return TRUE;
         case IDCANCEL:
             EndDialog( hDlg, 1 );   
@@ -8380,7 +8734,7 @@ LRESULT CALLBACK NewGameFRC_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM
             }
             return TRUE;
         case IDC_NFG_Random:
-            sprintf( buf, "%d", myrandom() % 960 );
+            sprintf( buf, "%d", myrandom() ); /* [HGM] shuffle: no longer limit to 960 */
             SetDlgItemText(hDlg, IDC_NFG_Edit, buf );
             return TRUE;
         }
@@ -8740,6 +9094,9 @@ UserName()
   static char buf[MSG_SIZ];
   DWORD bufsiz = MSG_SIZ;
 
+  if(appData.userName != NULL && appData.userName[0] != 0) { 
+	return appData.userName; /* [HGM] username: prefer name selected by user over his system login */
+  }
   if (!GetUserName(buf, &bufsiz)) {
     /*DisplayError("Error getting user name", GetLastError());*/
     strcpy(buf, "User");
@@ -8858,7 +9215,7 @@ AutoSaveGame()
   char fileTitle[MSG_SIZ];
 
   defName = DefaultFileName(appData.oldSaveStyle ? "gam" : "pgn");
-  f = OpenFileDialog(hwndMain, TRUE, defName,
+  f = OpenFileDialog(hwndMain, "a", defName,
 		     appData.oldSaveStyle ? "gam" : "pgn",
 		     GAME_FILT, 
 		     "Save Game to File", NULL, fileTitle, NULL);
@@ -9049,7 +9406,7 @@ StartChildProcess(char *cmdLine, char *dir, ProcRef *pr)
 void
 DestroyChildProcess(ProcRef pr, int/*boolean*/ signal)
 {
-  ChildProc *cp;
+  ChildProc *cp; int result;
 
   cp = (ChildProc *) pr;
   if (cp == NULL) return;
@@ -9066,22 +9423,23 @@ DestroyChildProcess(ProcRef pr, int/*boolean*/ signal)
     /*!!if (signal) GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, cp->pid);*/
 
     /* [AS] Special termination modes for misbehaving programs... */
-    if( signal == 9 ) {
+    if( signal == 9 ) { 
+        result = TerminateProcess( cp->hProcess, 0 );
+
         if ( appData.debugMode) {
-            fprintf( debugFP, "Terminating process %u\n", cp->pid );
+            fprintf( debugFP, "Terminating process %u, result=%d\n", cp->pid, result );
         }
-
-        TerminateProcess( cp->hProcess, 0 );
     }
     else if( signal == 10 ) {
         DWORD dw = WaitForSingleObject( cp->hProcess, 3*1000 ); // Wait 3 seconds at most
 
         if( dw != WAIT_OBJECT_0 ) {
+            result = TerminateProcess( cp->hProcess, 0 );
+
             if ( appData.debugMode) {
-                fprintf( debugFP, "Process %u still alive after timeout, killing...\n", cp->pid );
+                fprintf( debugFP, "Process %u still alive after timeout, killing... result=%d\n", cp->pid, result );
             }
 
-            TerminateProcess( cp->hProcess, 0 );
         }
     }