#include <CrashTickPrefs.h>

struct Hook ChangeHelpHook = { {NULL}, HelpHookEntry,NULL,(APTR)HELP_CHANGE};

#define CHANGENODE_AKA      0
#define CHANGENODE_DIR      1
#define CHANGENODE_GROUP    2
#define CHANGENODE_ADDNODE  3
#define CHANGENODE_REMNODE  4

struct ChangeNode
{
   struct Node Node;
   uchar nodedesc[100];

   uword Type;
   uword num;

   struct Aka *Aka_Aka;

   uchar Dir_Dir[80];

   uchar Group_Group;

   struct ConfigNode *AddNode_CNode;
   uword AddNode_Flags;

   struct ConfigNode *RemNode_CNode;
};

struct List Change_DoList;

struct ChangeNode *Change_CurrentNode;

uchar *Change_Nodeflags[4];
uchar *Change_Pagenames[6];

uchar Change_Akabuf[40];
uchar Change_Groupbuf[40];
uchar Change_Addnodebuf[40];
uchar Change_Remnodebuf[40];

extern APTR mempool;

struct LayoutHandle *changehandle;
struct Window *changewin;

uchar Change_SelectGroups[50];
uchar Change_SelectGroupsbuf[50];
uchar Change_SelectPattern[100]="#?";

void MakeDirectory(UBYTE *dest,ULONG destsize,UBYTE *defdir,UBYTE *areaname);

void Change_ChangedNum(void)
{
   if(!Change_DoList.lh_Head->ln_Succ)
   {
      LT_SetAttributes(changehandle,511,GA_Disabled,TRUE,TAG_END);

      LT_SetAttributes(changehandle,100,GA_Disabled,TRUE,TAG_END);

      LT_SetAttributes(changehandle,1000,GA_Disabled,TRUE,TAG_END);
      LT_SetAttributes(changehandle,1100,GA_Disabled,TRUE,TAG_END);
      LT_SetAttributes(changehandle,1200,GA_Disabled,TRUE,TAG_END);
      LT_SetAttributes(changehandle,1300,GA_Disabled,TRUE,TAG_END);
      LT_SetAttributes(changehandle,1301,GA_Disabled,TRUE,TAG_END);
      LT_SetAttributes(changehandle,1400,GA_Disabled,TRUE,TAG_END);
   }
   else
   {
      LT_SetAttributes(changehandle,511,GA_Disabled,FALSE,TAG_END);

      LT_SetAttributes(changehandle,100,GA_Disabled,FALSE,TAG_END);

      LT_SetAttributes(changehandle,1000,GA_Disabled,FALSE,TAG_END);
      LT_SetAttributes(changehandle,1100,GA_Disabled,FALSE,TAG_END);
      LT_SetAttributes(changehandle,1200,GA_Disabled,FALSE,TAG_END);
      LT_SetAttributes(changehandle,1300,GA_Disabled,FALSE,TAG_END);
      LT_SetAttributes(changehandle,1301,GA_Disabled,FALSE,TAG_END);
      LT_SetAttributes(changehandle,1400,GA_Disabled,FALSE,TAG_END);
   }
}

