/* ----------------------------------------------------------------- */

/* window2.c - window 2 (record editor) code */

#include "general.h"


extern struct NewGadget newgadget;

extern struct NewMenu  menu2[];

#define W2_COUNT 6

UBYTE (*w2_list[])(void) = {

        CreateGadgetContext2,
        CreateGadgets2,
        CreateWindow2,
        CreateMenu2,
        CreateMenuLayout2,
        InstallMenu2
};


TEXT *gadget_labels2[]={
"Store",
"Clear"
};

static UBYTE (*gadget_function[])(void) = {
        StoreData,   
        ClearStringGadgets 

};


/* ----------------------------------------------------------------- */

static struct  Window          *s_window_p;   

static struct  Menu            *s_menu_p;

static struct  Gadget          *s_gadgetlist_p;

static struct  Gadget          *s_previous_gadget_p;

static STACK   *s_resource_stack_p;

/* ----------------------------------------------------------------- */

UBYTE OpenWindow2(void)

{

UBYTE error_number=NO_ERROR;

if(!(s_resource_stack_p=CreateStack(void *))) error_number=NO_STACK; 
        
else  {

      /* attempt to allocate window resources... */

         error_number=AllocateResource(W2_COUNT,w2_list);                           

         if(!error_number)
         
                {

                 if (g_current_node_p) DisplayInEditor();
                 
                   else ClearStringGadgets();
                 
                 g_handler_sigbit[2]=1<<s_window_p->UserPort->mp_SigBit;
                 
                 /* add (OR) signal bit to global port mask */   

                 g_port_mask|=g_handler_sigbit[2];
             
                 if(g_handler_sigbit[1]) DisableWindow1MenuItem(1,1);

                }

     }

return(error_number);

} /* Logical end of this module */
  
/* ----------------------------------------------------------------- */

void CloseWindow2(void)

{

while(!PopStack(s_resource_stack_p,g_function1)) g_function1(); 
 
       KillStack(s_resource_stack_p);
 

g_port_mask^=g_handler_sigbit[2]; /* remove signal bit from mask */  

g_handler_sigbit[2]=0; /* clear signal bit entry */

s_window_p=NULL; /* indicates a closed window */

if(g_handler_sigbit[1]) EnableWindow1MenuItem(1,1);
 
}
 
/* ----------------------------------------------------------------- */


UBYTE CreateGadgetContext2(void)

{
    
UBYTE error_number=ALLOCATION_ERROR;

s_gadgetlist_p=NULL;/* static so must set to zero each time */

s_previous_gadget_p=CreateContext(&s_gadgetlist_p);

if(s_previous_gadget_p)

    {
        
    g_function1=RemoveGadgets2;
        
    PushStack(s_resource_stack_p,g_function1);
    
    if(s_previous_gadget_p) error_number=NO_ERROR;
        
    }
            
return(error_number);

}

/* ----------------------------------------------------------------------- */

void RemoveGadgets2(void)

{
        
FreeGadgets(s_gadgetlist_p);        
        
}

/* ----------------------------------------------------------------- */


UBYTE CreateGadgets2(void)

{

UBYTE i,error_number=ALLOCATION_ERROR;

newgadget.ng_TextAttr=g_public_screen_p->Font;

newgadget.ng_VisualInfo=g_visual_info_p;
                          
newgadget.ng_Width=g_w2_gadget1_width;     
             
newgadget.ng_Height=g_w2_gadget1_height;     

newgadget.ng_LeftEdge=g_w2_gadget1_x;  

newgadget.ng_TopEdge=g_w2_gadget1_y; 

                     
for (i=0;i<g_database_header.dh_FieldCount;i++)

  {
    
  newgadget.ng_GadgetText=&g_w3_gadget_labels[i][0];

  newgadget.ng_UserData=(APTR)DoNothing;

  s_previous_gadget_p=CreateGadget(STRING_KIND,s_previous_gadget_p,
                                 &newgadget,
                                 GTST_MaxChars,g_database_header.dh_FieldSize-1,

                                 TAG_END);
  
  newgadget.ng_TopEdge+=g_field_height+FIELD_GAP;  
    

  }


newgadget.ng_LeftEdge=g_w2_gadget2_x;  

newgadget.ng_TopEdge=g_w2_gadget2_y;

newgadget.ng_Width=g_w2_gadget2_width;     
             
newgadget.ng_Height=g_w2_gadget2_height;     


for (i=0;i<2;i++)

  {
                            
  newgadget.ng_GadgetText=gadget_labels2[i];

  newgadget.ng_UserData=(APTR)gadget_function[i];

  newgadget.ng_GadgetID=i;
  
  s_previous_gadget_p=CreateGadget(BUTTON_KIND,s_previous_gadget_p,
                                            &newgadget,
                                            TAG_END);

  newgadget.ng_LeftEdge+=g_w2_gadget2_width+g_offset;     
 
  }

      
if(s_previous_gadget_p) error_number=NO_ERROR;  
                
return(error_number);
                                
}

