callback.c

   1 /*
   2  * callback.c -- gtk-interface
   3  *
   4  * Copyright 2009, 2010 Free Software Foundation, Inc.
   5  *
   6  * GNU XBoard is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or (at
   9  * your option) any later version.
  10  *
  11  * GNU XBoard is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  18  *
  19  *------------------------------------------------------------------------
  20  ** See the file ChangeLog for a revision history.  */
  21
  22 #include <gtk/gtk.h>
  23 #include "common.h"
  24 #include "xboard.h"
  25 #include <errno.h>
  26 #include "backend.h"
  27
  28 #ifdef ENABLE_NLS
  29 # define  _(s) gettext (s)
  30 # define N_(s) gettext_noop (s)
  31 #else
  32 # define  _(s) (s)
  33 # define N_(s)  s
  34 #endif
  35
  36 extern GtkWidget  *about;
  37 extern GtkWidget  *GUI_Window;
  38 extern GtkWidget  *GUI_Aspect;
  39 extern GtkWidget  *GUI_Menubar;
  40 extern GtkWidget  *GUI_Timer;
  41 extern GtkWidget  *GUI_Buttonbar;
  42 extern GtkWidget  *GUI_Board;
  43
  44 extern char *programVersion;
  45 extern int errorExitStatus;
  46 extern int promotionUp;
  47 extern int fromX;
  48 extern int fromY;
  49 extern int toX;
  50 extern int toY;
  51 extern int squareSize,lineGap;
  52
  53 extern int LoadGamePopUp P((FILE *f, int gameNumber, char *title));
  54 extern int LoadPosition P((FILE *f, int gameNumber, char *title));
  55 extern int SaveGame P((FILE *f, int gameNumber, char *title));
  56 extern int SavePosition P((FILE *f, int gameNumber, char *title));
  57
  58 gboolean
  59 ExposeProc(object, user_data)
  60      GtkObject *object;
  61      gpointer user_data;
  62 {
  63   /* do resizing to a fixed aspect ratio */
  64   GtkRequisition w;
  65   int totalh=0,nw,nh;
  66   float ratio;
  67   int boardWidth,boardHeight,old,new;
  68
  69   nw=GTK_WIDGET(object)->allocation.width;
  70   nh=GTK_WIDGET(object)->allocation.height;
  71
  72   old=squareSize;
  73   squareSize  = nw/(BOARD_WIDTH*1.05+0.05);
  74
  75   if(old!=squareSize)
  76     {
  77       lineGap = squareSize*0.05;
  78
  79       boardWidth  = lineGap + BOARD_WIDTH  * (squareSize + lineGap);
  80       boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
  81
  82       /* get the height of the menus, etc. and calculate the aspect ratio */
  83       gtk_widget_size_request(GTK_WIDGET(GUI_Menubar),   &w);
  84       totalh += w.height;
  85       gtk_widget_size_request(GTK_WIDGET(GUI_Timer),   &w);
  86       totalh += w.height;
  87       gtk_widget_size_request(GTK_WIDGET(GUI_Buttonbar),   &w);
  88       totalh += w.height;
  89
  90       ratio  = ((float)totalh+boardHeight)/((float)boardWidth) ;
  91
  92       gtk_widget_set_size_request(GTK_WIDGET(GUI_Board),
  93                                   boardWidth,boardHeight);
  94
  95       gtk_aspect_frame_set (GTK_ASPECT_FRAME(GUI_Aspect),0,0,ratio,TRUE);
  96
  97       /* recreate pieces with new size... TODO: keep svg in memory and just recreate pixmap instead of reloading files */
  98       CreatePieces();
  99     }
 100   return FALSE; /* return false, so that other expose events are called too */
 101 }
 102
 103 void
 104 QuitProc (object, user_data)
 105      GtkObject *object;
 106      gpointer user_data;
 107 {
 108   gtk_main_quit();
 109   ExitEvent(0);
 110 }
 111
 112 /* Help Menu */
 113 void InfoProc(object, user_data)
 114      GtkObject *object;
 115      gpointer user_data;
 116 {
 117     char buf[MSG_SIZ];
 118     snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
 119             INFODIR, INFOFILE);
 120     system(buf);
 121     return;
 122 }
 123
 124 void ManProc(object, user_data)
 125      GtkObject *object;
 126      gpointer user_data;
 127 {
 128     char buf[MSG_SIZ];
 129     snprintf(buf, sizeof(buf), "xterm -e man xboard &");
 130     system(buf);
 131     return;
 132 }
 133
 134 void HintProc(object, user_data)
 135      GtkObject *object;
 136      gpointer user_data;
 137 {
 138     HintEvent();
 139     return;
 140 }
 141
 142 void BookProc(object, user_data)
 143      GtkObject *object;
 144      gpointer user_data;
 145 {
 146     BookEvent();
 147     return;
 148 }
 149
 150 void AboutProc (object, user_data)
 151      GtkObject *object;
 152      gpointer user_data;
 153 {
 154   GtkWidget               *about;
 155
 156   const gchar *authors[] = {"Tim Mann <tim@tim-mann.org>",
 157                             "John Chanak",
 158                             "Evan Welsh <Evan.Welsh@msdw.com>",
 159                             "Elmar Bartel <bartel@informatik.tu-muenchen.de>",
 160                             "Jochen Wiedmann",
 161                             "Frank McIngvale",
 162                             "Hugh Fisher <Hugh.Fisher@cs.anu.edu.au>",
 163                             "Allessandro Scotti",
 164                             "H.G. Muller <h.g.muller AT hccnet DOT nl>",
 165                             "Eric Mullins <emwine AT earthlink DOT net>",
 166                             "Arun Persaud <arun@nubati.net>"};
 167
 168   /* set up about window */
 169   about =  GTK_WIDGET(gtk_about_dialog_new());
 170
 171   /* fill in some information */
 172   char buf[MSG_SIZ];
 173 #if ZIPPY
 174   char *zippy = " (with Zippy code)";
 175 #else
 176   char *zippy = "";
 177 #endif
 178   sprintf(buf, "%s%s",  programVersion, zippy);
 179
 180   gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about),buf);
 181
 182   gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(about),
 183                                  "Copyright 1991 Digital Equipment Corporation\n"
 184                                  "Enhancements Copyright 1992-2009 Free Software Foundation\n"
 185                                  "Enhancements Copyright 2005 Alessandro Scotti");
 186   gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about),"http://www.gnu.org/software/xboard/");
 187   gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about),authors);
 188   gtk_about_dialog_set_translator_credits(GTK_ABOUT_DIALOG(about),
 189                                           " A. Alper (turkish)\n"
 190                                           " A. Persaud (german)\n");
 191
 192   /* end set up about window */
 193   gtk_dialog_run(GTK_DIALOG (about));
 194   gtk_widget_destroy(about);
 195 }
 196
 197 /* End Help Menu */
 198
 199 /* Mode Menu */
 200
 201 void MachineWhiteProc(object, user_data)
 202      GtkObject *object;
 203      gpointer user_data;
 204 {
 205     MachineWhiteEvent();
 206     return;
 207 }
 208
 209 void MachineBlackProc(object, user_data)
 210      GtkObject *object;
 211      gpointer user_data;
 212 {
 213     MachineBlackEvent();
 214     return;
 215 }
 216
 217 void TwoMachinesProc(object, user_data)
 218      GtkObject *object;
 219      gpointer user_data;
 220 {
 221     TwoMachinesEvent();
 222     return;
 223 }
 224
 225 void IcsClientProc(object, user_data)
 226      GtkObject *object;
 227      gpointer user_data;
 228 {
 229     IcsClientEvent();
 230     return;
 231 }
 232
 233 void
 234 AnalyzeFileProc(object, user_data)
 235      GtkObject *object;
 236      gpointer user_data;
 237 {
 238   if (!first.analysisSupport)
 239     {
 240       char buf[MSG_SIZ];
 241       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
 242       DisplayError(buf, 0);
 243       return;
 244     };
 245   Reset(FALSE, TRUE);
 246
 247   if (!appData.showThinking)
 248     ShowThinkingProc(NULL,NULL);
 249
 250   AnalyzeFileEvent();
 251   FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
 252   AnalysisPeriodicEvent(1);
 253   return;
 254 }
 255
 256 void
 257 AnalyzeModeProc(object, user_data)
 258      GtkObject *object;
 259      gpointer user_data;
 260 {
 261     char buf[MSG_SIZ];
 262
 263     if (!first.analysisSupport)
 264       {
 265         snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
 266         DisplayError(buf, 0);
 267         return;
 268       }
 269     /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
 270     if (appData.icsActive)
 271       {
 272         if (gameMode != IcsObserving)
 273           {
 274             sprintf(buf,_("You are not observing a game"));
 275             DisplayError(buf, 0);
 276             /* secure check */
 277             if (appData.icsEngineAnalyze)
 278               {
 279                 if (appData.debugMode)
 280                   fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
 281                 ExitAnalyzeMode();
 282                 ModeHighlight();
 283               }
 284             return;
 285           }
 286         /* if enable, use want disable icsEngineAnalyze */
 287         if (appData.icsEngineAnalyze)
 288           {
 289             ExitAnalyzeMode();
 290             ModeHighlight();
 291             return;
 292           }
 293         appData.icsEngineAnalyze = TRUE;
 294         if (appData.debugMode)
 295           fprintf(debugFP, _("ICS engine analyze starting... \n"));
 296       }
 297     if (!appData.showThinking)
 298       ShowThinkingProc(NULL,NULL);
 299
 300     AnalyzeModeEvent();
 301     return;
 302 }
 303
 304 void
 305 EditGameProc(object, user_data)
 306      GtkObject *object;
 307      gpointer user_data;
 308 {
 309   EditGameEvent();
 310   return;
 311 }
 312
 313 void
 314 EditPositionProc(object, user_data)
 315      GtkObject *object;
 316      gpointer user_data;
 317 {
 318   EditPositionEvent();
 319   return;
 320 }
 321
 322 void
 323 TrainingProc(object, user_data)
 324      GtkObject *object;
 325      gpointer user_data;
 326 {
 327   TrainingEvent();
 328   return;
 329 }
 330
 331
 332
 333 /* End Mode Menu */
 334
 335 /*
 336  * File menu
 337  */
 338
 339 void
 340 LoadNextGameProc(object, user_data)
 341      GtkObject *object;
 342      gpointer user_data;
 343 {
 344     ReloadGame(1);
 345     return;
 346 }
 347
 348 void
 349 LoadPrevGameProc(object, user_data)
 350      GtkObject *object;
 351      gpointer user_data;
 352 {
 353     ReloadGame(-1);
 354     return;
 355 }
 356
 357 void
 358 ReloadGameProc(object, user_data)
 359      GtkObject *object;
 360      gpointer user_data;
 361 {
 362     ReloadGame(0);
 363     return;
 364 }
 365
 366 void
 367 LoadNextPositionProc(object, user_data)
 368      GtkObject *object;
 369      gpointer user_data;
 370 {
 371     ReloadPosition(1);
 372     return;
 373 }
 374
 375 void
 376 LoadPrevPositionProc(object, user_data)
 377      GtkObject *object;
 378      gpointer user_data;
 379 {
 380     ReloadPosition(-1);
 381     return;
 382 }
 383
 384 void
 385 ReloadPositionProc(object, user_data)
 386      GtkObject *object;
 387      gpointer user_data;
 388 {
 389     ReloadPosition(0);
 390     return;
 391 }
 392
 393 void
 394 LoadPositionProc(object, user_data)
 395      GtkObject *object;
 396      gpointer user_data;
 397 {
 398   if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
 399     {
 400       Reset(FALSE, TRUE);
 401     };
 402
 403   FileNamePopUp(_("Load position file name?"), "", LoadPosition, "rb");
 404   return;
 405 }
 406
 407 void
 408 SaveGameProc(object, user_data)
 409      GtkObject *object;
 410      gpointer user_data;
 411 {
 412   FileNamePopUp(_("Save game file name?"),
 413                 DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),
 414                 SaveGame, "a");
 415   return;
 416 }
 417
 418 void
 419 SavePositionProc(object, user_data)
 420      GtkObject *object;
 421      gpointer user_data;
 422 {
 423   FileNamePopUp(_("Save position file name?"),
 424                 DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),
 425                 SavePosition, "a");
 426   return;
 427 }
 428
 429
 430 /* End File Menu */
 431
 432 void AcceptProc(object, user_data)
 433      GtkObject *object;
 434      gpointer user_data;
 435 {
 436     AcceptEvent();
 437     return;
 438 }
 439
 440 void DeclineProc(object, user_data)
 441      GtkObject *object;
 442      gpointer user_data;
 443 {
 444     DeclineEvent();
 445     return;
 446 }
 447
 448 void RematchProc(object, user_data)
 449      GtkObject *object;
 450      gpointer user_data;
 451 {
 452     RematchEvent();
 453     return;
 454 }
 455
 456 void CallFlagProc(object, user_data)
 457      GtkObject *object;
 458      gpointer user_data;
 459 {
 460     CallFlagEvent();
 461     return;
 462 }
 463
 464 void DrawProc(object, user_data)
 465      GtkObject *object;
 466      gpointer user_data;
 467 {
 468     DrawEvent();
 469     return;
 470 }
 471
 472 void AbortProc(object, user_data)
 473      GtkObject *object;
 474      gpointer user_data;
 475 {
 476     AbortEvent();
 477     return;
 478 }
 479
 480 void AdjournProc(object, user_data)
 481      GtkObject *object;
 482      gpointer user_data;
 483 {
 484     AdjournEvent();
 485     return;
 486 }
 487
 488 void ResignProc(object, user_data)
 489      GtkObject *object;
 490      gpointer user_data;
 491 {
 492     ResignEvent();
 493     return;
 494 }
 495
 496 void StopObservingProc(object, user_data)
 497      GtkObject *object;
 498      gpointer user_data;
 499 {
 500     StopObservingEvent();
 501     return;
 502 }
 503
 504 void StopExaminingProc(object, user_data)
 505      GtkObject *object;
 506      gpointer user_data;
 507 {
 508     StopExaminingEvent();
 509     return;
 510 }
 511
 512 void AdjuWhiteProc(object, user_data)
 513      GtkObject *object;
 514      gpointer user_data;
 515 {
 516     UserAdjudicationEvent(+1);
 517     return;
 518 }
 519
 520 void AdjuBlackProc(object, user_data)
 521      GtkObject *object;
 522      gpointer user_data;
 523 {
 524     UserAdjudicationEvent(-1);
 525     return;
 526 }
 527
 528 void AdjuDrawProc(object, user_data)
 529      GtkObject *object;
 530      gpointer user_data;
 531 {
 532     UserAdjudicationEvent(0);
 533     return;
 534 }
 535
 536 void BackwardProc(object, user_data)
 537      GtkObject *object;
 538      gpointer user_data;
 539 {
 540     BackwardEvent();
 541     return;
 542 }
 543
 544 void ForwardProc(object, user_data)
 545      GtkObject *object;
 546      gpointer user_data;
 547 {
 548     ForwardEvent();
 549     return;
 550 }
 551
 552 void ToStartProc(object, user_data)
 553      GtkObject *object;
 554      gpointer user_data;
 555 {
 556     ToStartEvent();
 557     return;
 558 }
 559
 560 void ToEndProc(object, user_data)
 561      GtkObject *object;
 562      gpointer user_data;
 563 {
 564     ToEndEvent();
 565     return;
 566 }
 567
 568 void RevertProc(object, user_data)
 569      GtkObject *object;
 570      gpointer user_data;
 571 {
 572     RevertEvent();
 573     return;
 574 }
 575
 576 void TruncateGameProc(object, user_data)
 577      GtkObject *object;
 578      gpointer user_data;
 579 {
 580     TruncateGameEvent();
 581     return;
 582 }
 583
 584 void MoveNowProc(object, user_data)
 585      GtkObject *object;
 586      gpointer user_data;
 587 {
 588     MoveNowEvent();
 589     return;
 590 }
 591
 592 void RetractMoveProc(object, user_data)
 593      GtkObject *object;
 594      gpointer user_data;
 595 {
 596     RetractMoveEvent();
 597     return;
 598 }
 599
 600 /* Option Menu */
 601 void
 602 AutocommProc(object, user_data)
 603      GtkObject *object;
 604      gpointer user_data;
 605 {
 606     appData.autoComment = !appData.autoComment;
 607     return;
 608 }
 609
 610 void
 611 AutoflagProc(object, user_data)
 612      GtkObject *object;
 613      gpointer user_data;
 614 {
 615     appData.autoCallFlag = !appData.autoCallFlag;
 616     return;
 617 }
 618
 619 void
 620 AutoflipProc(object, user_data)
 621      GtkObject *object;
 622      gpointer user_data;
 623 {
 624     appData.autoFlipView = !appData.autoFlipView;
 625     return;
 626 }
 627
 628 void
 629 ShowThinkingProc(object, user_data)
 630      GtkObject *object;
 631      gpointer user_data;
 632 {
 633     appData.showThinking = !appData.showThinking;
 634     ShowThinkingEvent();
 635
 636     return;
 637 }
 638
 639 void
 640 HideThinkingProc(object, user_data)
 641      GtkObject *object;
 642      gpointer user_data;
 643 {
 644     appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman;
 645     ShowThinkingEvent();
 646
 647     return;
 648 }
 649
 650 void
 651 FlipViewProc(object, user_data)
 652      GtkObject *object;
 653      gpointer user_data;
 654 {
 655     flipView = !flipView;
 656     DrawPosition(True, NULL);
 657     return;
 658 }
 659
 660 void
 661 AlwaysQueenProc(object, user_data)
 662      GtkObject *object;
 663      gpointer user_data;
 664 {
 665   appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;
 666   return;
 667 }
 668
 669 void
 670 AnimateDraggingProc(object, user_data)
 671      GtkObject *object;
 672      gpointer user_data;
 673 {
 674   appData.animateDragging = !appData.animateDragging;
 675
 676   if (appData.animateDragging)
 677     {
 678       // TODO convert to gtk
 679       //      CreateAnimVars();
 680     };
 681
 682   return;
 683 }
 684
 685 void
 686 AnimateMovingProc(object, user_data)
 687      GtkObject *object;
 688      gpointer user_data;
 689 {
 690   appData.animate = !appData.animate;
 691
 692   if (appData.animate)
 693     {
 694       // TODO convert to gtk
 695       //      CreateAnimVars();
 696     };
 697
 698   return;
 699 }
 700
 701 void
 702 AutobsProc(object, user_data)
 703      GtkObject *object;
 704      gpointer user_data;
 705 {
 706   appData.autoObserve = !appData.autoObserve;
 707   return;
 708 }
 709
 710 void
 711 AutoraiseProc(object, user_data)
 712      GtkObject *object;
 713      gpointer user_data;
 714 {
 715   appData.autoRaiseBoard = !appData.autoRaiseBoard;
 716   return;
 717 }
 718
 719 void
 720 AutosaveProc(object, user_data)
 721      GtkObject *object;
 722      gpointer user_data;
 723 {
 724   appData.autoSaveGames = !appData.autoSaveGames;
 725   return;
 726 }
 727
 728 void
 729 BlindfoldProc(object, user_data)
 730      GtkObject *object;
 731      gpointer user_data;
 732 {
 733   appData.blindfold = !appData.blindfold;
 734   DrawPosition(True, NULL);
 735   return;
 736 }
 737
 738 void
 739 TestLegalityProc(object, user_data)
 740      GtkObject *object;
 741      gpointer user_data;
 742 {
 743   appData.testLegality = !appData.testLegality;
 744   return;
 745 }
 746
 747 void
 748 FlashMovesProc(object, user_data)
 749      GtkObject *object;
 750      gpointer user_data;
 751 {
 752   if (appData.flashCount == 0)
 753     {
 754       appData.flashCount = 3;
 755     }
 756   else
 757     {
 758       appData.flashCount = -appData.flashCount;
 759     };
 760
 761     // TODO: check if this is working correct*/
 762     return;
 763 }
 764
 765 #if HIGHDRAG
 766 void
 767 HighlightDraggingProc(object, user_data)
 768      GtkObject *object;
 769      gpointer user_data;
 770 {
 771   /* TODO: connect to option menu */
 772   appData.highlightDragging = !appData.highlightDragging;
 773   return;
 774 }
 775 #endif
 776
 777 void
 778 HighlightLastMoveProc(object, user_data)
 779      GtkObject *object;
 780      gpointer user_data;
 781 {
 782   appData.highlightLastMove = !appData.highlightLastMove;
 783   return;
 784 }
 785
 786 void
 787 IcsAlarmProc(object, user_data)
 788      GtkObject *object;
 789      gpointer user_data;
 790 {
 791   appData.icsAlarm = !appData.icsAlarm;
 792   return;
 793 }
 794
 795 void
 796 MoveSoundProc(object, user_data)
 797      GtkObject *object;
 798      gpointer user_data;
 799 {
 800   appData.ringBellAfterMoves = !appData.ringBellAfterMoves;
 801   return;
 802 }
 803
 804 void
 805 OldSaveStyleProc(object, user_data)
 806      GtkObject *object;
 807      gpointer user_data;
 808 {
 809   appData.oldSaveStyle = !appData.oldSaveStyle;
 810   return;
 811 }
 812
 813 void
 814 PeriodicUpdatesProc(object, user_data)
 815      GtkObject *object;
 816      gpointer user_data;
 817 {
 818   PeriodicUpdatesEvent(!appData.periodicUpdates);
 819   return;
 820 }
 821
 822 void
 823 PremoveProc(object, user_data)
 824      GtkObject *object;
 825      gpointer user_data;
 826 {
 827   appData.premove = !appData.premove;
 828   return;
 829 }
 830
 831 void
 832 QuietPlayProc(object, user_data)
 833      GtkObject *object;
 834      gpointer user_data;
 835 {
 836   appData.quietPlay = !appData.quietPlay;
 837   return;
 838 }
 839
 840
 841 void
 842 PonderNextMoveProc(object, user_data)
 843      GtkObject *object;
 844      gpointer user_data;
 845 {
 846   PonderNextMoveEvent(!appData.ponderNextMove);
 847   return;
 848 }
 849
 850 void
 851 PopupExitMessageProc(object, user_data)
 852      GtkObject *object;
 853      gpointer user_data;
 854 {
 855   appData.popupExitMessage = !appData.popupExitMessage;
 856   return;
 857 }
 858
 859 void
 860 PopupMoveErrorsProc(object, user_data)
 861      GtkObject *object;
 862      gpointer user_data;
 863 {
 864   appData.popupMoveErrors = !appData.popupMoveErrors;
 865   return;
 866 }
 867
 868
 869
 870 /* end option menu */
 871
 872 gboolean CloseWindowProc(GtkWidget *button)
 873 {
 874     gtk_widget_destroy(gtk_widget_get_toplevel(button));
 875     return TRUE;
 876 }
 877
 878 void
 879 ResetProc (object, user_data)
 880      GtkObject *object;
 881      gpointer user_data;
 882 {
 883   ResetGameEvent();
 884   return;
 885 }
 886
 887 void WhiteClockProc(object, user_data)
 888      GtkObject *object;
 889      gpointer user_data;
 890 {
 891     if (gameMode == EditPosition || gameMode == IcsExamining) {
 892         SetWhiteToPlayEvent();
 893     } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {
 894         CallFlagEvent();
 895     }
 896 }
 897
 898 void BlackClockProc(object, user_data)
 899      GtkObject *object;
 900      gpointer user_data;
 901 {
 902     if (gameMode == EditPosition || gameMode == IcsExamining) {
 903         SetBlackToPlayEvent();
 904     } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {
 905         CallFlagEvent();
 906     }
 907 }
 908
 909
 910 void ShowCoordsProc(object, user_data)
 911      GtkObject *object;
 912      gpointer user_data;
 913 {
 914     appData.showCoords = !appData.showCoords;
 915
 916     DrawPosition(True, NULL);
 917 }
 918
 919 void ErrorPopDownProc(object, user_data)
 920      GtkObject *object;
 921      gpointer user_data;
 922 {
 923   gtk_widget_destroy(GTK_WIDGET(object));
 924   ErrorPopDown();
 925 }
 926
 927 void PauseProc(object, user_data)
 928      GtkObject *object;
 929      gpointer user_data;
 930 {
 931     // todo this toggling of the pause button doesn't seem to work?
 932     // e.g. select pause from buttonbar doesn't activate menumode.pause
 933   PauseEvent();
 934 }
 935
 936
 937 void LoadGameProc(object, user_data)
 938      GtkObject *object;
 939      gpointer user_data;
 940 {
 941   FileNamePopUp(_("Load game file name?"),"",LoadGamePopUp,"rb");
 942   return;
 943 }
 944
 945
 946 /*************
 947  * EVENTS
 948  *************/
 949
 950 void EventProc(window, event, data)
 951      GtkWindow *window;
 952      GdkEvent *event;
 953      gpointer data;
 954 {
 955   /* todo do we still need this?
 956     if (!XtIsRealized(widget))
 957       return;
 958   */
 959
 960     switch (event->type) {
 961       case GDK_EXPOSE:
 962         if (event->expose.count > 0) return;  /* no clipping is done */
 963         DrawPosition(True, NULL);
 964         break;
 965       default:
 966         return;
 967     }
 968 }
 969
 970
 971 /*
 972  * event handler for parsing user moves
 973  */
 974 void UserMoveProc(window, event, data)
 975      GtkWindow *window;
 976      GdkEvent *event;
 977      gpointer data;
 978 {
 979     if (errorExitStatus != -1) return;
 980
 981     if (promotionUp)
 982       {
 983         if (event->type == GDK_BUTTON_PRESS)
 984           {
 985             promotionUp = False;
 986             ClearHighlights();
 987             fromX = fromY = -1;
 988           }
 989         else
 990           {
 991             return;
 992           }
 993       }
 994
 995     // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
 996     if(event->type == GDK_BUTTON_PRESS)   LeftClick(Press,   (int)event->button.x, (int)event->button.y);
 997     if(event->type == GDK_BUTTON_RELEASE) LeftClick(Release, (int)event->button.x, (int)event->button.y);
 998
 999     return;
1000 }
1001
1002 void GetMoveListProc(object, user_data)
1003      GtkObject *object;
1004      gpointer user_data;
1005 {
1006   appData.getMoveList = !appData.getMoveList;
1007
1008   if (appData.getMoveList)
1009     {
1010       GetMoveListEvent();
1011     }
1012
1013   // gets set automatically? if we set it with set_active we end up in an endless loop switching between 0 and 1
1014   //  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (object),(gboolean) appData.getMoveList );
1015
1016   return;
1017 }