void Change_SetCurrent(ulong num)
{
   ulong c;

   if(!Change_DoList.lh_Head->ln_Succ)
   {
      Change_CurrentNode=NULL;
      return;
   }

   Change_CurrentNode=(struct ChangeNode *)Change_DoList.lh_Head;

   for(c=0;c<num;c++)
      Change_CurrentNode=(struct ChangeNode *)Change_CurrentNode->Node.ln_Succ;

   LT_SetAttributes(changehandle,501,
      GTLV_Selected,    num,
      GTLV_MakeVisible, num,
      TAG_DONE);

   LT_SetAttributes(changehandle,99,LAGR_ActivePage,Change_CurrentNode->Type,TAG_END);
   LT_SetAttributes(changehandle,100,GTCY_Active,Change_CurrentNode->Type,TAG_END);

   switch(Change_CurrentNode->Type)
   {
      case CHANGENODE_AKA:
         if(Change_CurrentNode->Aka_Aka)
            PrintFull4D(&Change_CurrentNode->Aka_Aka->Node,Change_Akabuf);

         else
            strcpy(Change_Akabuf,getString(PREFS_NO_AKA));

         LT_SetAttributes(changehandle,1000,GTTX_Text,Change_Akabuf,TAG_END);
         break;

      case CHANGENODE_DIR:
         LT_SetAttributes(changehandle,1100,GTST_String,Change_CurrentNode->Dir_Dir,TAG_END);
         break;

      case CHANGENODE_GROUP:
         if(Change_CurrentNode->Group_Group == 0)
            strcpy(Change_Groupbuf,getString(PREFS_NO_GROUP));

         else
            sprintf(Change_Groupbuf,"%lc: %s",
               Change_CurrentNode->Group_Group,config.cfg_GroupNames[Change_CurrentNode->Group_Group-'A']);

         LT_SetAttributes(changehandle,1200,GTTX_Text,Change_Groupbuf,TAG_END);
         break;

      case CHANGENODE_ADDNODE:
         if(Change_CurrentNode->AddNode_CNode)
            PrintFull4D(&Change_CurrentNode->AddNode_CNode->Node,Change_Addnodebuf);

         else
            strcpy(Change_Addnodebuf,getString(PREFS_NO_NODE));

         LT_SetAttributes(changehandle,1300,GTTX_Text,Change_Addnodebuf,TAG_END);

         if(Change_CurrentNode->AddNode_Flags & TICKNODE_READONLY)
            LT_SetAttributes(parthandle,1301,GTCY_Active,1,TAG_END);

         else if(Change_CurrentNode->AddNode_Flags & TICKNODE_WRITEONLY)
            LT_SetAttributes(parthandle,1301,GTCY_Active,2,TAG_END);

         else
            LT_SetAttributes(parthandle,1301,GTCY_Active,0,TAG_END);

         break;

      case CHANGENODE_REMNODE:
         if(Change_CurrentNode->RemNode_CNode)
            PrintFull4D(&Change_CurrentNode->RemNode_CNode->Node,Change_Remnodebuf);

         else
            strcpy(Change_Remnodebuf,getString(PREFS_NO_NODE));

         LT_SetAttributes(changehandle,1400,GTTX_Text,Change_Remnodebuf,TAG_END);
         break;

   }
}

void Change_SetSelectGroups(void)
{
   if(Change_SelectGroups[0]==0)
      strcpy(Change_SelectGroupsbuf,getString(PREFS_ANY_GROUP));

   else
      strcpy(Change_SelectGroupsbuf,Change_SelectGroups);

   LT_SetAttributes(changehandle,11,GTTX_Text,Change_SelectGroupsbuf,TAG_END);
}

void Change_MakeDesc(struct ChangeNode *chnode)
{
   uchar buf[50],buf2[50];

   switch(chnode->Type)
   {
      case CHANGENODE_AKA:
         if(chnode->Aka_Aka)
            PrintFull4D(&chnode->Aka_Aka->Node,buf);

         else
            strcpy(buf,getString(PREFS_NO_AKA));

         sprintf(chnode->nodedesc,"%s: %s",getString(PREFS_CHANGE_AKA),buf);
         break;

      case CHANGENODE_DIR:
         sprintf(chnode->nodedesc,"%s: %s",getString(PREFS_CHANGE_DIR),chnode->Dir_Dir);
         break;

      case CHANGENODE_GROUP:
         if(chnode->Group_Group == 0)
            strcpy(buf,getString(PREFS_NO_GROUP));

         else
            sprintf(buf,"%lc: %s",
               chnode->Group_Group,config.cfg_GroupNames[chnode->Group_Group-'A']);

         sprintf(chnode->nodedesc,"%s: %s",getString(PREFS_CHANGE_GROUP),buf);
         break;

      case CHANGENODE_ADDNODE:
         if(chnode->AddNode_CNode)
            PrintFull4D(&chnode->AddNode_CNode->Node,buf);

         else
            strcpy(buf,getString(PREFS_NO_NODE));

         if(chnode->AddNode_Flags & TICKNODE_READONLY)
            strcpy(buf2,getString(PREFS_NODEACCESS_NOHATCH));

         else if(chnode->AddNode_Flags & TICKNODE_WRITEONLY)
            strcpy(buf2,getString(PREFS_NODEACCESS_HATCHONLY));

         else
            strcpy(buf2,getString(PREFS_NODEACCESS_FULL));

         sprintf(chnode->nodedesc,"%s: %s, %s",getString(PREFS_CHANGE_ADDNODE),buf,buf2);
         break;

      case CHANGENODE_REMNODE:
         if(chnode->RemNode_CNode)
            PrintFull4D(&chnode->RemNode_CNode->Node,buf);

         else
            strcpy(buf,getString(PREFS_NO_NODE));

         sprintf(chnode->nodedesc,"%s: %s",getString(PREFS_CHANGE_REMNODE),buf);
         break;
   }
}

