new developer release
[xboard.git] / 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 }