home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / ACAUG1.DMS / in.adf / DataBase.lzx / DATABASE_COVERDISK_CODE / window1.c < prev   
Encoding:
C/C++ Source or Header  |  1996-04-10  |  28.7 KB  |  1,374 lines
  1. /* ----------------------------------------------------------------- */
  2.  
  3. /* window1.c - window 1 code */
  4.  
  5. #include "general.h"
  6.  
  7. #include "window.h"
  8.  
  9. extern struct Image title;
  10.  
  11. #define W1_COUNT 7
  12.  
  13. UBYTE (*w1_list[])(void) = {
  14.  
  15.         CreateGadgetContext1,
  16.         CreateGadgets1,
  17.         CreateWindow1,
  18.         CreateMenu1,
  19.         CreateMenuLayout1,
  20.         InstallMenu1,
  21.         CreateFileRequest 
  22.  
  23. };
  24.  
  25.  
  26.  
  27. /* ----------------------------------------------------------------- */
  28.  
  29. static struct  Window          *s_window_p;   
  30.  
  31. static struct  Menu            *s_menu_p;
  32.  
  33. static struct  Gadget          *s_gadgetlist_p;
  34.  
  35. static struct  Gadget          *s_previous_gadget_p;
  36.  
  37. struct FileRequester           *s_file_requester_p;
  38.  
  39. static STACK   *s_resource_stack_p;
  40.  
  41.  
  42. /* ----------------------------------------------------------------- */
  43.  
  44. UBYTE OpenWindow1(void)
  45.  
  46. {
  47.  
  48. UBYTE error_number=NO_ERROR;
  49.  
  50. if(!(s_resource_stack_p=CreateStack(void *))) error_number=NO_STACK; 
  51.         
  52. else  {
  53.  
  54.       /* attempt to allocate window resources... */
  55.  
  56.          error_number=AllocateResource(W1_COUNT,w1_list);                           
  57.  
  58.          if(!error_number)
  59.          
  60.                 {
  61.  
  62.                  g_handler_sigbit[1]=1<<s_window_p->UserPort->mp_SigBit;
  63.                  
  64.                  /* add (OR) signal bit to global port mask */   
  65.  
  66.                  g_port_mask|=g_handler_sigbit[1];
  67.  
  68.                  if(g_handler_sigbit[3])
  69.  
  70.                  DisableWindow1MenuItem(1,0);
  71.  
  72.                  if(g_handler_sigbit[2])
  73.  
  74.                  DisableWindow1MenuItem(1,1);
  75.                 
  76.                 }
  77.  
  78.      }
  79.  
  80. return(error_number);
  81.  
  82. } /* Logical end of this module */
  83.   
  84. /* ----------------------------------------------------------------- */
  85.  
  86. void CloseWindow1(void)
  87.  
  88. {
  89.  
  90. while(!PopStack(s_resource_stack_p,g_function1)) g_function1(); 
  91.  
  92.        KillStack(s_resource_stack_p);
  93.  
  94.  
  95. g_port_mask^=g_handler_sigbit[1]; /* remove signal bit from mask */  
  96.  
  97. g_handler_sigbit[1]=0; /* clear signal bit entry */
  98.  
  99. s_window_p=NULL; /* to indicate closed window */
  100.  
  101. }
  102.  
  103. /* ----------------------------------------------------------------- */
  104.  
  105.  
  106. UBYTE CreateGadgetContext1(void)
  107.  
  108. {
  109.     
  110. UBYTE error_number=ALLOCATION_ERROR;
  111.  
  112. s_gadgetlist_p=NULL;/* static so must set to zero each time */
  113.  
  114. s_previous_gadget_p=CreateContext(&s_gadgetlist_p);
  115.  
  116. if(s_previous_gadget_p)
  117.  
  118.     {
  119.         
  120.     g_function1=RemoveGadgets1;
  121.         
  122.     PushStack(s_resource_stack_p,g_function1);
  123.     
  124.     if(s_previous_gadget_p) error_number=NO_ERROR;
  125.         
  126.     }
  127.             
  128. return(error_number);
  129.  
  130. }
  131.  
  132. /* ----------------------------------------------------------------------- */
  133.  
  134. void RemoveGadgets1(void)
  135.  
  136. {
  137.         
  138. FreeGadgets(s_gadgetlist_p);        
  139.         
  140. }
  141.  
  142. /* ----------------------------------------------------------------- */
  143.  
  144.  
  145. UBYTE CreateGadgets1(void)
  146.  
  147. {
  148.  
  149. UBYTE error_number=ALLOCATION_ERROR;
  150.  
  151. newgadget.ng_TextAttr=g_public_screen_p->Font;
  152.  
  153. newgadget.ng_VisualInfo=g_visual_info_p;
  154.                           
  155. newgadget.ng_Width=g_w1_gadget1_width;     
  156.              
  157. newgadget.ng_Height=g_w1_gadget1_height;     
  158.              
  159. newgadget.ng_LeftEdge=g_w1_gadget1_x;     
  160.              
  161. newgadget.ng_TopEdge=g_w1_gadget1_y;     
  162.              
  163. newgadget.ng_GadgetText=NULL;
  164.  
  165. s_previous_gadget_p=CreateGadget(LISTVIEW_KIND,s_previous_gadget_p,
  166.                                             &newgadget,
  167.                                             GTLV_Labels,g_database_list_p,
  168.                                             GTLV_ShowSelected,NULL,
  169.                                             LAYOUTA_Spacing,3,
  170.                                             TAG_END);
  171.     
  172. if(s_previous_gadget_p) error_number=NO_ERROR;
  173.                 
  174. return(error_number);
  175.                                 
  176. }
  177.  
  178. /* ----------------------------------------------------------------------- */
  179.  
  180. UBYTE CreateWindow1(void)
  181.  
  182. {
  183.  
  184. UBYTE error_number=ALLOCATION_ERROR;
  185.  
  186. s_window_p=OpenWindowTags(NULL,
  187.         WA_MenuHelp,TRUE,
  188.         WA_Gadgets,s_gadgetlist_p,
  189.         WA_Left,g_w1_x, WA_Top,g_w1_y,
  190.         WA_Width,g_w1_width, WA_Height,g_w1_height,
  191.         WA_DragBar, TRUE,
  192.         WA_DepthGadget, TRUE,
  193.         WA_SizeGadget, TRUE,
  194.         WA_CloseGadget, TRUE,
  195.         WA_SmartRefresh, TRUE,
  196.         WA_MinHeight,W1_MINIMUM_HEIGHT,
  197.         WA_MaxHeight,g_public_screen_p->Height,
  198.         WA_MinWidth,W1_MINIMUM_WIDTH,
  199.         WA_MaxWidth,g_public_screen_p->Width,   
  200.  
  201.         WA_IDCMP, LISTVIEWIDCMP^IDCMP_INTUITICKS /* BLOCKING TICKS */
  202.            |IDCMP_CLOSEWINDOW|IDCMP_MENUPICK|
  203.            IDCMP_REFRESHWINDOW|IDCMP_GADGETUP|
  204.            IDCMP_CHANGEWINDOW|IDCMP_MENUHELP,
  205.         WA_Title, W1_TITLE,
  206.         WA_PubScreen, g_public_screen_p,
  207.         TAG_END);
  208.         
  209. if (s_window_p)
  210.         
  211.         {
  212.         
  213.         SetRast(s_window_p->RPort,3);
  214.  
  215.         RefreshWindowFrame(s_window_p);
  216.  
  217.         DrawImage(s_window_p->RPort,&title,g_w1_title_x,g_w1_title_y);
  218.  
  219.         GT_RefreshWindow(s_window_p,NULL);
  220.         
  221.         error_number=NO_ERROR;
  222.                                
  223.         g_function1=KillWindow1;
  224.         
  225.         PushStack(s_resource_stack_p,g_function1);
  226.                
  227.         }
  228.       
  229. return(error_number);
  230.  
  231. }
  232.  
  233. /* ----------------------------------------------------------------- */
  234.  
  235. void KillWindow1(void)
  236.  
  237. {
  238.  
  239. CloseWindow(s_window_p);
  240.  
  241. }
  242.  
  243. /* ----------------------------------------------------------------- */
  244.  
  245.  
  246. UBYTE CreateMenu1(void)
  247.  
  248. {
  249.  
  250. UBYTE error_number=NO_ERROR;
  251.  
  252. if(!(s_menu_p=CreateMenus(menu1,TAG_END)))
  253.  
  254.         error_number=ALLOCATION_ERROR;
  255.  
  256.   else {
  257.         
  258.         g_function1=ReleaseMenu1;
  259.         
  260.         PushStack(s_resource_stack_p,g_function1);
  261.        
  262.        }
  263.         
  264. return(error_number);
  265.  
  266.  
  267. }
  268.  
  269. /* ----------------------------------------------------------------- */
  270.  
  271. void ReleaseMenu1(void)
  272.  
  273. {
  274.         
  275. FreeMenus(s_menu_p);
  276.         
  277. }
  278.  
  279. /* ----------------------------------------------------------------- */
  280.  
  281. UBYTE CreateMenuLayout1(void)
  282.  
  283. {
  284.  
  285. UBYTE error_number=NO_ERROR;
  286.  
  287. if(!(LayoutMenus(s_menu_p,g_visual_info_p,TAG_END)))
  288.  
  289.         error_number=ALLOCATION_ERROR;
  290.  
  291.   else {
  292.         
  293.         
  294.        /* Function must be tested for success but
  295.           no deallocation operations are needed! */
  296.        
  297.        }
  298.         
  299. return(error_number);
  300.  
  301.  
  302. }
  303.  
  304. /* ----------------------------------------------------------------- */
  305.  
  306. UBYTE InstallMenu1(void)
  307.  
  308. {
  309.  
  310. UBYTE error_number=NO_ERROR;
  311.  
  312. if(!(SetMenuStrip(s_window_p,s_menu_p)))
  313.  
  314.         error_number=ALLOCATION_ERROR;
  315.  
  316.   else {
  317.         
  318.         g_function1=RemoveMenu1;
  319.         
  320.         PushStack(s_resource_stack_p,g_function1);
  321.        
  322.        }
  323.         
  324. return(error_number);
  325.  
  326. }
  327.  
  328. /* ----------------------------------------------------------------- */
  329.  
  330. void RemoveMenu1(void)
  331.  
  332. {
  333.  
  334. ClearMenuStrip(s_window_p);
  335.         
  336. }
  337.  
  338. /* ----------------------------------------------------------------- */
  339.  
  340. UBYTE CreateFileRequest(void)
  341.  
  342. {
  343.  
  344. UBYTE error_number=NO_ERROR;
  345.  
  346. if(!(s_file_requester_p=AllocAslRequestTags(ASL_FileRequest,
  347.                                             ASL_LeftEdge,g_asl_x,
  348.                                             ASL_TopEdge, g_asl_y,
  349.                                             ASL_Width,g_asl_width,
  350.                                             ASL_Height,g_asl_height,
  351.                         ASLFR_RejectIcons,TRUE,
  352.                                             TAG_DONE
  353.                                            )))
  354.  
  355.         error_number=ALLOCATION_ERROR;
  356.  
  357.   else {
  358.         
  359.         g_function1=RemoveFileRequest;
  360.         
  361.         PushStack(s_resource_stack_p,g_function1);
  362.        
  363.        }
  364.        
  365. return(error_number);
  366.  
  367. }
  368.  
  369. /* ----------------------------------------------------------------- */
  370.  
  371. void RemoveFileRequest(void)
  372.  
  373. {
  374.  
  375. FreeAslRequest(s_file_requester_p);
  376.         
  377. }
  378.  
  379. /* ----------------------------------------------------------------- */
  380.  
  381.  
  382.  
  383.  
  384. /* eventhandler1.c - event handling code for window 1 follows */
  385.  
  386.  
  387. /* ----------------------------------------------------------------- */
  388.  
  389. UBYTE EventHandler1(void)
  390.  
  391. {
  392.  
  393. UBYTE error_number=NO_ERROR;
  394.  
  395. struct Message *message_p;
  396.  
  397. while (message_p=(struct Message *)GT_GetIMsg(s_window_p->UserPort))
  398.    
  399.   {          
  400.    
  401.    error_number=IntuitionEvent1((struct IntuiMessage *)message_p);
  402.    
  403.   }
  404.       
  405. return(error_number);
  406.  
  407. }
  408.  
  409. /* ----------------------------------------------------------------- */
  410.  
  411.  
  412. UBYTE IntuitionEvent1(struct IntuiMessage *message_p)
  413.  
  414. {
  415.  
  416. UBYTE i,error_number=NO_ERROR;
  417.  
  418. UWORD code; 
  419.  
  420. ULONG class;
  421.  
  422. void *address;
  423.  
  424. struct Node *node_p;
  425.  
  426. class=message_p->Class; 
  427.             
  428. code= message_p->Code;
  429.  
  430. address=message_p->IAddress;
  431.  
  432. GT_ReplyIMsg(message_p);
  433.  
  434. switch (class) {
  435.  
  436.                 case IDCMP_CLOSEWINDOW: 
  437.                      
  438.                      error_number=PROGRAM_EXIT; break;
  439.                
  440.  
  441.                 case IDCMP_MENUPICK: 
  442.                              
  443.                 error_number=MenuEvent1(code); break;
  444.                              
  445.  
  446.                 case IDCMP_MENUHELP:
  447.  
  448.                      break;
  449.                       
  450.                 
  451.                 case IDCMP_GADGETUP:
  452.                 
  453.                      /* code = ordinal list number (first NODE is 0) */
  454.                    
  455.                      if (code)
  456.                      
  457.                        { 
  458.                         
  459.                         node_p=g_database_list_p->lh_Head;
  460.                              
  461.                         for (i=0;i<code;i++)
  462.                    
  463.                          {
  464.                         
  465.                          node_p=node_p->ln_Succ; /* next node */  
  466.                       
  467.                          }   
  468.  
  469.                          g_current_node_p=(struct ListNode *)node_p;
  470.                       
  471.                          g_new_node=*g_current_node_p; /* copy to editor window */
  472.  
  473.                          DisplayListNode(g_current_node_p);
  474.                         
  475.                         }
  476.                         
  477.                         else DisplayBeep(NULL); /* 1st record selected */
  478.                              
  479.                       break;
  480.  
  481.  
  482.                 case IDCMP_REFRESHWINDOW:
  483.   
  484.                      g_w1_height=s_window_p->Height;
  485.  
  486.                      g_w1_width=s_window_p->Width;
  487.  
  488.                      g_w1_gadget1_width=g_w1_width-3*g_offset-IMAGE_SIZE;
  489.  
  490.                      g_w1_gadget1_height=g_w1_height-2*g_w1_gadget1_y;
  491.  
  492.                      g_w1_title_x=g_w1_gadget1_x+g_w1_gadget1_width;
  493.  
  494.  
  495.                      error_number=REFRESH;
  496.                       
  497.                      break;
  498.                                                     
  499.                     
  500.  
  501.                case IDCMP_CHANGEWINDOW:
  502.                      
  503.                      g_w1_x=s_window_p->LeftEdge;
  504.  
  505.                      g_w1_y=s_window_p->TopEdge;
  506.                                                                         
  507.                      break;
  508.  
  509.                                           
  510.                 case IDCMP_INTUITICKS: 
  511.                 
  512.                      break;
  513.  
  514.                                                                  
  515.                 default:  break;
  516.  
  517.               }
  518.               
  519. return(error_number);
  520.  
  521. }
  522.  
  523. /* ----------------------------------------------------------------- */
  524.  
  525. UBYTE MenuEvent1(UWORD code)
  526.  
  527. {
  528.  
  529. UBYTE error_number=NO_ERROR;
  530.  
  531. UWORD menu_number;
  532.  
  533. if (code!=MENUNULL)
  534.  
  535.   {
  536.                     
  537.   menu_number=MENUNUM(code);
  538.                                   
  539.   switch(menu_number) 
  540.  
  541.    {
  542.     
  543.     case 0:  error_number=ProjectMenuHandler1(code); 
  544.  
  545.              break;
  546.  
  547.     case 1:  error_number=RecordMenuHandler1(code); 
  548.  
  549.              break;
  550.  
  551.     case 2:  error_number=OtherMenuHandler1(code); 
  552.  
  553.              break;
  554.  
  555.                              
  556.     default: break;
  557.  
  558.    } 
  559.  
  560.   }
  561.  
  562. return(error_number);
  563.  
  564. }
  565.  
  566. /* ----------------------------------------------------------------- */
  567.  
  568. UBYTE ProjectMenuHandler1(UWORD code)
  569.  
  570. {
  571.  
  572. UBYTE error_number=NO_ERROR;
  573.  
  574. UWORD item_number,sub_item_number;
  575.  
  576. item_number=ITEMNUM(code);
  577.  
  578. sub_item_number=SUBNUM(code);
  579.          
  580. switch (item_number)
  581.  
  582.         {
  583.  
  584.          case 0: /* NEW */ 
  585.  
  586.                     if (g_handler_sigbit[2]) CloseWindow2();
  587.                       
  588.                     if (g_handler_sigbit[3]) CloseWindow3();
  589.                    
  590.                     RemoveListViewList();
  591.  
  592.                     g_database_list_p=ClearList(g_database_list_p); 
  593.  
  594.                     g_database_list_p=CreateList(); /* new list header */                 
  595.                    
  596.                     g_current_node_p=NULL;
  597.  
  598.                     g_filename_buffer[0]=NULL;
  599.                                     
  600.                     SetHeaderDefaults(&g_database_header); /* for default display */
  601.  
  602.                     SetDefaultFieldLabels();
  603.                     
  604.                     g_creating_flag=TRUE;
  605.  
  606.                     CalculateNewRecordLayout();
  607.   
  608.                     CalculateGadgetPositions(&g_database_header);
  609.                                          
  610.                                     
  611.                     OpenWindow2(); 
  612.                     
  613.                     break;
  614.  
  615.          
  616.          case 1: /* LOAD */                  
  617.                  
  618.                    g_creating_flag=FALSE;                      
  619.  
  620.                    if (GetFileName("LOAD FILE"))
  621.                  
  622.                      {
  623.  
  624.                      SetDefaultFieldLabels();
  625.                      
  626.                      RemoveListViewList();
  627.  
  628.                      g_database_list_p=ClearList(g_database_list_p); 
  629.  
  630.                      if(g_database_list_p=LoadFile(g_filename_buffer))
  631.                      
  632.                            {
  633.                             
  634.                            g_current_node_p=(struct ListNode *)
  635.                                             g_database_list_p->lh_Head;
  636.                                     
  637.                   
  638.                            g_current_node_p=(struct ListNode *)
  639.                            
  640.                            ((struct Node *)g_current_node_p)->ln_Succ;
  641.  
  642.                            g_new_node=*g_current_node_p; /* copy of record data */
  643.  
  644.                            SetGadgetLabels(g_database_list_p,
  645.                                            g_database_header.dh_FieldCount);
  646.           
  647.                            }
  648.  
  649.                       else { 
  650.                       
  651.                             SetHeaderDefaults(&g_database_header); /* for default display */
  652.  
  653.                             ClearGlobalNewNode(g_database_header.dh_FieldCount);        
  654.  
  655.                             g_current_node_p=NULL;
  656.                             
  657.                             DisplayBeep(NULL);                                                  
  658.                          
  659.                            }
  660.                     
  661.                      CalculateGadgetPositions(&g_database_header);
  662.                                                                          
  663.                      }
  664.                  
  665.                    error_number=REFRESH; /* do this regardless */                  
  666.                  
  667.                    break;
  668.             
  669.               
  670.          case 3: /* SAVE */ 
  671.  
  672.                    g_creating_flag=FALSE; 
  673.  
  674.                    if(!strlen(g_filename_buffer))
  675.                          
  676.                      GetFileName("SAVE AS FILE");
  677.                                 
  678.                    error_number=SaveFile(g_filename_buffer);
  679.                  
  680.                  break;
  681.  
  682.           
  683.          
  684.          case 4: /* SAVE AS */
  685.  
  686.                  g_creating_flag=FALSE; 
  687.                      
  688.                  GetFileName("SAVE AS FILE");
  689.                    
  690.                  error_number=SaveFile(g_filename_buffer);
  691.  
  692.                  break;
  693.                  
  694.                   
  695.          case 6: error_number=PROGRAM_EXIT; break;
  696.  
  697.  
  698.         default: DisplayBeep(NULL);    break;
  699.  
  700.         }
  701.  
  702. return(error_number);
  703.  
  704. }
  705.  
  706. /* ----------------------------------------------------------------- */
  707.  
  708. UBYTE RecordMenuHandler1(UWORD code)
  709.  
  710. {
  711.  
  712. UBYTE error_number=NO_ERROR;
  713.  
  714. UWORD item_number;
  715.  
  716. item_number=ITEMNUM(code);
  717.         
  718. switch (item_number)
  719.  
  720.         {
  721.          
  722.          case 0: g_creating_flag=FALSE; 
  723.          
  724.                  error_number=OpenWindow3(); 
  725.                                        
  726.                  break;
  727.  
  728.  
  729.          case 1: g_creating_flag=FALSE;
  730.          
  731.                  error_number=OpenWindow2(); 
  732.                 
  733.                  break;
  734.  
  735.   
  736.          case 3: g_creating_flag=FALSE; 
  737.          
  738.                  if(!OpenClip()) 
  739.          
  740.                     {
  741.  
  742.                      WriteCurrentRecord(&g_database_header);                    
  743.                      
  744.                      CloseClip();
  745.         
  746.                     }
  747.                    
  748.                    else DisplayBeep(NULL);                  
  749.                     
  750.                  break;
  751.  
  752.  
  753.          case 5: g_creating_flag=FALSE;
  754.                  
  755.                  RemoveFromList(); 
  756.         
  757.                  ClearDisplayReadOnly();
  758.                  
  759.                  ClearStringGadgets();
  760.                  
  761.                  break;
  762.  
  763.                  
  764.         default: break;
  765.  
  766.         }
  767.  
  768. return(error_number);
  769.  
  770. }
  771.  
  772. /* ----------------------------------------------------------------- */
  773.  
  774. UBYTE OtherMenuHandler1(UWORD code)
  775.  
  776. {
  777.  
  778. UBYTE error_number=NO_ERROR;
  779.  
  780. UWORD item_number;
  781.  
  782. item_number=ITEMNUM(code);
  783.          
  784. switch (item_number)
  785.  
  786.         {
  787.  
  788.          case 0: /* HELP */ 
  789.                  
  790.                     g_creating_flag=FALSE;
  791.                         
  792.                     break;
  793.   
  794.          default:   break;
  795.  
  796.         }
  797.  
  798. return(error_number);
  799.  
  800. }
  801.  
  802. /* ----------------------------------------------------------------- */
  803.  
  804. UBYTE AddToList(void)
  805.  
  806. {
  807.  
  808. UBYTE i,buffer[MAX_FIELD_SIZE],error_number=ALLOCATION_ERROR;
  809.  
  810. WORD  result=NULL;
  811.  
  812. struct ListNode *memory_p;
  813.  
  814. struct Node *node_p;
  815.  
  816. if (IsListEmpty(g_database_list_p))     
  817.  
  818.        { /* we will be storing field labels in this case! */
  819.  
  820.         if(memory_p=(struct ListNode *) 
  821.                      AllocMem(sizeof(struct ListNode),MEMF_CLEAR))
  822.         
  823.   
  824.            {
  825.   
  826.             *memory_p=g_new_node; /* copy new data */
  827.  
  828.             memory_p->ln_Node.ln_Name=&memory_p->ln_Field[0][0];
  829.            
  830.             buffer[0]=' ';
  831.  
  832.             strncpy(&buffer[1],&memory_p->ln_Field[0][0],
  833.                     g_database_header.dh_FieldSize);
  834.  
  835.             strncpy(&memory_p->ln_Field[0][0],&buffer[0],
  836.                     g_database_header.dh_FieldSize);
  837.                                   
  838.             AddHead(g_database_list_p,(struct Node *)memory_p); 
  839.            
  840.             error_number=NO_ERROR;
  841.             
  842.            }       
  843.            
  844.        }
  845.  
  846.  else {
  847.     
  848.          node_p=g_database_list_p->lh_Head; 
  849.  
  850.          while(node_p)
  851.      
  852.            {
  853.          
  854.            result=stricmp(&g_new_node.ln_Field[0][0],
  855.                   &((struct ListNode *)node_p)->ln_Field[0][0]);            
  856.  
  857.            if(result<0)
  858.               
  859.               
  860.                      {
  861.                         
  862.                         if(memory_p=(struct ListNode *) 
  863.                         AllocMem(sizeof(struct ListNode),MEMF_CLEAR))
  864.           
  865.                         {
  866.   
  867.                         *memory_p=g_new_node; /* copy new data */
  868.  
  869.                         memory_p->ln_Node.ln_Name=&memory_p->ln_Field[0][0]; 
  870.                                                                   
  871.                         Insert(g_database_list_p,(struct Node *)memory_p,
  872.                                node_p->ln_Pred);
  873.  
  874.                         node_p=NULL;              
  875.       
  876.                         error_number=NO_ERROR;   
  877.                        
  878.                         }
  879.                       
  880.                       }                       
  881.  
  882.                  
  883.  
  884.           if (result==0)
  885.              
  886.                       {                        
  887.                      
  888.                         /*  here we must ONLY copy my extra data
  889.                             exec node fields must be left alone */ 
  890.                         
  891.                         for (i=1;i<g_database_header.dh_FieldCount;i++)
  892.                         strncpy(&(((struct ListNode *)node_p)->ln_Field[i][0]),
  893.                         &g_new_node.ln_Field[i][0],
  894.                         g_database_header.dh_FieldSize);                           
  895.                                      
  896.                         node_p=NULL;                   
  897.  
  898.                         error_number=NO_ERROR;    
  899.  
  900.                       }
  901.  
  902.        
  903.                  
  904.           if(result>0)
  905.                  
  906.                       {
  907.                     
  908.                        node_p=node_p->ln_Succ;
  909.                  
  910.                         if(!node_p->ln_Succ) 
  911.               
  912.                           {
  913.  
  914.                           if(memory_p=(struct ListNode *) 
  915.                                        AllocMem(sizeof(struct ListNode),
  916.                                        MEMF_CLEAR))
  917.           
  918.                             {
  919.   
  920.                              *memory_p=g_new_node; /* copy new data */
  921.  
  922.                              memory_p->ln_Node.ln_Name=&memory_p->ln_Field[0][0];
  923.                    
  924.                              AddTail(g_database_list_p,(struct Node *)memory_p);
  925.  
  926.                              node_p=NULL;
  927.  
  928.                              error_number=NO_ERROR;           
  929.         
  930.                             }          
  931.  
  932.                           }                 
  933.         
  934.                       }                
  935.      
  936.     
  937.            }/* end while */
  938.            
  939.        } /* end else */ 
  940.  
  941.   /*  if (!error_number) error_number=REFRESH; */
  942.  
  943. return(error_number);
  944.     
  945. }
  946.  
  947. /* ----------------------------------------------------------------- */
  948.  
  949.  
  950. UBYTE RemoveFromList(void)
  951.  
  952. {
  953.  
  954. UBYTE error_number=NO_ERROR;
  955.  
  956. RemoveListViewList();
  957.  
  958. Remove((struct Node *)g_current_node_p); g_current_node_p=NULL;
  959.     
  960. AddListViewList();
  961.  
  962. ClearDisplayReadOnly(); 
  963.  
  964.  
  965. return(error_number);
  966.     
  967. }
  968.  
  969. /* ----------------------------------------------------------------- */
  970.  
  971.  
  972. struct List *ClearList(struct List *list_p)
  973.  
  974. {
  975.  
  976. struct Node *node_p;
  977.          
  978. /* Deallocate all existing list nodes and list header */
  979.  
  980. if(list_p)
  981.  
  982.   {
  983.                      
  984.    while (node_p=RemHead(list_p))
  985.                  
  986.      FreeMem(node_p,sizeof(struct ListNode));
  987.  
  988.   FreeMem(list_p,sizeof(struct List));
  989.  
  990.   }
  991.   
  992. return(NULL);
  993.  
  994. }
  995.  
  996. /* ----------------------------------------------------------------- */
  997.  
  998. struct List *CreateList(void)
  999.  
  1000. {
  1001.  
  1002. struct List *list_p;
  1003.  
  1004. if (list_p=(struct List *) AllocMem(sizeof(struct List),MEMF_CLEAR))
  1005.         
  1006.      {
  1007.         
  1008.      NewList(list_p);
  1009.  
  1010.      }
  1011.      
  1012. return(list_p);
  1013.     
  1014. }
  1015.  
  1016. /* ----------------------------------------------------------------- */
  1017.  
  1018. UBYTE SaveFile(UBYTE *filename_p)
  1019.  
  1020. {
  1021.  
  1022. UBYTE i,error_number=BAD_FILE;
  1023.  
  1024. FILE *fh;
  1025.  
  1026. struct Node *node_p;
  1027.  
  1028. if(fh=fopen(filename_p,"w"))
  1029.  
  1030.   {              
  1031.  
  1032.    WriteDatabaseHeader(fh);
  1033.       
  1034.    node_p=g_database_list_p->lh_Head; 
  1035.     
  1036.      while(node_p)
  1037.      
  1038.         {
  1039.  
  1040.          WriteRecordHeader(fh);
  1041.  
  1042.          for (i=0;i<g_database_header.dh_FieldCount;i++)
  1043.  
  1044.           {
  1045.            
  1046.            fputs(&(((struct ListNode *)node_p)->ln_Field[i][0]),fh);
  1047.  
  1048.            fputc('\n',fh);
  1049.            
  1050.           }
  1051.           
  1052.          fputc('\n',fh);
  1053.          
  1054.          node_p=node_p->ln_Succ;
  1055.          
  1056.          if(!node_p->ln_Succ) node_p=NULL;
  1057.         
  1058.         }
  1059.  
  1060.    fclose(fh);
  1061.    
  1062.    error_number=NO_ERROR;    
  1063.  
  1064.   }
  1065.  
  1066. return(error_number);    
  1067.  
  1068. }
  1069.  
  1070. /* ----------------------------------------------------------------- */
  1071.  
  1072. void WriteDatabaseHeader(FILE *fh)
  1073.  
  1074. {
  1075.  
  1076. fwrite(&g_database_header,sizeof(struct DatabaseHeader),1,fh);     
  1077.  
  1078. }      
  1079.  
  1080. /* ----------------------------------------------------------------- */
  1081.  
  1082. void WriteRecordHeader(FILE *fh)
  1083.  
  1084. {
  1085.  
  1086. fwrite(&g_descriptor,sizeof(struct RecordHeader),1,fh);  
  1087.  
  1088. }      
  1089.  
  1090. /* ----------------------------------------------------------------- */
  1091.  
  1092. struct List *LoadFile(UBYTE *filename_p)
  1093.  
  1094. {
  1095.  
  1096. UBYTE i,j,exit_flag=FALSE;
  1097.  
  1098. BOOL loop_exit_flag;
  1099.  
  1100. WORD c;
  1101.  
  1102. struct List *list_p=NULL;
  1103.  
  1104. struct ListNode *memory_p;
  1105.  
  1106. FILE *fh;
  1107.  
  1108. if(fh=fopen(filename_p,"r"))
  1109.  
  1110.   {            
  1111.                 
  1112.   if(!ReadDatabaseHeader(fh))
  1113.   
  1114.     {
  1115.  
  1116.     if (list_p=CreateList())
  1117.         
  1118.      {
  1119.  
  1120.      while(!exit_flag)
  1121.      
  1122.         {
  1123.         
  1124.          c=fgetc(fh);
  1125.                
  1126.          if(!feof(fh))   
  1127.          
  1128.            {
  1129.            
  1130.            ungetc(c,fh);
  1131.  
  1132.            if (!ReadRecordHeader(fh))
  1133.  
  1134.              {
  1135.  
  1136.               if (memory_p=(struct ListNode *) 
  1137.                  AllocMem(sizeof(struct ListNode),MEMF_CLEAR))
  1138.  
  1139.                  {
  1140.     
  1141.                   for (i=0;i<g_database_header.dh_FieldCount;i++)
  1142.                   
  1143.                     {
  1144.                       
  1145.                       j=0;loop_exit_flag=FALSE;
  1146.                                             
  1147.                       while(!loop_exit_flag)
  1148.                       
  1149.                           {
  1150.                             
  1151.                             c=fgetc(fh);
  1152.                             
  1153.                             if (c!=(WORD)'\n')
  1154.                             
  1155.                             memory_p->ln_Field[i][j++]=(UBYTE)c;
  1156.                             
  1157.                             else loop_exit_flag=TRUE;
  1158.                             
  1159.                           }
  1160.                         
  1161.                        memory_p->ln_Field[i][j]=NULL;  
  1162.                       
  1163.                      
  1164.  
  1165.                      }
  1166.                  
  1167.                   c=fgetc(fh); /* soak end of record '\n' character */
  1168.                    
  1169.                   memory_p->ln_Node.ln_Name=&memory_p->ln_Field[0][0];
  1170.  
  1171.                   /* We now have a record in memory whose 
  1172.                      location is identified by memory_p */
  1173.  
  1174.                   AddTail(list_p,(struct Node *)memory_p);
  1175.                   
  1176.                   }
  1177.       
  1178.                else exit_flag=TRUE; /* out of memeory */
  1179.              
  1180.               }
  1181.                  
  1182.            }
  1183.         
  1184.          else exit_flag=TRUE;
  1185.          
  1186.         }       
  1187.     
  1188.      }
  1189.      
  1190.     }
  1191.     
  1192.   fclose(fh);   
  1193.  
  1194.   }
  1195.  
  1196. return(list_p);    
  1197.  
  1198. }
  1199.  
  1200. /* ----------------------------------------------------------------- */
  1201.  
  1202. UBYTE ReadDatabaseHeader(FILE *fh)
  1203.  
  1204. {
  1205.  
  1206. UBYTE error_number=BAD_FILE;
  1207.  
  1208. UWORD c,count;
  1209.       
  1210. fread(&g_database_header,sizeof(struct DatabaseHeader),1,fh);
  1211.  
  1212. if(g_database_header.dh_ID==FILE_ID)
  1213.  
  1214.   {
  1215.     
  1216.    count=g_database_header.dh_DatabaseHeaderDataSize-6;    
  1217.    
  1218.    while(count--) c=fgetc(fh); /* skip any other header fields */
  1219.    
  1220.    error_number=NO_ERROR;
  1221.  
  1222.   }
  1223.  
  1224. return(error_number);
  1225.  
  1226. }
  1227.  
  1228. /* ----------------------------------------------------------------- */
  1229.  
  1230. UBYTE ReadRecordHeader(FILE *fh)
  1231.  
  1232. {
  1233.  
  1234. UBYTE error_number=BAD_FILE;
  1235.  
  1236. UWORD c,count;
  1237.       
  1238. fread(&g_descriptor,sizeof(struct RecordHeader),1,fh);
  1239.  
  1240. if(g_descriptor.rh_ID==RECORD_ID)
  1241.  
  1242.   {
  1243.  
  1244.    count=g_descriptor.rh_RecordHeaderDataSize-6;    
  1245.    
  1246.    while(count--) c=fgetc(fh); /* skip any other header fields */
  1247.    
  1248.    error_number=NO_ERROR;
  1249.  
  1250.   }
  1251.  
  1252. return(error_number);
  1253.  
  1254. }
  1255.  
  1256. /* ----------------------------------------------------------------- */
  1257.  
  1258.  
  1259. void EnableWindow1MenuItem(UWORD menu, UWORD item)
  1260.  
  1261. {
  1262.     
  1263.    OnMenu(s_window_p,SHIFTMENU(menu)|SHIFTITEM(item));     
  1264.  
  1265. }
  1266.  
  1267. /* ----------------------------------------------------------------- */
  1268.  
  1269. void DisableWindow1MenuItem(UWORD menu, UWORD item)
  1270.  
  1271. { 
  1272.  
  1273.   OffMenu(s_window_p,SHIFTMENU(menu)|SHIFTITEM(item));     
  1274.  
  1275. }
  1276.  
  1277. /* ----------------------------------------------------------------- */
  1278. BOOL GetFileName(UBYTE *hail_p)
  1279.  
  1280. {
  1281.      
  1282. BOOL error_flag;
  1283.            
  1284. if(AslRequestTags(s_file_requester_p,
  1285.                   ASL_Hail,hail_p,
  1286.                   TAG_DONE))
  1287.           
  1288.     {
  1289.                        
  1290.      error_flag=MakeFilename(s_file_requester_p,g_filename_buffer);                   
  1291.                   
  1292.     }
  1293.                   
  1294.  else DisplayBeep(NULL);                  
  1295.  
  1296. return(error_flag);
  1297.   
  1298. }
  1299.  
  1300. /* ----------------------------------------------------------------- */
  1301. void RemoveListViewList(void)
  1302.  
  1303.                      
  1304. {
  1305.  
  1306. if(s_window_p) GT_SetGadgetAttrs(s_previous_gadget_p,
  1307.                                  s_window_p,NULL,
  1308.                                  GTLV_Labels,NULL,
  1309.                                  TAG_END);  
  1310.  
  1311. }                    
  1312. /* ----------------------------------------------------------------- */
  1313.  
  1314. void AddListViewList(void)
  1315.  
  1316. {
  1317.  
  1318. if(s_window_p) GT_SetGadgetAttrs(s_previous_gadget_p,
  1319.                                  s_window_p,NULL,
  1320.                                  GTLV_Labels,g_database_list_p,
  1321.                                  TAG_END);               
  1322.  
  1323. }   
  1324.                     
  1325. /* ----------------------------------------------------------------- */
  1326.  
  1327. void DisplayListNode(struct ListNode *node_p)                         
  1328.  
  1329. {
  1330.  
  1331. UBYTE error_number=NO_ERROR;
  1332.  
  1333.     
  1334. if (g_handler_sigbit[2]) 
  1335.                          
  1336.     DisplayInEditor();
  1337.  
  1338. if (g_handler_sigbit[3]) 
  1339.    
  1340.     DisplayReadOnly(node_p);                            
  1341.  
  1342. if (!(g_handler_sigbit[2]|g_handler_sigbit[3])) 
  1343.  
  1344.     {
  1345.                 
  1346.      error_number=OpenWindow3();      
  1347.  
  1348.      DisplayReadOnly(node_p);
  1349.         
  1350.     }
  1351.                        
  1352. }
  1353.                         
  1354. /* ----------------------------------------------------------------- */
  1355.  
  1356. void ClearGlobalNewNode(UBYTE count)
  1357.  
  1358.  
  1359. {
  1360.  
  1361. UBYTE i;
  1362.  
  1363. for (i=0;i<count;i++)
  1364.  
  1365.      {
  1366.  
  1367.       g_new_node.ln_Field[i][0]=NULL;
  1368.         
  1369.      }
  1370.  
  1371. }
  1372.  
  1373. /* ----------------------------------------------------------------- */
  1374.