void Change_UpdateDesc(struct ChangeNode *chnode)
{
   LT_SetAttributes(changehandle,501,GTLV_Labels,~0,TAG_END);
   Change_MakeDesc(chnode);
   LT_SetAttributes(changehandle,501,GTLV_Labels,&Change_DoList,TAG_END);
}

void Change_RenumberNodes(void)
{
   ULONG num;
   struct ChangeNode *chnode;

   num=0;

   for(chnode=(struct ChangeNode *)Change_DoList.lh_Head;chnode->Node.ln_Succ;chnode=(struct ChangeNode *)chnode->Node.ln_Succ)
      chnode->num=num++;
}

void Change_Add(void)
{
   struct ChangeNode *chnode;

   if(!(chnode=AllocCleared(sizeof(struct ChangeNode))))
   {
      DisplayBeep(NULL);
      return;
   }

   LT_SetAttributes(changehandle,501,GTLV_Labels,~0,TAG_END);

   chnode->Node.ln_Name=chnode->nodedesc;
   Change_MakeDesc(chnode);
   AddTail(&Change_DoList,(struct Node *)chnode);
   Change_RenumberNodes();

   LT_SetAttributes(changehandle,501,GTLV_Labels,&Change_DoList,TAG_END);

   chnode=(struct ChangeNode *)Change_DoList.lh_TailPred;

   Change_ChangedNum();
   Change_SetCurrent(chnode->num);
}

void Change_Remove(void)
{
   ULONG tmp;

   tmp=Change_CurrentNode->num;

   if(!Change_CurrentNode->Node.ln_Succ->ln_Succ)
      tmp--;

   LT_SetAttributes(changehandle,501,GTLV_Labels,~0,TAG_END);
   Remove((struct Node *)Change_CurrentNode);
   LibFreePooled(mempool,Change_CurrentNode,sizeof(struct ChangeNode));
   LT_SetAttributes(changehandle,501,GTLV_Labels,&Change_DoList,TAG_END);

   Change_RenumberNodes();
   Change_ChangedNum();
   Change_SetCurrent(tmp);
}

