home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / fm2000 / launch.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-04  |  8.8 KB  |  373 lines
  1. /*
  2.      Filemaster - Multitasking directory utility.
  3.      Copyright (C) 2000  Toni Wilen
  4.      
  5.      This program is free software; you can redistribute it and/or
  6.      modify it under the terms of the GNU General Public License
  7.      as published by the Free Software Foundation; either version 2
  8.      of the License, or (at your option) any later version.
  9.      
  10.      This program is distributed in the hope that it will be useful,
  11.      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.      GNU General Public License for more details.
  14.      
  15.      You should have received a copy of the GNU General Public License
  16.      along with this program; if not, write to the Free Software
  17.      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20. #include <exec/types.h>
  21. #include <dos/dosextens.h>
  22. #include <dos/dostags.h>
  23. #include <exec/memory.h>
  24. #include <exec/execbase.h>
  25. /* #include <pragmas/exec_pragmas.h> */
  26. #include <clib/exec_protos.h>
  27. #include <proto/all.h>
  28. #include <proto/datatypes.h>
  29. #include <string.h>
  30. #include <intuition/intuition.h>
  31. #include <stdio.h>
  32. #include <proto/xfdmaster.h>
  33. #include "fmnode.h"
  34. #include "fmlocale.h"
  35. #include "child.h"
  36. #include "fmdos.h"
  37.  
  38. void executeownnum(void);
  39. WORD setalloc(struct FMList*,WORD);
  40. void stopoldmod(void);
  41. void textextent(struct RastPort*,UBYTE*,WORD*,WORD*);
  42.  
  43. extern struct FMMain fmmain;
  44. extern struct FMConfig *fmconfig;
  45. extern APTR launchtable[];
  46. extern struct FMList fmlist[];
  47.  
  48. WORD launch(void(*address)(void),struct CMenuConfig *cmc,WORD flag,WORD subproc)
  49. {
  50. struct ProcMsg *pmsg;
  51. struct Process *proc;
  52. struct IntuiMessage *imsg;
  53. WORD cnt;
  54. WORD ret=0;
  55.  
  56. if(!address) return(1);
  57.  
  58. for(cnt=0;cnt<LISTS;cnt++) fmlist[cnt].flags&=~LABORTREQ;
  59. pmsg=allocvec(0,sizeof(struct ProcMsg),MEMF_CLEAR|MEMF_PUBLIC);
  60. if(!pmsg) return(0);
  61. pmsg->cmc=cmc;
  62.  
  63. SetSignal(0,SIGBREAKF_CTRL_F);
  64. fmmain.pmsg=pmsg;
  65. if(subproc&MSUBPROC) {
  66.     //flag?"FM Timer":"<<<FileMaster Unknown>>>"
  67.     if (!(proc=CreateNewProcTags(NP_Entry,address,NP_StackSize,10000,NP_Priority,fmconfig->mainpriority,NP_Name,"FM",TAG_DONE))) goto fail;
  68.     Signal((struct Task*)proc,SIGBREAKF_CTRL_F);
  69.     while(fmmain.pmsg) Wait(SIGBREAKF_CTRL_F);
  70.     ret=1;
  71. } else {
  72.     Signal((struct Task*)fmmain.myproc,SIGBREAKF_CTRL_F);
  73.     address();
  74.     ret=1;
  75. }
  76. SetSignal(0,SIGBREAKF_CTRL_F);
  77. fail:
  78. if(fmmain.ikkuna) {
  79.     while(imsg=(struct IntuiMessage*)GetMsg(fmmain.ikkuna->UserPort)) ReplyMsg((struct Message*)imsg);
  80. }
  81. return(ret);
  82. }
  83.  
  84. void runcommand(struct GadKeyTab *gkt)
  85. {
  86. WORD apu1;
  87. struct Gadget *g;
  88. struct CMenuConfig *cmc;
  89.  
  90. ReportMouse(0,fmmain.ikkuna);
  91. for(apu1=0;apu1<LISTS;apu1++) fmlist[apu1].lastclicked=0;
  92. g=gkt->g;
  93. if(g) {
  94.     fmmain.sourcedir->fmmessage1[0]=0;
  95.     fmmain.sourcedir->fmmessage2[0]=0;
  96.     cmc=gkt->cmc;
  97.  
  98.     if(cmc&&cmc->cmenucount) {
  99.         if(cmc->cmenucount<100) {
  100.             if(cmc->cmenucount<=CONFIGCONFIG||(cmc->cmenucount>=DRIVESCONFIG&&cmc->cmenucount<=CLEARCONFIG)||cmc->cmenucount==FILEEDITCONFIG||cmc->cmenucount==DISKEDITCONFIG) {
  101.                 launch(launchtable[cmc->cmenucount],cmc,0,0);
  102.             } else {
  103.                 launch(launchtable[cmc->cmenucount],cmc,0,MSUBPROC);
  104.             }
  105.         } else {
  106.             launch(executeownnum,cmc,0,MSUBPROC);
  107.         }
  108.     }
  109. }
  110. }
  111.  
  112. void deinitproc(struct ProcMsg *pm)
  113. {
  114. if(xfdMasterBase) CloseLibrary((struct Library*)xfdMasterBase);
  115. #ifdef V39
  116. CloseLibrary(CxBase);
  117. CloseLibrary(DataTypesBase);
  118. #endif
  119. CloseLibrary((struct Library*)DOSBase);
  120. CloseLibrary((struct Library*)GfxBase);
  121. CloseLibrary((struct Library*)IntuitionBase);
  122. CloseLibrary(UtilityBase);
  123. CloseLibrary(GadToolsBase);
  124. CloseLibrary(KeymapBase);
  125. CloseLibrary(WorkbenchBase);
  126. CloseLibrary(LocaleBase);
  127. CloseLibrary(IconBase);
  128. CloseLibrary(BGUIBase);
  129. freemem(pm);
  130. }
  131.  
  132. extern UBYTE gfxlib[];
  133. extern UBYTE intlib[];
  134. extern UBYTE comlib[];
  135. extern UBYTE utilib[];
  136. extern UBYTE gadlib[];
  137. extern UBYTE keylib[];
  138. extern UBYTE wblib[];
  139. extern UBYTE loclib[];
  140. extern UBYTE bguilib[];
  141. extern UBYTE xfdlib[];
  142. extern UBYTE datlib[];
  143. extern UBYTE icolib[];
  144.  
  145. struct ProcMsg * __saveds sinitproc(void)
  146. {
  147. struct ProcMsg *msg;
  148.  
  149. Wait(SIGBREAKF_CTRL_F);
  150. msg=fmmain.pmsg;
  151. fmmain.pmsg=0;
  152. Signal((struct Task*)fmmain.myproc,SIGBREAKF_CTRL_F);
  153. OpenLibrary("dos.library",0);
  154. OpenLibrary(gfxlib,0);
  155. OpenLibrary(intlib,0);
  156. OpenLibrary(utilib,0);
  157. OpenLibrary(gadlib,0);
  158. OpenLibrary(keylib,0);
  159. OpenLibrary(wblib,0);
  160. OpenLibrary(loclib,0);
  161. OpenLibrary(icolib,0);
  162. OpenLibrary(bguilib,0);
  163. OpenLibrary(xfdlib,0);
  164. #ifdef V39
  165. OpenLibrary(comlib,0);
  166. OpenLibrary(datlib,0);
  167. #endif
  168. return(msg);
  169. }
  170.  
  171. void priority(struct CMenuConfig *cmc)
  172. {
  173. if(cmc) SetTaskPri(FindTask(0),fmconfig->pri[cmc->priority]);
  174. }
  175.  
  176. void initproc(struct FMList *list,UBYTE *txt)
  177. {
  178. struct FMList *plist;
  179. struct Process *proc;
  180. UBYTE *txt2;
  181.  
  182. if((LONG)txt!=1) txt2=txt; else txt2=0;
  183.  
  184. if (txt&&list) {
  185.     list->flags|=LACTIVE;
  186.     list->oldcur=1;
  187.     if (fmconfig->flags&MSUBPROC) list->flags|=LSUBPROC;
  188.     plist=list->pair;
  189.     if (plist) {
  190.         plist->flags|=LACTIVE;
  191.         plist->oldcur=1;
  192.         strcpy(plist->workname,txt2);
  193.         plist->fmmessage1[0]=0;
  194.         plist->fmmessage2[0]=0;
  195.     }
  196.     list->fmmessage1[0]=0;
  197.     list->fmmessage2[0]=0;
  198.     fmmessage(list);
  199. }
  200. changename(list,txt2);
  201. proc=(struct Process*)FindTask(0);
  202. if(fmmain.ikkuna) proc->pr_WindowPtr=fmmain.ikkuna;
  203. }
  204.  
  205. void changename(struct FMList *list,UBYTE *name)
  206. {
  207. //struct Task *task;
  208.  
  209. if(!list||!name) return;
  210. /*
  211. task=FindTask(0);
  212. if(name&&fmconfig->flags&MSUBPROC) {
  213.     Disable();
  214.     strcpy(task->tc_Node.ln_Name,"FM ");
  215.     strcpy(task->tc_Node.ln_Name+3,name);
  216.     Enable();
  217. }
  218. */
  219. if(list) strcpy(list->workname,name);
  220. }
  221.  
  222. void endproc(struct FMList *list)
  223. {
  224. BPTR prevlock;
  225. struct IntuiMessage *imsg;
  226.  
  227. if (!(list->flags&LACTIVE)) return;
  228. Forbid();
  229. setalloc(list,0);
  230. if (list->pair) {
  231.     setalloc(list->pair,0); list->pair->flags&=~(LACTIVE|LSUBPROC|LUPDATEMSG);
  232.     list->pair->workname[0]=0; list->pair->pair=0;
  233. }
  234. if (list->flags&LSUBPROC && list->oldcur!=1) {
  235.     prevlock=CurrentDir(list->oldcur);
  236.     if (prevlock) UnLock(prevlock);
  237. }
  238. list->workname[0]=0;
  239. list->pair=0;
  240. list->flags&=~(LACTIVE|LSUBPROC|LUPDATEMSG);
  241. if(fmmain.ikkuna) {
  242.     while(imsg=(struct IntuiMessage*)GetMsg(fmmain.ikkuna->UserPort)) ReplyMsg((struct Message*)imsg);
  243. }
  244. Permit();
  245. }
  246.  
  247. WORD tstsubproc(WORD mode)
  248. {
  249. extern struct FMList fmlist[];
  250. WORD cnt;
  251.  
  252. retry:
  253. Forbid();
  254. for(cnt=0;cnt<10;cnt++) {
  255.     if ((fmlist[cnt].flags&LACTIVE)||fmmain.wincnt) {
  256.         Permit();
  257.         if (requestmsg(getstring(MSG_MAIN_WARNING),MSG_RETRY,MSG_CANCEL,MSG_MAIN_PROCESSES)) goto retry;
  258.         return(1);
  259.     }
  260. }
  261. Permit();
  262. return(0);
  263. }
  264.  
  265. // 0=free,1=alloc
  266.  
  267. #define GNUM 4
  268.  
  269. WORD setalloc(struct FMList *list,WORD aa)
  270. {
  271. extern struct FMMain fmmain;
  272. extern struct Gadget *slider1ptr;
  273. extern struct Gadget *slider2ptr;
  274.  
  275. if (aa==1 && list->flags&LALLOCATED) return(0);
  276. if (aa==1) {
  277.     list->flags|=LALLOCATED;
  278.     if(list->li) offgadget(&list->li->slider1,3);
  279.     return(1);
  280. }
  281. if (!aa) {
  282.     list->flags&=~LALLOCATED;
  283.     if(list->li) ongadget(&list->li->slider1,3);
  284. }
  285. return(1);
  286. }
  287.  
  288. void offgadget(struct Gadget *gadg,WORD cnt)
  289. {
  290. WORD pos,cntv=0;
  291. struct Gadget *gadgv;
  292.  
  293. gadgv=gadg;
  294. while(cnt--&&gadg) {
  295.     pos=RemoveGadget(fmmain.ikkuna,gadg);
  296.     gadg->Flags|=GADGDISABLED;
  297.     AddGadget(fmmain.ikkuna,gadg,pos);
  298.     gadg=gadg->NextGadget;
  299.     cntv++;
  300. }
  301. if(cntv) RefreshGList(gadgv,fmmain.ikkuna,0,cntv);
  302. }
  303.  
  304. void ongadget(struct Gadget *gadg,WORD cnt)
  305. {
  306. WORD pos,cntv=0;
  307. struct Gadget *gadgv;
  308. UBYTE txt[2];
  309. WORD apu1,apu2;
  310.  
  311. gadgv=gadg;
  312. while(cnt--&&gadg) {
  313.     pos=RemoveGadget(fmmain.ikkuna,gadg);
  314.     gadg->Flags&=~GADGDISABLED;
  315.     if(gadg->GadgetType==BOOLGADGET) {
  316.         ObtainSemaphore(&fmmain.gfxsema);
  317.         SetAPen(fmmain.rp,fmconfig->backpen);
  318.         RectFill(fmmain.rp,gadg->LeftEdge,gadg->TopEdge,gadg->LeftEdge+gadg->Width,gadg->TopEdge+gadg->Height);
  319.         SetAPen(fmmain.rp,fmconfig->txtpen);
  320.         SetSoftStyle(fmmain.rp,1,1);
  321.         txt[0]=(UBYTE)gadg->UserData; txt[1]=0;
  322.         textextent(fmmain.rp,txt,&apu1,&apu2);
  323.         Move(fmmain.rp,(gadg->Width-apu1+1)/2+gadg->LeftEdge,gadg->TopEdge+fmmain.txtbaseline+2);
  324.         Text(fmmain.rp,txt,1);
  325.         SetSoftStyle(fmmain.rp,0,1);
  326.         ReleaseSemaphore(&fmmain.gfxsema);
  327.     }
  328.     AddGadget(fmmain.ikkuna,gadg,pos);
  329.     cntv++;
  330.     gadg=gadg->NextGadget;
  331. }
  332. if(cntv) RefreshGList(gadgv,fmmain.ikkuna,0,cntv);
  333. }
  334.  
  335. WORD testabort(struct FMList *list)
  336. {
  337. struct IntuiMessage *message;
  338.  
  339. extern struct FMList fmlist[];
  340.  
  341. if (!(fmconfig->flags&MSUBPROC)) {
  342.     while(message=(struct IntuiMessage*)GetMsg(fmmain.ikkuna->UserPort)) {
  343.         if (message->Class==MOUSEBUTTONS && message->Code==MENUDOWN && list->flags&LACTIVE) list->flags|=LABORTREQ;
  344.         ReplyMsg((struct Message*)message);
  345.     }
  346. }
  347. if (list->flags&LACTIVE && list->flags&LABORTREQ) return(1);
  348. return(0);
  349. }
  350.  
  351. WORD askabort(struct FMList *list)
  352. {
  353. WORD ret;
  354. UWORD oldflag;
  355.  
  356. oldflag=list->flags;
  357. list->flags&=~(LABORTREQ|LUPDATEMSG);
  358. ret=request(getstring(MSG_MAIN_ABORT),MSG_YES,MSG_NO,"%s (%lU)",list->workname,list->listnumber);
  359. if(ret) {
  360.     strcpymsg(list->fmmessage1,MSG_MAIN_ABORTED);
  361.     list->fmmessage2[0]=0;
  362.     fmmessage(list);
  363. } else {
  364.     if(oldflag&LUPDATEMSG) list->flags|=LUPDATEMSG;
  365. }
  366. return(ret);
  367. }
  368.  
  369. void askmodabort(void)
  370. {
  371. if(fmmain.modflag&&requestmsg(getstring(MSG_MAIN_AREYOUSURE),MSG_YES,MSG_NO,MSG_MAIN_ABORTMODPLAY)) stopoldmod();
  372. }
  373.