/* ----------------------------------------------------------------------- */

UBYTE CreateWindow2(void)

{

UBYTE error_number=ALLOCATION_ERROR;

s_window_p=OpenWindowTags(NULL,
        WA_Gadgets,s_gadgetlist_p,
        WA_Left,g_w2_x, WA_Top,g_w2_y,
        WA_Width,g_w2_width, WA_Height, g_w2_height,
        WA_DragBar, TRUE,
        WA_DepthGadget, TRUE,
        WA_CloseGadget, TRUE,
        WA_SmartRefresh, TRUE,
        WA_IDCMP, IDCMP_CLOSEWINDOW|IDCMP_MENUPICK|IDCMP_REFRESHWINDOW|
        IDCMP_GADGETUP|IDCMP_CHANGEWINDOW,
        WA_Title, W2_TITLE,
        WA_PubScreen, g_public_screen_p,
        WA_SizeGadget,TRUE,
        WA_MinWidth,W2_MINIMUM_WIDTH,
        WA_MinHeight,W2_MINIMUM_HEIGHT,
        WA_MaxWidth,g_public_screen_p->Width,
        WA_MaxHeight,g_public_screen_p->Height,
        TAG_END);
        
if (s_window_p)
        
        {
        
        SetRast(s_window_p->RPort,2);

        DrawWindowMask(s_window_p,s_gadgetlist_p,3,1,g_database_header.dh_FieldCount);
       
        RefreshWindowFrame(s_window_p);

        GT_RefreshWindow(s_window_p,NULL);
        
        error_number=NO_ERROR;
                               
        g_function1=KillWindow2;
        
        PushStack(s_resource_stack_p,g_function1);
               
        }
      
return(error_number);

}

/* ----------------------------------------------------------------- */

void KillWindow2(void)

{

CloseWindow(s_window_p);
 
}

/* ----------------------------------------------------------------- */

UBYTE CreateMenu2(void)

{

UBYTE error_number=NO_ERROR;

if(!(s_menu_p=CreateMenus(menu2,TAG_END)))

        error_number=ALLOCATION_ERROR;

  else {
        
        g_function1=ReleaseMenu2;
        
        PushStack(s_resource_stack_p,g_function1);
       
       }
        
return(error_number);


}

/* ----------------------------------------------------------------- */

void ReleaseMenu2(void)

{
        
FreeMenus(s_menu_p);
        
}

/* ----------------------------------------------------------------- */

UBYTE CreateMenuLayout2(void)

{

UBYTE error_number=NO_ERROR;

if(!(LayoutMenus(s_menu_p,g_visual_info_p,TAG_END)))

        error_number=ALLOCATION_ERROR;

  else {
        
        
       /* Function must be tested for success but
          no deallocation operations are needed! */
       
       }
        
return(error_number);


}

/* ----------------------------------------------------------------- */

UBYTE InstallMenu2(void)

{

UBYTE error_number=NO_ERROR;

if(!(SetMenuStrip(s_window_p,s_menu_p)))

        error_number=ALLOCATION_ERROR;

  else {
        
        g_function1=RemoveMenu2;
        
        PushStack(s_resource_stack_p,g_function1);
       
       }
        
return(error_number);

}

/* ----------------------------------------------------------------- */

void RemoveMenu2(void)

{

ClearMenuStrip(s_window_p);
        
}

/* ----------------------------------------------------------------- */


/* eventhandler2.c - event handling code for window 2 follows */


/* ----------------------------------------------------------------- */

UBYTE EventHandler2(void)

{

UBYTE error_number=NO_ERROR;

struct Message *message_p;

while (message_p=(struct Message *)GT_GetIMsg(s_window_p->UserPort))

  {
            
   error_number=IntuitionEvent2((struct IntuiMessage *)message_p);

  }


if(error_number==CLOSE_WINDOW)

   {
    
    CloseWindow2(); error_number=NO_ERROR;
    
   }
   
return(error_number);

}

/* ----------------------------------------------------------------- */


UBYTE IntuitionEvent2(struct IntuiMessage *message_p)