void DoChange(void)
{
   struct Area *area;
   struct TickNode *tnode;
   UBYTE parsedpattern[400];
   BOOL changed;
   ULONG changedareas,unalteredareas;
   UBYTE buf[300];
   UBYTE newpath[80];
   struct ChangeNode *chnode;

   changedareas=0;
   unalteredareas=0;

   if(ParsePatternNoCase(Change_SelectPattern,parsedpattern,400)==-1)
   {
      rtEZRequestTags(getString(PREFS_CHANGE_INVALID_PATTERN),getString(PREFS_TXT_OK),NULL,NULL,
            RT_Underscore,'_',
            RT_Window,changewin,
            RT_WaitPointer,TRUE,
            RT_LockWindow, TRUE,
             TAG_END);

      return;
   }

   for(area=(struct Area *)config.AreaList.First;area;area=area->Next)
      if(MatchPatternNoCase(parsedpattern,area->Name) && (Change_SelectGroups[0] == 0 || CheckFlags(area->Group,Change_SelectGroups)))
      {
         changed=FALSE;

         for(chnode=(struct ChangeNode *)Change_DoList.lh_Head;chnode->Node.ln_Succ;chnode=(struct ChangeNode *)chnode->Node.ln_Succ)
         {
            switch(chnode->Type)
            {
               case CHANGENODE_AKA:
                  if(chnode->Aka_Aka && chnode->Aka_Aka != area->Aka)
                  {
                     area->Aka=chnode->Aka_Aka;
                     changed=TRUE;
                  }
                  break;
                  
               case CHANGENODE_DIR:
                  MakeDirectory(newpath,80,chnode->Dir_Dir,area->Name);

                  if(strcmp(newpath,area->Directory) != 0)
                  {
                     strcpy(area->Directory,newpath);
                     changed=TRUE;
                  }
                  break;

               case CHANGENODE_GROUP:
                  if(chnode->Group_Group != area->Group)
                  {
                     area->Group=chnode->Group_Group;
                     changed=TRUE;
                  }

               case CHANGENODE_ADDNODE:
                  if(chnode->AddNode_CNode)
                  {
                     for(tnode=(struct TickNode *)area->TickNodes.First;tnode;tnode=tnode->Next)
                        if(tnode->ConfigNode == chnode->AddNode_CNode) break;

                     if(!tnode)
                     {
                        if(tnode=AllocCleared(sizeof(struct TickNode)))
                        {
                           tnode->ConfigNode=chnode->AddNode_CNode;
                           tnode->Flags|=chnode->AddNode_Flags;
                           jbAddNode(&area->TickNodes,(struct jbNode *)tnode);
                           changed=TRUE;
                        }
                     }
                  }
                  break;

               case CHANGENODE_REMNODE:
                  if(chnode->RemNode_CNode)
                  {
                     for(tnode=(struct TickNode *)area->TickNodes.First;tnode;tnode=tnode->Next)
                        if(tnode->ConfigNode == chnode->RemNode_CNode) break;

                     if(tnode)
                     {
                        jbFreeNode(&area->TickNodes,(struct jbNode *)tnode,sizeof(struct TickNode));
                        changed=TRUE;
                     }
                  }
                  break;
            }
         }

         if(changed) changedareas++;
         else        unalteredareas++;
      }

   sprintf(buf,getString(PREFS_CHANGE_RESULT),changedareas,unalteredareas);

   rtEZRequestTags(buf,getString(PREFS_TXT_OK),NULL,NULL,RT_Underscore,'_',
                                      RT_Window,changewin,
                                      RT_WaitPointer,TRUE,
                                      RT_LockWindow, TRUE,
                                      RTEZ_Flags, EZREQF_CENTERTEXT,
                                      TAG_END);

   if(changedareas)
      config.configchanged=TRUE;
}

