callback.c

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