{

UBYTE error_number=NO_ERROR;

UWORD code; 

ULONG class;

void *address;

class=message_p->Class; 
            
code= message_p->Code;

address=message_p->IAddress;

GT_ReplyIMsg(message_p);

switch (class) {

                case IDCMP_CLOSEWINDOW: 
                
                     g_creating_flag=FALSE; /* in case user never hit gadget */

                     error_number=CLOSE_WINDOW; 
                     
                     break;
               
                
                case IDCMP_MENUPICK: 
                             
                error_number=MenuEvent2(code); break;
                             

                case IDCMP_GADGETUP: 

                     g_function3=((struct Gadget *)address)->UserData;

                     error_number=g_function3(((struct Gadget *)address)->GadgetID);

                     break;


                case IDCMP_REFRESHWINDOW:
                    
                     g_w2_width=s_window_p->Width;
                   
                     g_w2_height=s_window_p->Height;                     

                     /* Only occuring during record creation (as sizing
                        gadget is used). The g_creating_flag takes care
                        of the calculations but the following error_number
                        makes sure we get back to main event loop */

                
                     CalculateNewRecordLayout();
                
                     CalculateGadgetPositions(&g_database_header);
                 
                     error_number=REFRESH;
                     
                     break;


               case IDCMP_CHANGEWINDOW:
                     
                     g_w2_x=s_window_p->LeftEdge;

                     g_w2_y=s_window_p->TopEdge;
                                                                        
                     break;

                                         
                case IDCMP_MOUSEMOVE: break;

                                                                 
                default: DisplayBeep(NULL); break;

              }
              
return(error_number);

}

/* ----------------------------------------------------------------- */

UBYTE MenuEvent2(UWORD code)

{
 
UBYTE error_number=NO_ERROR;

UWORD menu_number, item_number;

if (code!=MENUNULL)

  {
                    
  menu_number=MENUNUM(code);
                            
  item_number=ITEMNUM(code);
       
  switch(menu_number) 

   {
    
    case 0:  error_number=ProjectMenuHandler2(item_number); 

             break;
             
   
    default: break;

   } 

  }

return(error_number);

}

/* ----------------------------------------------------------------- */

UBYTE ProjectMenuHandler2(UWORD item_number)

{

UBYTE error_number=NO_ERROR;
        
switch (item_number)

        {

        case 0:  g_creating_flag=FALSE; /* in case user never hit gadget */

                 error_number=CLOSE_WINDOW;         
                 
                 break;
        
        
        default: break;

        }

return(error_number);

}

/* ----------------------------------------------------------------- */

UBYTE StoreData(void)

{

UBYTE i, error_number=NO_ERROR;

struct Gadget *gadget_p;

RemoveListViewList();

gadget_p=s_gadgetlist_p->NextGadget; /* skip first Gadtools gadget */

for (i=0;i<g_database_header.dh_FieldCount;i++)

 {

  strcpy(&g_new_node.ln_Field[i][0],
         &((struct StringInfo *)gadget_p->SpecialInfo)->Buffer[0]);

  gadget_p=gadget_p->NextGadget; 

 }

error_number=AddToList();

         
if(g_handler_sigbit[3]) DisplayReadOnly(g_current_node_p);    
   
  if(!error_number)

   { /* If creating we must only allow ONE RECORD to be entered.
        checking has to be done here because this routine is entered
        immediately the gadget is hit */
    
    if (g_creating_flag) 
    
       {
     
        for (i=0;i<g_database_header.dh_FieldCount;i++)

            {
         
            strncpy(&g_w3_gadget_labels[i][0],&g_new_node.ln_Field[i][0],LABEL_SIZE);      
 
            g_new_node.ln_Field[i][0]=NULL;
        
            }
             
        error_number=CLOSE_WINDOW; /* force window to close */
         
        g_creating_flag=FALSE; /* clear flag since creation is complete */

       }
              
   }

AddListViewList();
   
return(error_number); 
    
}
  
/* ----------------------------------------------------------------- */

UBYTE ClearStringGadgets(void)

{

UBYTE i, error_number=NO_ERROR;

struct Gadget *gadget_p;

if(s_window_p)

 {

  gadget_p=s_gadgetlist_p->NextGadget; /* skip first Gadtools gadget */
    
  for (i=0;i<g_database_header.dh_FieldCount;i++)

    {    
    
    GT_SetGadgetAttrs(gadget_p,s_window_p,NULL,
                                       GTST_String,NULL,
                                       TAG_END);  

    gadget_p=gadget_p->NextGadget; 

    }

} 

return(error_number);
    
}

/* ----------------------------------------------------------------- */

void DisplayInEditor(void)

{

UBYTE i;

struct Gadget *gadget_p;

if(s_window_p)

 {
 
 gadget_p=s_gadgetlist_p->NextGadget; /* skip first Gadtools gadget */

 for (i=0;i<g_database_header.dh_FieldCount;i++)

   {    
    

   GT_SetGadgetAttrs(gadget_p,s_window_p,NULL,
                     GTST_String,&g_new_node.ln_Field[i][0],
                     TAG_END);  

   gadget_p=gadget_p->NextGadget; 

   }

 }

}

/* ----------------------------------------------------------------- */