void ChangeAreas(void)
{
   struct IntuiMessage *IntuiMessage;
   APTR iaddress;
   ULONG class,code,qualifier;
   struct Aka *aka;
   uchar group;
   struct Change *chnode;
   struct ConfigNode *cnode;

   Change_Nodeflags[0]=getString(PREFS_NODEACCESS_FULL);
   Change_Nodeflags[1]=getString(PREFS_NODEACCESS_NOHATCH);
   Change_Nodeflags[2]=getString(PREFS_NODEACCESS_HATCHONLY);
   Change_Nodeflags[3]=NULL;

   Change_Pagenames[0]=getString(PREFS_CHANGE_AKA);
   Change_Pagenames[1]=getString(PREFS_CHANGE_DIR);
   Change_Pagenames[2]=getString(PREFS_CHANGE_GROUP);
   Change_Pagenames[3]=getString(PREFS_CHANGE_ADDNODE);
   Change_Pagenames[4]=getString(PREFS_CHANGE_REMNODE);
   Change_Pagenames[5]=NULL;

   NewList(&Change_DoList);

   changehandle = LT_CreateHandleTags(scr,LH_EditHook,     &StrEditHook,
                                        LH_RawKeyFilter, FALSE,
                                        LH_LocaleHook,   &LocaleHook,
                                        TAG_DONE);

   if(!changehandle)
      return;

   LT_New(changehandle,
      LA_Type, VERTICAL_KIND,
      TAG_DONE);

      LT_New(changehandle,
         LA_Type, HORIZONTAL_KIND,
         LA_LabelID, PREFS_CHANGE_SELECTFRAME,
         LAGR_Spread,TRUE,
         TAG_DONE);

         LT_New(changehandle,
            LA_Type, VERTICAL_KIND,
            TAG_DONE);

            LT_New(changehandle,
               LA_LabelID,       PREFS_CHANGE_SELPATTERN,
               LA_Chars,         40,
               LA_Type,          STRING_KIND,
               GTST_MaxChars,    99,
               LA_ID,            10,
               LA_STRPTR,        Change_SelectPattern,
               TAG_DONE);

            LT_New(changehandle,
               LA_LabelID,       PREFS_CHANGE_SELGROUPS,
               LA_Chars,         40,
               LA_Type,          TEXT_KIND,
               LATX_Picker,      TRUE,
               GTTX_Border,      TRUE,
               LA_ID,            11,
               TAG_DONE);

         LT_EndGroup(changehandle);

         LT_New(changehandle,
            LA_Type, HORIZONTAL_KIND,
            TAG_DONE);

            LT_New(changehandle,
               LA_Type,      YBAR_KIND,
               TAG_DONE);

         LT_EndGroup(changehandle);

         LT_New(changehandle,
            LA_Type, HORIZONTAL_KIND,
            TAG_DONE);

            LT_New(changehandle,
               LA_Type,      BUTTON_KIND,
               LA_LabelID,   PREFS_CHANGE_DOCHANGE,
               LA_ID,        15,
               TAG_DONE);

         LT_EndGroup(changehandle);

      LT_EndGroup(changehandle);

      LT_New(changehandle,
         LA_Type,      VERTICAL_KIND,
         LA_LabelID,   PREFS_CHANGE_CHANGEFRAME,
         TAG_DONE);

         LT_New(changehandle,
            LA_Type,      VERTICAL_KIND,
            TAG_DONE);

            LT_New(changehandle,
               LA_Type,       LISTVIEW_KIND,
               LALV_Lines,    5,
               LALV_CursorKey,TRUE,
               LA_ID,         501,
               LA_Chars,      60,
               LALV_Link,     NIL_LINK,
               LALV_LockSize, TRUE,
               TAG_DONE);

            LT_New(changehandle,
               LA_Type,      HORIZONTAL_KIND,
               LAGR_SameSize,TRUE,
               LAGR_Spread,  TRUE,
               TAG_DONE);

               LT_New(changehandle,
                  LA_Type,      BUTTON_KIND,
                  LA_LabelID,   PREFS_CHANGE_ADD,
                  LA_Chars,     30,
                  LA_ID,        510,
                  TAG_DONE);

               LT_New(changehandle,
                  LA_Type,      BUTTON_KIND,
                  LA_LabelID,   PREFS_CHANGE_REM,
                  LA_Chars,     30,
                  LA_ID,        511,
                  TAG_DONE);

            LT_EndGroup(changehandle);

         LT_EndGroup(changehandle);

         LT_New(changehandle,
            LA_Type,      XBAR_KIND,
            TAG_DONE);

         LT_New(changehandle,
            LA_Type,      VERTICAL_KIND,
            TAG_DONE);

            LT_New(changehandle,
               LA_Type,          CYCLE_KIND,
               LA_ID,            100,
               GTCY_Labels,      Change_Pagenames,
               TAG_DONE);

            LT_New(changehandle,
                LA_Type,      VERTICAL_KIND,
                LA_ID,        99,
                LAGR_ActivePage,0,
                TAG_DONE);

               LT_New(changehandle,
                  LA_Type,      VERTICAL_KIND,
                  TAG_DONE);

                  LT_New(changehandle,
                     LA_Type,      VERTICAL_KIND,
/*                     LA_LabelID,   PREFS_CHANGE_AKA, */
                     TAG_DONE);

                     LT_New(changehandle,
                        LA_LabelID,       PREFS_CHANGE_AKA,
                        LA_Chars,         20,
                        LA_Type,          TEXT_KIND,
                        LATX_Picker,      TRUE,
                        GTTX_Border,      TRUE,
                        LA_ID,            1000,
                        TAG_DONE);

                  LT_EndGroup(changehandle);
      
               LT_EndGroup(changehandle);

               LT_New(changehandle,
                  LA_Type,      VERTICAL_KIND,
                  TAG_DONE);

                  LT_New(changehandle,
                     LA_Type,      VERTICAL_KIND,
/*                     LA_LabelID,   PREFS_CHANGE_DIR,*/
                     TAG_DONE);

                     LT_New(changehandle,
                        LA_LabelID,       PREFS_CHANGE_DIR,
                        LA_Chars,         50,
                        LA_Type,          STRING_KIND,
                        GTST_MaxChars,    79,
                        LAST_Picker,      TRUE,
                        LA_ID,            1100,
                        TAG_DONE);

                  LT_EndGroup(changehandle);

               LT_EndGroup(changehandle);

               LT_New(changehandle,
                  LA_Type,      VERTICAL_KIND,
                  TAG_DONE);

                  LT_New(changehandle,
                     LA_Type,      VERTICAL_KIND,
/*                     LA_LabelID,   PREFS_CHANGE_GROUP, */
                     TAG_DONE);

                     LT_New(changehandle,
                        LA_LabelID,       PREFS_CHANGE_GROUP,
                        LA_Chars,         20,
                        LA_Type,          TEXT_KIND,
                        LATX_Picker,      TRUE,
                        GTTX_Border,      TRUE,
                        LA_ID,            1200,
                        TAG_DONE);

                  LT_EndGroup(changehandle);

               LT_EndGroup(changehandle);

               LT_New(changehandle,
                  LA_Type,      VERTICAL_KIND,
                  TAG_DONE);

                  LT_New(changehandle,
                     LA_Type,      HORIZONTAL_KIND,
/*                     LA_LabelID,   PREFS_CHANGE_ADDNODE, */
                     TAG_DONE);

                     LT_New(changehandle,
                        LA_LabelID,       PREFS_CHANGE_ADDNODE,
                        LA_Chars,         20,
                        LA_Type,          TEXT_KIND,
                        LATX_Picker,      TRUE,
                        GTTX_Border,      TRUE,
                        LA_ID,            1300,
                        TAG_DONE);

                     LT_New(changehandle,
                        LA_Type,          CYCLE_KIND,
                        GTCY_Labels,      Change_Nodeflags,
                        LA_ID,            1301,
                        TAG_DONE);

                  LT_EndGroup(changehandle);

               LT_EndGroup(changehandle);

               LT_New(changehandle,
                  LA_Type,      VERTICAL_KIND,
                  TAG_DONE);

                  LT_New(changehandle,
                     LA_Type,      VERTICAL_KIND,
/*                     LA_LabelID,   PREFS_CHANGE_REMNODE, */
                     TAG_DONE);

                     LT_New(changehandle,
                        LA_LabelID,       PREFS_CHANGE_REMNODE,
                        LA_Chars,         20,
                        LA_Type,          TEXT_KIND,
                        LATX_Picker,      TRUE,
                        GTTX_Border,      TRUE,
                        LA_ID,            1400,
                        TAG_DONE);

                  LT_EndGroup(changehandle);

               LT_EndGroup(changehandle);

            LT_EndGroup(changehandle);

         LT_EndGroup(changehandle);

      LT_EndGroup(changehandle);

   LT_EndGroup(changehandle);

   changewin=LT_Build(changehandle,LAWN_IDCMP,    IDCMP_CLOSEWINDOW|IDCMP_RAWKEY,
                               LAWN_Parent,   mainwin,
                               LAWN_HelpHook, &ChangeHelpHook,
                               LAWN_Title,    getString(PREFS_CHANGE_TITLE),
                               WA_Flags,      WFLG_ACTIVATE|WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_NEWLOOKMENUS,
                               TAG_END);

   if(!changewin)
   {
      LT_DeleteHandle(changehandle);
      DisplayBeep(NULL);
      return;
   }

   Change_SetCurrent(0);
   Change_ChangedNum();

   Change_SetSelectGroups();

   for(;;)
   {
      while(IntuiMessage=(struct IntuiMessage *)LT_GetIMsg(changehandle))
      {
         class=IntuiMessage->Class;
         code=IntuiMessage->Code;
         iaddress=IntuiMessage->IAddress;
         qualifier=IntuiMessage->Qualifier;

         LT_ReplyIMsg(IntuiMessage);

         switch(class)
         {
            case IDCMP_IDCMPUPDATE:    if(((struct Gadget *)iaddress)->GadgetID == 11)
                                       {
                                          if(EditGroups(Change_SelectGroups,getString(PREFS_EDIT_GROUPS),partwin))
                                             Change_SetSelectGroups();
                                       }
                                       
                                       if(Change_CurrentNode)
                                       {
                                          switch(((struct Gadget *)iaddress)->GadgetID)
                                          {
                                             case 1000:
                                                if(aka=AskAka(changewin))
                                                {
                                                   Change_CurrentNode->Aka_Aka=aka;
                                                   Change_UpdateDesc(Change_CurrentNode);
                                                   Change_SetCurrent(Change_CurrentNode->num);
                                                }
                                                break;

                                             case 1100:
                                               OpenReqDir(Change_CurrentNode->Dir_Dir,79,getString(PREFS_REQ_SELECT_DIR),changewin);
                                               Change_UpdateDesc(Change_CurrentNode);
                                               Change_SetCurrent(Change_CurrentNode->num);
                                               break;

                                             case 1200:
                                               group=AskGroup(changewin,getString(PREFS_NO_GROUP));

                                               if(group != -1)
                                               {
                                                   Change_CurrentNode->Group_Group=group;
                                                   Change_UpdateDesc(Change_CurrentNode);
                                                   Change_SetCurrent(Change_CurrentNode->num);
                                               }
                                               break;

                                             case 1300:
                                               if(cnode=AskCNode(changewin))
                                               {
                                                   Change_CurrentNode->AddNode_CNode=cnode;
                                                   Change_UpdateDesc(Change_CurrentNode);
                                                   Change_SetCurrent(Change_CurrentNode->num);
                                               }
                                               break;

                                             case 1400:
                                               if(cnode=AskCNode(changewin))
                                               {
                                                   Change_CurrentNode->RemNode_CNode=cnode;
                                                   Change_UpdateDesc(Change_CurrentNode);
                                                   Change_SetCurrent(Change_CurrentNode->num);
                                               }
                                               break;
                                          }
                                       }
                                       break;

            case IDCMP_GADGETUP:       /* No current node necessary */

                                       switch(((struct Gadget *)iaddress)->GadgetID)
                                       {
                                          case 500+LV_ADD:
                                             Change_Add();
                                             break;

                                          case 15:
                                             LT_UpdateStrings(changehandle);
                                             DoChange();
                                             break;
                                       }

                                       /* Current node necessary */

                                       if(Change_CurrentNode)
                                       {
                                          switch(((struct Gadget *)iaddress)->GadgetID)
                                          {
                                             case 100:
                                                Change_CurrentNode->Type=code;
                                                Change_UpdateDesc(Change_CurrentNode);
                                                Change_SetCurrent(Change_CurrentNode->num);
                                                break;

                                             case 1100:
                                                mystrncpy(Change_CurrentNode->Dir_Dir,(uchar *)LT_GetAttributes(changehandle,1100,TAG_END),80);
                                                Change_UpdateDesc(Change_CurrentNode);
                                                Change_SetCurrent(Change_CurrentNode->num);
                                                break;

                                             case 1301:
                                                if(code == 0)
                                                   Change_CurrentNode->AddNode_Flags=0;

                                                if(code == 1)
                                                   Change_CurrentNode->AddNode_Flags = TICKNODE_READONLY;

                                                if(code == 2)
                                                   Change_CurrentNode->AddNode_Flags = TICKNODE_WRITEONLY;

                                                Change_UpdateDesc(Change_CurrentNode);
                                                Change_SetCurrent(Change_CurrentNode->num);
                                                break;

                                             case 500+LV_LIST:
                                                Change_SetCurrent(code);
                                                break;

                                             case 500+LV_REMOVE:
                                                Change_Remove();
                                                break;

                                          }
                                      }
                                      break;

            case IDCMP_CLOSEWINDOW:   LT_DeleteHandle(changehandle);
                                      changehandle=NULL;

                                      while(chnode=(struct Change *)RemTail(&Change_DoList))
                                       LibFreePooled(mempool,chnode,sizeof(struct ChangeNode));

                                      return;

         }
      }
      WaitPort(changewin->UserPort);
   }
}

/* asknode(), editgroups, kunna ändra */
