home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / utility / misc / toolmana.lha / ToolManager / Source / prefs / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-26  |  12.7 KB  |  523 lines
  1. /*
  2.  * main.c  V2.0
  3.  *
  4.  * configuration program main entry point
  5.  *
  6.  * (c) 1990-1992 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerConf.h"
  10.  
  11. static const char Version[]="\0$VER: ToolManager " TMVERSION "." TMREVISION
  12.                             " (" TMCONFDATE ")\r\n";
  13. static const char PrefsPortName[]="ToolManager_Prefs";
  14.  
  15. /* Misc. data */
  16. extern struct GfxBase *GfxBase;
  17. struct Library *IFFParseBase=NULL;
  18. struct Library *IconBase=NULL;
  19. static struct MsgPort *PrefsPort=NULL;
  20. static char *FromFileName;
  21. static char *PubScreenName;
  22. static char Template[]="FROM,EDIT/S,USE/S,SAVE/S,PUBSCREEN/K,DEFAULTFONT/S";
  23. static struct {
  24.                char *from;
  25.                long  edit;
  26.                long  use;
  27.                long  save;
  28.                char *pubsc;
  29.                long  deffont;
  30.               } cmdlineparams={PrefsFileName,TRUE,FALSE,FALSE,NULL,FALSE};
  31. static BOOL DefaultFont;
  32. static char WBName[]="Workbench";
  33. static char YesString[]="Y|Yes";
  34.  
  35. /* Open resources */
  36. static BOOL OpenResources(void)
  37. {
  38.  if (!(IFFParseBase=OpenLibrary("iffparse.library",37))) return(FALSE);
  39.  if (!(IconBase=OpenLibrary("icon.library",37))) return(FALSE);
  40.  if (!(PrefsPort=CreateMsgPort())) return(FALSE);
  41.  PrefsPort->mp_Node.ln_Pri=-127;
  42.  PrefsPort->mp_Node.ln_Name=PrefsPortName;
  43.  AddPort(PrefsPort);
  44.  
  45.  /* Try to open workbench.library */
  46.  WorkbenchBase=OpenLibrary("workbench.library",37);
  47.  
  48.  if (!(AppMsgPort=CreateMsgPort())) return(FALSE);
  49.  GetLocale();
  50.  
  51.  /* All OK */
  52.  return(TRUE);
  53. }
  54.  
  55. /* Close Resources */
  56. static void CloseResources(void)
  57. {
  58.  FreeLocale();
  59.  if (AppMsgPort) {
  60.   struct Message *msg;
  61.   while (msg=GetMsg(AppMsgPort)) ReplyMsg(msg);
  62.   DeleteMsgPort(AppMsgPort);
  63.  }
  64.  if (WorkbenchBase) CloseLibrary(WorkbenchBase);
  65.  if (PrefsPort) {
  66.   RemPort(PrefsPort);
  67.   DeleteMsgPort(PrefsPort);
  68.  }
  69.  if (IconBase) CloseLibrary(IconBase);
  70.  if (IFFParseBase) CloseLibrary(IFFParseBase);
  71. }
  72.  
  73. /* Free all preferences objects */
  74. void FreeAllObjects(void)
  75. {
  76.  int i;
  77.  
  78.  for (i=0; i<TMOBJTYPES; i++) {
  79.   struct List *list=&ObjectLists[i];
  80.   FreeNodeFunction *freefunc=FreeNodeFunctions[i];
  81.   struct Node *node;
  82.  
  83.   /* Scan list and free nodes */
  84.   while (node=RemHead(list)) (*freefunc)(node);
  85.  }
  86. }
  87.  
  88. /* Copy a file */
  89. BOOL CopyFile(char *source, char *dest)
  90. {
  91.  char *copybuf;
  92.  BOOL rc=FALSE;
  93.  
  94.  /* Allocate copy buffer */
  95.  if (copybuf=malloc(2048)) {
  96.   BPTR infh;
  97.  
  98.   /* Open source file */
  99.   if (infh=Open(source,MODE_OLDFILE)) {
  100.    BPTR outfh;
  101.  
  102.    /* Open destination file */
  103.    if (outfh=Open(dest,MODE_NEWFILE)) {
  104.     LONG n;
  105.  
  106.     /* Copy file */
  107.     while ((n=Read(infh,copybuf,2048))>0) Write(outfh,copybuf,n);
  108.  
  109.     /* No error? */
  110.     if (n==0) rc=TRUE;
  111.  
  112.     Close(outfh);
  113.    }
  114.    Close(infh);
  115.   }
  116.   free(copybuf);
  117.  }
  118.  return(rc);
  119. }
  120.  
  121. /* Main program */
  122. static int mainprogram(struct WBArg *wa)
  123. {
  124.  /* Another ToolManager Preferences program already running? */
  125.  Forbid();
  126.  if (PrefsPort=FindPort(PrefsPortName)) {
  127.   /* Yes, signal other task... */
  128.   Signal(PrefsPort->mp_SigTask,1L << PrefsPort->mp_SigBit);
  129.   Permit();
  130.  
  131.   /* ...and exit! */
  132.   return(0);
  133.  }
  134.  Permit();
  135.  
  136.  /* Open resources */
  137.  if (OpenResources()) {
  138.   /* Set defaults */
  139.   FromFileName=PrefsFileName;
  140.   PubScreenName=NULL;
  141.   ProgramName=NULL;
  142.   DefaultFont=FALSE;
  143.  
  144.   /* WB or CLI startup? */
  145.   if (wa) {
  146.    /* WB Startup */
  147.    struct DiskObject *dobj;
  148.  
  149.    /* Get icon */
  150.    if (dobj=GetDiskObjectNew(wa->wa_Name)) {
  151.     char *s,**tt=dobj->do_ToolTypes;
  152.  
  153.     /* USE? */
  154.     if (FindToolType(tt,"USE")) {
  155.      /* Copy From file to preferences file */
  156.      CopyFile(wa->wa_Name,PrefsFileName);
  157.  
  158.      /* ...and exit */
  159.      CloseResources();
  160.      return(0);
  161.     }
  162.  
  163.     /* SAVE? */
  164.     if (FindToolType(tt,"SAVE")) {
  165.      /* Copy From file to preferences file */
  166.      CopyFile(wa->wa_Name,SavePrefsFileName);
  167.  
  168.      /* ...and exit */
  169.      CloseResources();
  170.      return(0);
  171.     }
  172.  
  173.     /* PUBSCREEN */
  174.     if (s=FindToolType(tt,"PUBSCREEN")) PubScreenName=strdup(s);
  175.  
  176.     /* DEFAULTFONT */
  177.     if (s=FindToolType(tt,"DEFAULTFONT"))
  178.      DefaultFont=MatchToolValue(YesString,s);
  179.  
  180.     /* CREATEICONS */
  181.     if (s=FindToolType(tt,"CREATEICONS"))
  182.      CreateIcons=MatchToolValue(YesString,s);
  183.  
  184.     /* Get program & prefs file name. Icon type? */
  185.     switch (dobj->do_Type) {
  186.      case WBTOOL:    if (ProgramName=malloc(256)) {
  187.                       *ProgramName='\0';
  188.                       if (NameFromLock(wa->wa_Lock,ProgramName,256))
  189.                        AddPart(ProgramName,wa->wa_Name,256);
  190.                      }
  191.                      break;
  192.      case WBPROJECT: ProgramName=strdup(dobj->do_DefaultTool);
  193.                      if (!(FromFileName=strdup(wa->wa_Name)))
  194.                       FromFileName=PrefsFileName;
  195.                      break;
  196.     }
  197.  
  198.    }
  199.   } else {
  200.    /* CLI Startup */
  201.    struct RDArgs *rda;
  202.  
  203.    /* Parse command line */
  204.    rda=ReadArgs(Template,(LONG *) &cmdlineparams,NULL);
  205.  
  206.    /* Get values */
  207.    if (cmdlineparams.from) FromFileName=strdup(cmdlineparams.from);
  208.    if (!FromFileName) FromFileName=PrefsFileName;
  209.    if (cmdlineparams.pubsc) PubScreenName=strdup(cmdlineparams.pubsc);
  210.    if (cmdlineparams.deffont) DefaultFont=TRUE;
  211.  
  212.    /* Free ReadArgs parameters */
  213.    if (rda) FreeArgs(rda);
  214.  
  215.    /* USE? */
  216.    if (cmdlineparams.use) {
  217.     /* Copy From file to preferences file */
  218.     CopyFile(FromFileName,PrefsFileName);
  219.  
  220.     /* ...and exit */
  221.     CloseResources();
  222.     return(0);
  223.    }
  224.  
  225.    /* SAVE? */
  226.    if (cmdlineparams.save) {
  227.     /* Copy From file to save preferences file */
  228.     CopyFile(FromFileName,SavePrefsFileName);
  229.  
  230.     /* ...and exit */
  231.     CloseResources();
  232.     return(0);
  233.    }
  234.  
  235.    /* Get program name */
  236.    if (ProgramName=malloc(256)) {
  237.     *ProgramName='\0';
  238.     GetProgramName(ProgramName,256);
  239.    }
  240.   }
  241.  
  242.   /* Init object lists */
  243.   {
  244.    int i;
  245.  
  246.    for (i=0; i<TMOBJTYPES; i++) NewList(&ObjectLists[i]);
  247.   }
  248.  
  249.   /* Read public screen list */
  250.   NewList(&PubScreenList);
  251.   {
  252.    struct List *pubsclist;
  253.  
  254.    if (pubsclist=LockPubScreenList()) {
  255.     struct PubScreenNode *pubscnode=GetHead(pubsclist);
  256.  
  257.     /* Scan list */
  258.     while (pubscnode) {
  259.      struct Node *mynode;
  260.  
  261.      /* Copy entry */
  262.      if (mynode=malloc(sizeof(struct Node)))
  263.       if (mynode->ln_Name=strdup(pubscnode->psn_Node.ln_Name))
  264.        /* Node allocated, add it to list */
  265.        AddTail(&PubScreenList,mynode);
  266.       else
  267.        /* no memory, free node */
  268.        free(mynode);
  269.  
  270.      /* get a pointer to next node */
  271.      pubscnode=GetSucc(pubscnode);
  272.     }
  273.  
  274.     /* Release public screen list */
  275.     UnlockPubScreenList();
  276.    }
  277.   }
  278.  
  279.   /* Try to get the Workbench window offsets */
  280.   if (PublicScreen=LockPubScreen(WBName)) {
  281.    struct Window *w=PublicScreen->FirstWindow;
  282.  
  283.    /* Scan Workbench screen window list */
  284.    while (w) {
  285.     struct MsgPort *mp=w->UserPort;
  286.  
  287.     /* Workbench window? (Lots of safety checks) */
  288.     if ((w->Flags & WFLG_WBENCHWINDOW) && mp &&
  289.         ((mp->mp_Flags & PF_ACTION) == PA_SIGNAL)) {
  290.      struct Task *t=mp->mp_SigTask;
  291.  
  292.      /* More safety checks */
  293.      if (t && t->tc_Node.ln_Name && !strcmp(t->tc_Node.ln_Name,WBName))
  294.       /* Window title valid? */
  295.       if (w->Title) {
  296.        /* Window has title, compare it to string "Workbench" */
  297.        if (!strcmp(w->Title,WBName)) break;
  298.       } else
  299.        /* Window has no title, check for Workbench backdrop window */
  300.        if ((w->Flags & (WFLG_BACKDROP|WFLG_BORDERLESS)) ==
  301.             (WFLG_BACKDROP|WFLG_BORDERLESS))
  302.         break;
  303.     }
  304.  
  305.     /* next window */
  306.     w=w->NextWindow;
  307.    }
  308.  
  309.    /* Window found? */
  310.    if (w)
  311.     /* Yes. Read offsets. Backdrop window? */
  312.     if (w->Flags & WFLG_BACKDROP) {
  313.      /* Yes. Just read window coordinates */
  314.      WBXOffset=w->LeftEdge;
  315.      WBYOffset=w->TopEdge;
  316.     } else {
  317.      /* No */
  318.      WBXOffset=w->LeftEdge+w->BorderLeft;
  319.      WBYOffset=w->TopEdge+w->BorderTop;
  320.     }
  321.  
  322.    UnlockPubScreen(NULL,PublicScreen);
  323.   }
  324.  
  325.   /* Read Configuration */
  326.   if (ReadConfigFile(FromFileName)) {
  327.    /* Lock default public screen */
  328.    if (PublicScreen=LockPubScreen(PubScreenName)) {
  329.     WBScreen=(PublicScreen->Flags & SCREENTYPE) == WBENCHSCREEN;
  330.  
  331.     /* Get visual info */
  332.     if (ScreenVI=GetVisualInfo(PublicScreen,TAG_DONE)) {
  333.      /* Which font should be used? */
  334.      if (DefaultFont) {
  335.       struct TextFont *tf=GfxBase->DefaultFont;
  336.  
  337.       /* Read system default font values */
  338.       ScreenTextAttr.ta_Name=tf->tf_Message.mn_Node.ln_Name;
  339.       ScreenTextAttr.ta_YSize=tf->tf_YSize;
  340.       ScreenTextAttr.ta_Style=tf->tf_Style;
  341.       ScreenTextAttr.ta_Flags=tf->tf_Flags;
  342.      }
  343.      else
  344.       /* Copy public screen TextAttr */
  345.       ScreenTextAttr=*(PublicScreen->Font);
  346.  
  347.      /* Limit font size. Fonts must be higher than 7 pixels! */
  348.      if (ScreenTextAttr.ta_YSize<8) ScreenTextAttr.ta_YSize=8;
  349.  
  350.      /* Open screen font */
  351.      if (ScreenFont=OpenDiskFont(&ScreenTextAttr)) {
  352.  
  353.       /* Calculate requester button image */
  354.       if (CalcReqButtonImage()) {
  355.        ULONG IDCMPSignalMask;
  356.  
  357.        /* Init global TmpRastPort */
  358.        InitRastPort(&TmpRastPort);
  359.        SetFont(&TmpRastPort,ScreenFont);
  360.  
  361.        /* Init windows */
  362.        {
  363.         UWORD left=PublicScreen->WBorLeft+INTERWIDTH/2;
  364.         UWORD fheight=ScreenFont->tf_YSize+INTERHEIGHT;
  365.  
  366.         WindowTop=PublicScreen->WBorTop+ScreenFont->tf_YSize+1;
  367.  
  368.         InitMainWindow(left,fheight);
  369.         InitExecEditWindow(left,fheight);
  370.         InitImageEditWindow(left,fheight);
  371.         InitSoundEditWindow(left,fheight);
  372.         InitMenuEditWindow(left,fheight);
  373.         InitIconEditWindow(left,fheight);
  374.         InitDockEditWindow(left,fheight);
  375.         InitMoveWindow(left,fheight);
  376.         InitDockListEditWindow(left,fheight);
  377.         InitListRequester(left,fheight);
  378.        }
  379.  
  380.        /* Init global NewGadget structure */
  381.        NewGadget.ng_TextAttr=&ScreenTextAttr;
  382.        NewGadget.ng_VisualInfo=ScreenVI;
  383.        NewGadget.ng_UserData=NULL;
  384.  
  385.        /* Open main window */
  386.        if (IDCMPSignalMask=OpenMainWindow()) {
  387.         ULONG PrefsPortSignalMask,AppMsgPortSignalMask,SignalMask;
  388.         BPTR oldcd;
  389.         BOOL notend=TRUE;
  390.  
  391.         /* Init signal masks */
  392.         PrefsPortSignalMask=1L << PrefsPort->mp_SigBit;
  393.         AppMsgPortSignalMask=1L << AppMsgPort->mp_SigBit;
  394.         SignalMask=IDCMPSignalMask | PrefsPortSignalMask |
  395.                     AppMsgPortSignalMask;
  396.  
  397.         /* Go to boot directory */
  398.         oldcd=CurrentDir(NULL);
  399.  
  400.         /* Main event loop */
  401.         while (notend) {
  402.          ULONG GotSigs;
  403.  
  404. /*         DEBUG_PRINTF("CONF: Waiting for messages...\n"); */
  405.  
  406.          /* Wait for messages */
  407.          GotSigs=Wait(SignalMask);
  408.  
  409.          /* IDCMP Event? */
  410.          if (GotSigs & IDCMPSignalMask) {
  411.           struct IntuiMessage *msg;
  412.  
  413.           /* Scan IDCMP port */
  414.           while (msg=GT_GetIMsg(IDCMPPort)) {
  415.            void *data;
  416.            HandleIDCMPFunction *func=msg->IDCMPWindow->UserData;
  417.  
  418.            /* Handle IDCMP Message. Window closed? */
  419.            if (data=(*func)(msg))
  420.             /* Yes. Main window closed? */
  421.             if (UpdateWindow)
  422.              /* No, call update function */
  423.              (*UpdateWindow)(data);
  424.             else
  425.              /* Yes, quit program */
  426.              notend=FALSE;
  427.            else
  428.             /* No, reply message */
  429.             GT_ReplyIMsg(msg);
  430.           }
  431.          }
  432.  
  433.          /* Prefs port signal? */
  434.          if (GotSigs & PrefsPortSignalMask)
  435.           /* Yes. Move current window to front */
  436.           WindowToFront(CurrentWindow);
  437.  
  438.          /* Application message arrived? */
  439.          if (GotSigs & AppMsgPortSignalMask) {
  440.           struct AppMessage *msg;
  441.  
  442.           /* Scan AppMsg port */
  443.           while (msg=GetMsg(AppMsgPort)) {
  444.            /* Application message handling function valid? */
  445.            if (HandleAppMsg)
  446.             /* Yes, handle message */
  447.             (*HandleAppMsg)(msg);
  448.  
  449.            /* Reply message */
  450.            ReplyMsg((struct Message *) msg);
  451.           }
  452.          }
  453.         }
  454.  
  455.         /* Go back to old directory */
  456.         CurrentDir(oldcd);
  457.  
  458.         /* Close Main Window */
  459.         CloseMainWindow();
  460.  
  461.         /* End of program. Clear public screen pointer */
  462.         PublicScreen=NULL;
  463.        }
  464.        FreeReqButtonImage();
  465.       }
  466.       CloseFont(ScreenFont);
  467.      }
  468.      FreeVisualInfo(ScreenVI);
  469.     }
  470.     if (PublicScreen) UnlockPubScreen(NULL,PublicScreen);
  471.    }
  472.   }
  473.  
  474.   /* Free public screen list */
  475.   {
  476.    struct Node *n1,*n2=GetHead(&PubScreenList);
  477.  
  478.    while (n1=n2) {
  479.     /* Get next node */
  480.     n2=GetSucc(n1);
  481.  
  482.     /* Free node */
  483.     free(n1->ln_Name);
  484.     free(n1);
  485.    }
  486.   }
  487.  
  488.   /* Free all object nodes */
  489.   FreeAllObjects();
  490.  }
  491.  
  492.  /* Closing down... */
  493.  CloseResources();
  494.  return(0);
  495. }
  496.  
  497. /* CLI entry point */
  498. int main(int argc, char *argv[])
  499. {
  500.  return(mainprogram(NULL));
  501. }
  502.  
  503. /* WB entry point */
  504. int wbmain(struct WBStartup *wbs)
  505. {
  506.  struct WBArg *wa;
  507.  BPTR dirlock;
  508.  int rc;
  509.  
  510.  /* Get last WBArg */
  511.  wa=&wbs->sm_ArgList[wbs->sm_NumArgs-1];
  512.  
  513.  /* Go to icon directory */
  514.  dirlock=CurrentDir(wa->wa_Lock);
  515.  
  516.  /* Do it :-) */
  517.  rc=mainprogram(wa);
  518.  
  519.  /* Go back... */
  520.  CurrentDir(dirlock);
  521.  return(rc);
  522. }
  523.