home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / chaos5_3src.lha / chaos / src / RoundsAmi.c < prev   
Encoding:
C/C++ Source or Header  |  1994-11-20  |  13.1 KB  |  448 lines
  1. /*  Chaos:            The Chess HAppening Organisation System    V5.3
  2.     Copyright (C)   1993    Jochen Wiedmann
  3.  
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18.  
  19.     $RCSfile: RoundsAmi.c,v $
  20.     $Revision: 3.2 $
  21.     $Date: 1994/11/19 19:32:01 $
  22.  
  23.     This file contains the system dependent part of the functions to enter
  24.     results.
  25.  
  26.     Computer:    Amiga 1200            Compiler:    Dice 2.07.54 (3.0)
  27.  
  28.     Author:    Jochen Wiedmann
  29.         Am Eisteich 9
  30.       72555 Metzingen
  31.         Tel. 07123 / 14881
  32.         Internet: wiedmann@mailserv.zdv.uni-tuebingen.de
  33. */
  34.  
  35.  
  36. #ifndef CHAOS_H
  37. #include "chaos.h"
  38. #endif
  39.  
  40.  
  41.  
  42.  
  43. /*
  44.     GetRoundNr() allows the user to select a round.
  45.  
  46.     Result: round number or 0, if the user cancels
  47. */
  48. #define ID_RndSelWnd_Ok     20
  49. #define ID_RndSelWnd_Cancel    21
  50. #define ID_RndselWnd_Rnd    22
  51.  
  52.  
  53. int GetRoundNr(void)
  54.  
  55. #ifdef AMIGA
  56. { ULONG open, signal;
  57.   int round = 0;
  58.   APTR RndSelWnd;        /*    round select window            */
  59.   APTR RndSelWnd_Ok;        /*    Ok button (round select window)     */
  60.   APTR RndSelWnd_Cancel;    /*    Cancel button (round select window) */
  61.   APTR RndSelWnd_Rnd;        /*    round number gadget            */
  62.   int Ok_SC = *GetChaosString(MSG_OK_SC);
  63.   int Cancel_SC = *GetChaosString(MSG_CANCEL_SC);
  64.  
  65.   if (NumRounds == 1)
  66.   { return(1);
  67.   }
  68.  
  69.   RndSelWnd_Rnd = SliderObject,
  70.     MUIA_Slider_Max, NumRounds,
  71.     MUIA_Slider_Level, NumRounds,
  72.     MUIA_Slider_Min, 1,
  73.     End;
  74.  
  75.   RndSelWnd = WindowObject,
  76.         MUIA_Window_ID, MAKE_ID('R','N','D','S'),
  77.         MUIA_Window_Title, GetChaosString(WND_RNDSEL_TITLE),
  78.         MUIA_Window_DefaultObject, RndSelWnd_Rnd,
  79.         WindowContents, VGroup,
  80.             Child, TextObject,
  81.             MUIA_Text_Contents, GetChaosString(WND_RNDSEL_TEXT),
  82.             End,
  83.             Child, RndSelWnd_Rnd,
  84.             Child, HGroup,
  85.             Child, RndSelWnd_Ok = KeyButton(GetChaosString(MSG_OK), Ok_SC),
  86.             Child, RndSelWnd_Cancel = KeyButton(GetChaosString(MSG_CANCEL_INPUT), Cancel_SC),
  87.             End,
  88.         End,
  89.         End;
  90.  
  91.   if (!RndSelWnd)
  92.   { return(0);
  93.   }
  94.   DoMethod(App, OM_ADDMEMBER, RndSelWnd);
  95.   DoMethod(RndSelWnd, MUIM_Window_SetCycleChain, RndSelWnd_Rnd,
  96.        RndSelWnd_Ok, RndSelWnd_Cancel, NULL);
  97.  
  98.   /*
  99.       Setting up the notification events for the round select window:
  100.       CloseWindow, Ok-, and Cancel-button and the round number gadget.
  101.   */
  102.   DoMethod(RndSelWnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  103.        App, 2, MUIM_Application_ReturnID, ID_RndSelWnd_Cancel);
  104.   DoMethod(RndSelWnd_Cancel, MUIM_Notify, MUIA_Pressed, FALSE, App, 2,
  105.        MUIM_Application_ReturnID, ID_RndSelWnd_Cancel);
  106.   DoMethod(RndSelWnd, MUIM_Notify, MUIA_Window_InputEvent, "ctrl return",
  107.        App, 2, MUIM_Application_ReturnID, ID_RndSelWnd_Ok);
  108.   DoMethod(RndSelWnd_Ok, MUIM_Notify, MUIA_Pressed, FALSE,
  109.        App, 2, MUIM_Application_ReturnID, ID_RndSelWnd_Ok);
  110.  
  111.   set(MainWnd, MUIA_Window_Open, FALSE);
  112.   set(RndSelWnd, MUIA_Window_Open, TRUE);
  113.   get(RndSelWnd, MUIA_Window_Open, &open);
  114.   if (!open)
  115.   { MUIError((char *) GetChaosString(ERRMSG_CANNOT_OPEN_WINDOW));
  116.     DoMethod(App, OM_REMMEMBER, RndSelWnd);
  117.     MUI_DisposeObject(RndSelWnd);
  118.     return(0);
  119.   }
  120.  
  121.   for(;;)
  122.   { switch(DoMethod(App, MUIM_Application_Input, &signal))
  123.     { case MUIV_Application_ReturnID_Quit:
  124.     if (TestSaved())
  125.     { exit(0);
  126.     }
  127.     break;
  128.       case ID_RndSelWnd_Ok:
  129.     get(RndSelWnd_Rnd, MUIA_Slider_Level, &round);
  130.       case ID_RndSelWnd_Cancel:
  131.     set(RndSelWnd, MUIA_Window_Open, FALSE);
  132.     DoMethod(App, OM_REMMEMBER, RndSelWnd);
  133.     MUI_DisposeObject(RndSelWnd);
  134.     return(round);
  135.     }
  136.  
  137.     if (signal)
  138.     { Wait(signal);
  139.     }
  140.   }
  141. }
  142. #endif    /*  AMIGA   */
  143.  
  144.  
  145.  
  146.  
  147. /*
  148.     TerminateRsltWnd() closes the result window.
  149. */
  150. #ifdef AMIGA
  151. static APTR RsltWnd = NULL;    /*  Result window            */
  152. static APTR RsltWnd_OkGad;    /*  Ok button (result window)           */
  153. static APTR RsltWnd_CancelGad;    /*  Cancel button (result window)       */
  154. static APTR RsltWnd_GmLV;    /*  game listview gadget (result window)*/
  155. static APTR RsltWnd_Rslt;    /*  result radio gadget         */
  156. static APTR RsltWnd_Mode;    /*  result mode radio gadget        */
  157.  
  158. void TerminateRsltWnd(void)
  159.  
  160. { if (RsltWnd)
  161.   { set(RsltWnd, MUIA_Window_Open, FALSE);
  162.     DoMethod(App, OM_REMMEMBER, RsltWnd);
  163.     MUI_DisposeObject(RsltWnd);
  164.     RsltWnd = NULL;
  165.   }
  166. }
  167. #endif    /*  AMIGA   */
  168.  
  169.  
  170.  
  171.  
  172. #ifdef AMIGA
  173. /*
  174.     This is the MUI-displayhook. The following function gets called, when
  175.     a game is displayed.
  176. */
  177. SAVEDS ASM static LONG DispRsltFunc(REG(a1) struct GameNode *gn,
  178.                     REG(a2) char **array)
  179.  
  180. {
  181.   *array++ = gn->Text;
  182.   *array++ = gn->White->Name;
  183.   *array++ = ": ";
  184.   *array++ = gn->Black->Name;
  185.   *array   = gn->Text + strlen(gn->Text) + 1;
  186.   return(0);
  187. }
  188. #ifdef AZTEC_C
  189. extern LONG MyDispRsltFunc (struct GameNode *gn, char **array);
  190. #asm
  191.         xref    _geta4
  192. _MyDispRsltFunc:
  193.         move.l    a4,-(sp)
  194.         jsr    _geta4
  195.         move.l    a2,-(sp)
  196.         move.l    a1,-(sp)
  197.         jsr    _DispRsltFunc
  198.         add.l    #8,sp
  199.         move.l    (sp)+,a4
  200.         rts
  201. #endasm
  202. #define DispRsltFunc MyDispRsltFunc
  203. #endif    /*  AZTEC_C */
  204. struct Hook RsltWnd_GmListDispHook =
  205. { NULL, NULL, (void *) DispRsltFunc, NULL, NULL
  206. };
  207. #endif    /*  AMIGA   */
  208.  
  209.  
  210.  
  211.  
  212. /*
  213.     InitRsltWnd() initializes the window to enter results.
  214.  
  215.     Inputs: title   - window title
  216.         rlist   - list of GameNode structures created using GetRound()
  217.  
  218.     Result: TRUE, if successfull, FALSE otherwise
  219. */
  220. #ifdef AMIGA
  221. #define ID_RsltWnd_Ok        14
  222. #define ID_RsltWnd_Cancel    15
  223. #define ID_RsltWnd_Rslt     16
  224. #define ID_RsltWnd_Mode     17
  225. #define ID_RsltWnd_GmLV     18
  226. #define ID_RsltWnd_White    23
  227. #define ID_RsltWnd_Draw     24
  228. #define ID_RsltWnd_Black    25
  229. #define ID_RsltWnd_Missing    26
  230. #define ID_RsltWnd_Played    27
  231. #define ID_RsltWnd_NotPlayed    28
  232. #define ID_RsltWnd_Down     29
  233.  
  234. int InitRsltWnd(char *title, struct MinList *rlist)
  235.  
  236. { ULONG open;
  237.   struct GameNode *gn;
  238.   static STRPTR RsltWnd_Rslt_Entries[5];
  239.   static STRPTR RsltWnd_Mode_Entries[3];
  240.   int Ok_SC = *GetChaosString(MSG_OK_SC);
  241.   int Cancel_SC = *GetChaosString(MSG_CANCEL_SC);
  242.  
  243.   RsltWnd_Rslt_Entries[0] = GetChaosString(MSG_WHITE_WINS_INPUT);
  244.   RsltWnd_Rslt_Entries[1] = GetChaosString(MSG_DRAW_INPUT);
  245.   RsltWnd_Rslt_Entries[2] = GetChaosString(MSG_BLACK_WINS_INPUT);
  246.   RsltWnd_Rslt_Entries[3] = GetChaosString(MSG_RESULT_MISSING_INPUT);
  247.   RsltWnd_Rslt_Entries[4] = NULL;
  248.   RsltWnd_Mode_Entries[0] = GetChaosString(MSG_AUSGETRAGEN_INPUT);
  249.   RsltWnd_Mode_Entries[1] = GetChaosString(MSG_KAMPFLOS_INPUT);
  250.   RsltWnd_Mode_Entries[2] = NULL;
  251.  
  252.   RsltWnd = WindowObject,
  253.         MUIA_Window_ID, MAKE_ID('R','S','L','T'),
  254.         MUIA_Window_Title, title,
  255.         MUIA_Window_DefaultObject, RsltWnd_GmLV,
  256.         WindowContents, VGroup,
  257.             Child, RsltWnd_GmLV = ListviewObject,
  258.             MUIA_Listview_List, ListObject,
  259.                 MUIA_List_Format, ",,,,",
  260.                 MUIA_List_DisplayHook, &RsltWnd_GmListDispHook,
  261.                 InputListFrame,
  262.             End,
  263.             End,
  264.             Child, HGroup,
  265.             Child, RsltWnd_OkGad = KeyButton(GetChaosString(MSG_OK), Ok_SC),
  266.             Child, HSpace(10),
  267.             Child, RsltWnd_Rslt = Radio(GetChaosString(RADIO_RESULT_TITLE),
  268.                             RsltWnd_Rslt_Entries),
  269.             Child, RsltWnd_Mode = Radio(GetChaosString(RADIO_MODE_TITLE),
  270.                             RsltWnd_Mode_Entries),
  271.             Child, HSpace(10),
  272.             Child, RsltWnd_CancelGad = KeyButton(GetChaosString(MSG_CANCEL_INPUT), Cancel_SC),
  273.             End,
  274.         End,
  275.         End;
  276.  
  277.   if (!RsltWnd)
  278.   { return(FALSE);
  279.   }
  280.   DoMethod(App, OM_ADDMEMBER, RsltWnd);
  281.   DoMethod(RsltWnd, MUIM_Window_SetCycleChain, RsltWnd_GmLV, RsltWnd_OkGad,
  282.        RsltWnd_Rslt, RsltWnd_Mode, RsltWnd_CancelGad, NULL);
  283.  
  284.   /*
  285.       Setting up the notification events for the result window:
  286.       CloseWindow, Ok-, and Cancel-button, the result and result-mode
  287.       gadgets and the result keys.
  288.   */
  289.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  290.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Cancel);
  291.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent, "esc",
  292.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Cancel);
  293.   DoMethod(RsltWnd_CancelGad, MUIM_Notify, MUIA_Pressed, FALSE,
  294.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Cancel);
  295.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent, "ctrl return",
  296.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Ok);
  297.   DoMethod(RsltWnd_OkGad, MUIM_Notify, MUIA_Pressed, FALSE,
  298.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Ok);
  299.   DoMethod(RsltWnd_Rslt, MUIM_Notify, MUIA_Radio_Active, MUIV_EveryTime,
  300.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Rslt);
  301.   DoMethod(RsltWnd_Mode, MUIM_Notify, MUIA_Radio_Active, MUIV_EveryTime,
  302.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Mode);
  303.   DoMethod(RsltWnd_GmLV, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
  304.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_GmLV);
  305.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  306.        GetChaosString(KEY_RESULT_WHITE),
  307.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_White);
  308.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  309.        GetChaosString(KEY_RESULT_BLACK),
  310.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Black);
  311.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  312.        GetChaosString(KEY_RESULT_MISSING),
  313.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Missing);
  314.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  315.        GetChaosString(KEY_RESULT_DRAW),
  316.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Draw);
  317.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  318.        GetChaosString(KEY_RESULT_PLAYED),
  319.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_Played);
  320.   DoMethod(RsltWnd, MUIM_Notify, MUIA_Window_InputEvent,
  321.        GetChaosString(KEY_RESULT_NPLAYED),
  322.        App, 2, MUIM_Application_ReturnID, ID_RsltWnd_NotPlayed);
  323.  
  324.   /*
  325.       Initialize the window settings
  326.   */
  327.   gn = (struct GameNode *) rlist->mlh_Head;
  328.   for (gn = (struct GameNode *) rlist->mlh_Head;
  329.        gn->gn_Node.mln_Succ != NULL;
  330.        gn = (struct GameNode *) gn->gn_Node.mln_Succ)
  331.   { DoMethod(RsltWnd_GmLV, MUIM_List_Insert, &gn, 1,
  332.          MUIV_List_Insert_Bottom);
  333.   }
  334.   set(RsltWnd_GmLV, MUIA_List_Active, MUIV_List_Active_Top);
  335.  
  336.  
  337.   set(RsltWnd, MUIA_Window_Open, TRUE);
  338.   get(RsltWnd, MUIA_Window_Open, &open);
  339.   if (!open)
  340.   { MUIError((char *) GetChaosString(ERRMSG_CANNOT_OPEN_WINDOW));
  341.     return(FALSE);
  342.   }
  343.   return(TRUE);
  344. }
  345. #endif
  346.  
  347.  
  348.  
  349.  
  350. /*
  351.     ProcessRsltWnd() allows the user to enter the results.
  352.  
  353.     Input: rlist    - A list of GameNode structures created using
  354.               GetRound(). The function may modify the contents.
  355.  
  356.     Result: -1    - The user has selected the Ok button, process the changes
  357.         1    - Indicates, that ProcessRsltWnd() wants to be called again
  358.         0    - The user has terminated via Cancel button
  359. */
  360. int ProcessRsltWnd(struct MinList *rlist)
  361.  
  362. #ifdef AMIGA
  363. { ULONG Signal, id;
  364.   struct GameNode *gn;
  365.   LONG result, mode;
  366.   extern struct Library *MUIMasterBase;
  367.  
  368.   /*
  369.       Check for user actions
  370.   */
  371.   switch (id = DoMethod(App, MUIM_Application_Input, &Signal))
  372.   { case MUIV_Application_ReturnID_Quit:
  373.       if (TestSaved())
  374.       { exit(0);
  375.       }
  376.       break;
  377.     case ID_RsltWnd_Cancel:
  378.       return(0);
  379.     case ID_RsltWnd_Ok:
  380.       return(-1);
  381.     case ID_RsltWnd_Rslt:
  382.     case ID_RsltWnd_White:
  383.     case ID_RsltWnd_Draw:
  384.     case ID_RsltWnd_Black:
  385.     case ID_RsltWnd_Missing:
  386.       DoMethod(RsltWnd_GmLV, MUIM_List_GetEntry, MUIV_List_GetEntry_Active,
  387.            &gn);
  388.       if (gn != NULL)
  389.       { if (id == ID_RsltWnd_Rslt)
  390.     { get(RsltWnd_Rslt, MUIA_Radio_Active, &result);
  391.     }
  392.     else
  393.     { result = id - ID_RsltWnd_White;
  394.     }
  395.     gn->Result = 2-result;
  396.     FormatGame(gn, 2);
  397.     DoMethod(RsltWnd_GmLV, MUIM_List_Redraw, MUIV_List_Redraw_Active);
  398.     if (MUIMasterBase->lib_Version >= 7)
  399.     { SetAttrs(RsltWnd_GmLV, MUIA_NoNotify, TRUE, MUIA_List_Active,
  400.            MUIV_List_Active_Down, TAG_DONE);
  401.     }
  402.       }
  403.     case ID_RsltWnd_GmLV:
  404.       DoMethod(RsltWnd_GmLV, MUIM_List_GetEntry, MUIV_List_GetEntry_Active,
  405.            &gn);
  406.       if (gn != NULL)
  407.       { SetAttrs(RsltWnd_Rslt, MUIA_NoNotify, TRUE,
  408.                    MUIA_Radio_Active, 2-gn->Result,
  409.                    TAG_DONE);
  410.     SetAttrs(RsltWnd_Mode, MUIA_NoNotify, TRUE,
  411.                    MUIA_Radio_Active,
  412.                     (gn->Flags & GMFLAGSF_NOFIGHT) ? 1 : 0,
  413.                    TAG_DONE);
  414.       }
  415.       if (id != ID_RsltWnd_Rslt  &&  id != ID_RsltWnd_GmLV  &&
  416.       MUIMasterBase->lib_Version < 7)
  417.       { DoMethod(App, MUIM_Application_ReturnID, ID_RsltWnd_Down);
  418.       }
  419.       break;
  420.     case ID_RsltWnd_Down:
  421.       set(RsltWnd_GmLV, MUIA_List_Active, MUIV_List_Active_Down);
  422.       break;
  423.     case ID_RsltWnd_Mode:
  424.     case ID_RsltWnd_Played:
  425.     case ID_RsltWnd_NotPlayed:
  426.       DoMethod(RsltWnd_GmLV, MUIM_List_GetEntry, MUIV_List_GetEntry_Active,
  427.            &gn);
  428.       if (gn != NULL)
  429.       { if (id == ID_RsltWnd_Mode)
  430.       { get(RsltWnd_Mode, MUIA_Radio_Active, &mode);
  431.       }
  432.     else
  433.       { mode = id - ID_RsltWnd_Played;
  434.       }
  435.     gn->Flags = (gn->Flags & ~GMFLAGSF_NOFIGHT) |
  436.             (mode ? GMFLAGSF_NOFIGHT : 0);
  437.     FormatGame(gn, 2);
  438.     DoMethod(RsltWnd_GmLV, MUIM_List_Redraw, MUIV_List_Redraw_Active);
  439.       }
  440.       break;
  441.   }
  442.   if (Signal)
  443.   { Wait(Signal);
  444.   }
  445.   return(1);
  446. }
  447. #endif    /*  AMIGA   */
  448.