home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Utilities / ModePro / Src / Daemon / Unnamed1 / 4.1 / MPPatch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-12  |  21.8 KB  |  955 lines
  1. #include "MP.h"
  2. #include <graphics/videocontrol.h>
  3.  
  4. #define AllocOpenNode(on)  (on ? on: AllocMem(sizeof(struct OpenNode),MEMF_CLEAR|MEMF_PUBLIC))
  5.   
  6. void CatchDNode(ULONG list,UBYTE *Name);
  7. //void PrintTags(struct TagItem *tags);
  8. //UBYTE *FindTagSting(ULONG ID);
  9. void CloneTextAttr(struct TTextAttr *Source, struct TTextAttr *Dest);
  10.  
  11. extern struct MPSem *MPSem;
  12. extern CxObj  *Broker;
  13. extern struct MsgPort *BrokerPort;
  14. extern STRPTR MiscText[];
  15. extern BOOL V39;
  16. extern BYTE PublicSignal;
  17. extern struct Process  *MPTask;
  18. extern UWORD NumDriPens;
  19. // extern defaultpens[];
  20. extern struct MsgPort *CatchPort;
  21. extern struct Screen ASM *(*OldOpenScreen)(REG __a0 struct NewScreen *,REG __a6 struct IntuitionBase *);
  22. extern struct Screen ASM *(*OldOpenScreenTagList)(REG __a0 struct ExtNewScreen *ns,
  23.                                              REG __a1 struct TagItem *taglist,
  24.                                              REG __a6 struct IntuitionBase * );
  25. extern BOOL ASM (*OldCloseScreen)(REG __a0 struct Screen *,REG __a6 struct IntuitionBase *);
  26. extern struct Window ASM *(*OldOpenWindow)(REG __a0 struct NewWindow *nw,
  27.                                              REG __a6 struct IntuitionBase *lib);
  28. extern struct Window ASM *(*OldOpenWindowTagList)(REG __a0 struct NewWindow *nw,
  29.                                                     REG __a1 struct TagItem *tags,
  30.                                                     REG __a6 struct IntuitionBase *lib);
  31. extern BOOL ASM *(*OldLayoutMenusA)(REG __a0 struct Menu *fm,
  32.                                       REG __a1 APTR vi, 
  33.                                       REG __a2 struct TagItem *tags,
  34.                                       REG __a6 struct Library *lib);
  35. extern LONG ASM (*OldCloseWorkBench)(REG __a6 struct IntuitionBase *lib);
  36.  
  37. struct Screen ASM __saveds  *NewOpenScreen(REG __a0 struct ExtNewScreen *ns)
  38. {
  39.   return(NewOpenScreenTagList(ns,(ns->Type & NS_EXTENDED ?ns->Extension:0) ));
  40. }
  41.  
  42. struct DimensionInfo diminfo;
  43. struct DisplayInfo   dispinfo;
  44.  
  45. UBYTE *Topaz="topaz.font";
  46.  
  47. struct Screen *scr;
  48. struct TextFont *textfont;
  49. struct ScreenModeRequester *sr;
  50.  
  51. WORD   width,
  52.        height,
  53.        depth;
  54. BOOL   dodepth;
  55.  
  56. LONG   autoscroll,
  57.        look3d,
  58.        modeid,
  59.        overscan,
  60.        interleave,
  61.        wbscr;
  62.        //likewb;
  63. BOOL   changed,modechanged;
  64.        
  65. WORD   pens[]={~0},
  66.        *screenpens;
  67.        
  68. struct Task *task;
  69. struct DefaultNode *n;
  70. struct TagItem ti[21],
  71.               *tag;
  72. struct TagItem fonttags[]=
  73. {
  74.   TA_DeviceDPI,(1<<16) | 1,TAG_DONE,0
  75. };
  76.  
  77.  
  78. ULONG  TagNum,ehbham;
  79.  
  80. struct TextAttr *storedfont;
  81.  
  82. UBYTE  cliname[41],*taskname;
  83. UBYTE *title;
  84.        
  85. struct OpenNode *ON;
  86.  
  87. LONG custombm;
  88.    
  89.       
  90. struct Screen ASM __saveds  *NewOpenScreenTagList(REG __a0 struct ExtNewScreen *ns,
  91.                                                   REG __a1 struct TagItem *taglist)
  92. {
  93.   ObtainSemaphoreShared(&MPSem->ListSem); 
  94.   ObtainSemaphore(&MPSem->NodeSem); 
  95.   /* Now that we've got the semaphore all globals are mine */
  96.   /* initialize everything */
  97.  
  98.   TagNum=0;
  99.  
  100.   title=NULL;
  101.  
  102.   ON=NULL;   //likewb=0;
  103.   
  104.   custombm=changed=modechanged=depth=look3d=overscan=interleave=0L;
  105.   dodepth=FALSE;
  106.   
  107.   wbscr=0;  
  108.   
  109.   width=height=autoscroll=modeid=-1;
  110.  
  111.   screenpens=pens;
  112.   
  113.   task=FindTask(0);
  114.   taskname=task->tc_Node.ln_Name;
  115.  
  116.   if(GetProgramName(cliname,40)) /* Get cli program's name */
  117.     if(cliname[0]!=0)            /* make sure cliname contains something */
  118.       taskname=cliname;
  119.   
  120.   /* Initialization Done */
  121.  
  122.  
  123.  
  124.   /**** Extract screen info from ns and taglist ****/  
  125.   if(ns)                     
  126.   {
  127.     storedfont=ns->Font;
  128.     width    =ns->Width;
  129.     height   =ns->Height;
  130.     modeid   =ns->ViewModes;
  131.     depth    =ns->Depth;
  132.     title    =ns->DefaultTitle;
  133.     custombm =ns->Type & CUSTOMBITMAP;
  134.   }
  135.  
  136.   if(taglist)
  137.   {
  138.     //likewb=(ULONG)FindTagItem(SA_LikeWorkbench,taglist);
  139.     //printf("\n---------\n");
  140.     //PrintTags(taglist);
  141.     custombm  =GetTagData(SA_BitMap,    custombm,taglist);
  142.     width     =GetTagData(SA_Width,     width,   taglist);
  143.     height    =GetTagData(SA_Height,    height,  taglist);
  144.     autoscroll=GetTagData(SA_AutoScroll,autoscroll,taglist);
  145.     overscan  =GetTagData(SA_Overscan,  overscan,taglist);
  146.     modeid    =GetTagData(SA_DisplayID, modeid,  taglist);
  147.     depth     =GetTagData(SA_Depth,     depth,   taglist);
  148.     title     =(UBYTE *)GetTagData(SA_Title,(ULONG)title,taglist);
  149.     wbscr     =(GetTagData(SA_Type,0,taglist) & 15) == WBENCHSCREEN;
  150.     interleave=GetTagData(SA_Interleaved,interleave,taglist);
  151.     if(tag=FindTagItem(SA_Overscan,taglist))
  152.       if(!FindTagItem(SA_DClip,taglist))
  153.         overscan=tag->ti_Data;
  154.     if(tag=FindTagItem(SA_Pens,taglist))
  155.     {
  156.       screenpens=(UWORD *)(tag->ti_Data);
  157.       //look3d=TRUE;
  158.     }
  159.     //printf("TagList w=%4d h=%4d id=%8x d=%4d t=%s\n",width,height,modeid,depth,title);
  160.   }
  161.   n=NULL;
  162.  
  163. //  printf("\nOld Tags:\n");  
  164. //  PrintTags(taglist);
  165.  
  166.   
  167.   if(!title) title=GetString(MSG_ITEM_NO_NAME); /* Just in case ther isn't a title */
  168.  
  169.   if(!(n=FindDNode(&MPSem->PromotionList[1],title)))
  170.     if(!(n=FindDNode(&MPSem->PromotionList[0],taskname)))
  171.     { 
  172.       if(MPSem->CatchPrograms && taskname)   //Catch new names only.
  173.         CatchDNode(0,taskname);
  174.       if(MPSem->CatchScreens) CatchDNode(1,title);
  175.     }
  176.  
  177.   if(!MPSem->Enabled || !n/* || wbscr*/)
  178.   {
  179.     scr=OldOpenScreenTagList(ns,taglist,IntuitionBase);
  180.     ReleaseSemaphore(&MPSem->ListSem);
  181.     ReleaseSemaphore(&MPSem->NodeSem);
  182.     return(scr);
  183.   }
  184.   
  185.   ehbham=modeid & (HAM_KEY | EXTRAHALFBRITE_KEY); 
  186.   
  187.   look3d     =n->Look3D;
  188.   interleave =(n->Flags & INTERLEAVE) | interleave;
  189.   screenpens =n->Pens;
  190.  
  191.   if(!wbscr)
  192.   {
  193.     switch(n->ModeSelect)
  194.     {
  195.       case 1:
  196.         if(modeid > -1)
  197.         {
  198.           modeid      =(n->ModeID & MONITOR_ID_MASK) | (modeid & (~MONITOR_ID_MASK));
  199.           modechanged=TRUE;
  200.         }
  201.       case 0:          
  202.         autoscroll  =n->AutoScroll;
  203.         break;
  204.       case 2:
  205.         modeid      =n->ModeID | ehbham;
  206.         overscan    =n->OverscanType;
  207.         width       =n->Width;
  208.         height      =n->Height;
  209.         autoscroll  =n->AutoScroll;
  210.         if(n->Flags & DEPTH)
  211.         {
  212.           depth=n->Depth;
  213.           dodepth=TRUE;
  214.         }
  215.         changed=TRUE;
  216.         break;
  217.       case 3:
  218.         if((sr=(struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  219.                     ASLSM_TitleText             ,title,
  220.                     ASLSM_DoWidth               ,TRUE ,
  221.                     ASLSM_DoHeight              ,TRUE ,
  222.                     ASLSM_DoOverscanType        ,TRUE ,
  223.                     ASLSM_DoAutoScroll          ,TRUE ,
  224.                     ASLSM_DoDepth               ,n->Flags & DEPTH,
  225.                     ASLSM_InitialAutoScroll     ,n->AutoScroll,
  226.                     ASLSM_InitialDisplayWidth   ,n->Width,
  227.                     ASLSM_InitialDisplayHeight  ,n->Height,
  228.                     ASLSM_InitialDisplayID      ,n->ModeID,
  229.                     ASLSM_InitialDisplayDepth   ,n->Depth,
  230.                     ASLSM_NegativeText          ,GetString(MSG_REQ_USE_DEFAULT),
  231.                     ASLSM_PropertyFlags         ,0,
  232.                     ASLSM_PropertyMask          ,BADMODES,                      
  233.                     TAG_END 
  234.                     )))
  235.         {
  236.           if(AslRequest(sr,NULL))
  237.           {
  238.             modeid    =sr->sm_DisplayID | ehbham;
  239.             overscan  =sr->sm_OverscanType;
  240.             width     =sr->sm_DisplayWidth;
  241.             height    =sr->sm_DisplayHeight;    
  242.             changed=TRUE;
  243.             if(n->Flags & DEPTH)
  244.             {
  245.               depth=sr->sm_DisplayDepth;
  246.               dodepth=TRUE;
  247.             }
  248.           }
  249.           FreeAslRequest(sr);  
  250.         }
  251.         break; 
  252.     }/* end switch*/
  253.   
  254.     /**** Setup promoted taglist ****/
  255.   
  256.     if(changed && !(custombm))
  257.     {
  258.       ti[TagNum].ti_Tag=SA_Width;
  259.       ti[TagNum].ti_Data=width;
  260.       TagNum++;
  261.       ti[TagNum].ti_Tag=SA_Height;
  262.       ti[TagNum].ti_Data=height;
  263.       TagNum++;
  264.       ti[TagNum].ti_Tag=SA_Overscan;
  265.       ti[TagNum].ti_Data=overscan;
  266.       TagNum++;
  267.     }
  268.   
  269.     if(modechanged || changed)
  270.     {
  271.       ti[TagNum].ti_Tag=SA_DisplayID;
  272.       ti[TagNum].ti_Data=modeid;
  273.       TagNum++;
  274.     }
  275.  
  276.     if(n->Flags & SHAREPENS)
  277.     {
  278.       ti[TagNum].ti_Tag=SA_SharePens;
  279.       ti[TagNum].ti_Data=TRUE;
  280.       TagNum++;
  281.     }
  282.  
  283.     if(dodepth && !(custombm) && !(ehbham))
  284.     {
  285.       ti[TagNum].ti_Tag=SA_Depth;
  286.       ti[TagNum].ti_Data=depth;
  287.       TagNum++;
  288.     }
  289.  
  290.  
  291.     switch(n->FontType)
  292.     {
  293.       case SFONT_SYS:
  294.         if(ns) ns->Font=0;
  295.         ti[TagNum].ti_Tag=SA_SysFont;
  296.         ti[TagNum].ti_Data=1;
  297.         TagNum++;
  298.         break;
  299.       case SFONT_MP:
  300.         if(n->Font.tta_Name)
  301.         {
  302.           if(ON=AllocOpenNode(ON))
  303.           {
  304.             ON->Flags|=ON_FONT;
  305.           
  306.             ti[TagNum].ti_Tag  =SA_Font;
  307.             ti[TagNum].ti_Data =(ULONG)&ON->TA;
  308.             TagNum++;
  309.   
  310.             if(n->Flags & FIXASPECT && modeid != -1)
  311.             {
  312.               if(GetDisplayInfoData(NULL,(UBYTE *)&dispinfo,sizeof(struct DisplayInfo),DTAG_DISP,modeid))
  313.               {
  314.                 fonttags[0].ti_Data=(ULONG)dispinfo.Resolution.x|(((ULONG)dispinfo.Resolution.y)<<16);
  315.                 n->Font.tta_Style |= FSF_TAGGED;
  316.                 n->Font.tta_Tags   =fonttags;
  317.               }
  318.             }
  319.             CloneTextAttr(&n->Font,&ON->TA);
  320.   
  321.             n->Font.tta_Style &= (~FSF_TAGGED);
  322.             n->Font.tta_Tags=NULL;
  323.           }
  324.         }
  325.         break;
  326.     }
  327.  
  328.     if(n->PubOptions==1)
  329.     {
  330.       ULONG error=FALSE;
  331.       struct TagItem badtags[]=
  332.       {
  333.         SA_BitMap,    1<<0,
  334. //      SA_PubName,   1<<1,
  335.         SA_PubSig,    1<<2,
  336.         SA_PubTask,   1<<3,
  337.         SA_BackFill,  1<<4,
  338.         TAG_DONE,     0
  339.       };
  340.       
  341.       if(taglist) error =PackBoolTags(0,taglist,badtags);
  342.       if(ns)      error|=(ns->Type & CUSTOMBITMAP);
  343.       
  344.       if(error==0)
  345.       {
  346.         if(ON=AllocOpenNode(ON))
  347.         {
  348.           struct OpenNode *won;
  349.           UBYTE number[8];
  350.           ULONG cnt=1,len;
  351.           
  352.           strncpy(ON->PubName,n->PubName,MAXPUBSCREENNAME);
  353.           ON->PubName[MAXPUBSCREENNAME]=0;
  354.           len=strlen(ON->PubName);
  355.           len=min(len,MAXPUBSCREENNAME-9);
  356.           
  357.           won=(struct OpenNode *)MPSem->OpenList.lh_Head;
  358.           while(won->on_Node.ln_Succ)
  359.           {
  360.             if(cnt > 1)   
  361.             {
  362.               number[0]='.';
  363.               stci_d(&number[1],cnt);        
  364.               ON->PubName[len]=0;
  365.               strncat(ON->PubName,number,MAXPUBSCREENNAME);
  366.               ON->PubName[MAXPUBSCREENNAME]=0;
  367.             }
  368.             
  369.             if(0==strcmp(ON->PubName,won->PubName))
  370.             {
  371.               won=(struct OpenNode *)MPSem->OpenList.lh_Head;
  372.               cnt++;
  373.             }
  374.             else
  375.               won=(struct OpenNode *)won->on_Node.ln_Succ;
  376.           }
  377.           
  378.           ON->PubName[MAXPUBSCREENNAME]=0;
  379.           ON->Flags|=ON_PUBLIC|ON_OPEN;
  380.           
  381.           ti[TagNum].ti_Tag=SA_Title;
  382.           ti[TagNum].ti_Data=(ULONG)ON->PubName;
  383.           TagNum++;
  384.   
  385.           ti[TagNum].ti_Tag=SA_PubName;
  386.           ti[TagNum].ti_Data=(ULONG)ON->PubName;
  387.           TagNum++;
  388.       
  389.           ti[TagNum].ti_Tag=SA_PubSig;
  390.           ti[TagNum].ti_Data=PublicSignal;
  391.           TagNum++;
  392.           
  393.           ti[TagNum].ti_Tag=SA_PubTask;
  394.           ti[TagNum].ti_Data=(ULONG)MPTask;
  395.           TagNum++;
  396.           
  397.           
  398.           if(!(ON->Flags & ON_FONT))
  399.           {
  400.             struct TTextAttr *ot=NULL;
  401.             
  402.             if(ns)  ot=(struct TTextAttr *)ns->Font;          
  403.             ot=(struct TTextAttr *)GetTagData(SA_Font,(ULONG)ot,taglist);
  404.             
  405.             if(ot)
  406.             {
  407.               ON->Flags|=ON_FONT;
  408.   
  409.               CloneTextAttr(ot,&ON->TA);
  410.   
  411.               ti[TagNum].ti_Tag =SA_Font;
  412.               ti[TagNum].ti_Data=(ULONG)&ON->TA;
  413.               TagNum++;
  414.             }
  415.           }
  416.         }
  417.       }
  418.     }
  419.  
  420.   }/* end if !wbscr */
  421.   else  /* Yes, this is the Workbench screen */
  422.   {
  423.     if(ON=AllocOpenNode(ON))
  424.       ON->Flags|=ON_WORKBENCH;
  425.   }
  426.  
  427.   if(look3d)
  428.   {
  429.     ti[TagNum].ti_Tag=SA_Pens;
  430.     ti[TagNum].ti_Data=(ULONG)screenpens;
  431.     TagNum++;
  432.     
  433.     if(depth==1)
  434.     {
  435.       depth=2;
  436.       dodepth=TRUE;
  437.       //  ti[TagNum].ti_Tag=SA_Depth;
  438.       //  ti[TagNum].ti_Data=2;
  439.       //   TagNum++;
  440.     }
  441.   }
  442.  
  443.   if(autoscroll)
  444.   {
  445.     ti[TagNum].ti_Tag=SA_AutoScroll;
  446.     ti[TagNum].ti_Data=TRUE;
  447.     TagNum++;
  448.   }
  449.  
  450.   
  451.   if(n->Flags & CENTER)
  452.   {    
  453.     if(GetDisplayInfoData(NULL,(UBYTE *)&diminfo,sizeof(struct DimensionInfo),DTAG_DIMS,modeid))
  454.     {
  455.       if(width>-1)
  456.       {
  457.         ti[TagNum].ti_Tag=SA_Left;
  458.         ti[TagNum].ti_Data=((diminfo.Nominal.MaxX-diminfo.Nominal.MinX)-width)/2;
  459.         TagNum++;
  460.       }
  461.       if(height>-1)
  462.       {
  463.         ti[TagNum].ti_Tag=SA_Top;
  464.         ti[TagNum].ti_Data=((diminfo.Nominal.MaxY-diminfo.Nominal.MinY)-height)/2;
  465.         TagNum++;
  466.       }
  467.     }
  468.   }
  469.   
  470.  
  471.  
  472.   if(n->Flags & SCRHOTKEY)
  473.   {
  474.     if(ON=AllocOpenNode(ON))
  475.     {
  476.       if(ON->HotKey=AllocVec(strlen(n->HotKey)+1,MEMF_CLEAR|MEMF_PUBLIC))
  477.       {
  478.         strcpy(ON->HotKey,n->HotKey);
  479.         ON->Cx=AddHotKey(Broker,BrokerPort,ON->HotKey,(ULONG)ON);
  480.       }
  481.     }
  482.   }
  483.   
  484.  
  485.   if(interleave && !(custombm))
  486.   {
  487.     ti[TagNum].ti_Tag=SA_Interleaved;
  488.     ti[TagNum].ti_Data=TRUE;
  489.     TagNum++;
  490.   }
  491.  
  492.   
  493.   ti[TagNum].ti_Tag=SA_MinimizeISG; /*** just a little extra for v40 ***/
  494.   ti[TagNum].ti_Data=TRUE;
  495.   TagNum++;
  496.  
  497.   if(taglist)
  498.   {
  499.     ti[TagNum].ti_Tag=TAG_MORE;
  500.     ti[TagNum].ti_Data=(ULONG)taglist;
  501.   }
  502.   else
  503.   {
  504.     ti[TagNum].ti_Tag=TAG_DONE;
  505.     ti[TagNum].ti_Data=0;
  506.   }
  507.   /**** End Setup taglist ****/
  508.  
  509. //  printf("\nNew Tags:\n");  
  510. //  PrintTags(ti);
  511.  
  512.   
  513.   if(ON)
  514.   {
  515.     if(ON->Flags & ON_FONT)
  516.       textfont=OpenDiskFont((struct TextAttr *)&ON->TA);
  517.   }
  518.   
  519.   scr=OldOpenScreenTagList(ns,ti,IntuitionBase);
  520.  
  521.   if(scr && n->Flags & SHAREPENS && n->LockedPens && V39)
  522.   {
  523.     UBYTE *str,state=0,done=FALSE;
  524.     WORD num=0,num1=0,num2;
  525.     struct ColorMap *cm;
  526.     
  527.     cm=scr->ViewPort.ColorMap;
  528.     
  529.     str=n->LockedPens;
  530.     
  531.     while(!done)
  532.     {
  533.       if(!*str) done=TRUE;
  534.       
  535.       if(*str>='0' && *str<='9')
  536.       {
  537.         if(state==0)
  538.           state=1;
  539.         num=0;
  540.         while(*str>='0' && *str<='9')
  541.         {
  542.           num*=10;
  543.           num+=*str - '0';
  544.           str++;
  545.         }
  546.         
  547.         switch(state)
  548.         {
  549.           case 1:
  550.        //     printf("obtaining %d\n",num);
  551.             ObtainPen(cm,num,0,0,0, PEN_EXCLUSIVE | PEN_NO_SETCOLOR);
  552.             break;
  553.           case 2:
  554.             for(num2=num1+1;num2<=num;num2++)
  555.             {
  556.          //     printf("obtaining %d\n",num2);
  557.               ObtainPen(cm,num2,0,0,0, PEN_EXCLUSIVE | PEN_NO_SETCOLOR);
  558.             }
  559.             break;
  560.         }
  561.         state=0;
  562.        
  563.       }
  564.       
  565.       if(*str==' ')
  566.         for(;*str==' ';str++);
  567.       else
  568.         if(*str=='-')
  569.         {
  570.           num1=num;
  571.           state=2;
  572.           str++;
  573.         }
  574.         else
  575.           str++;
  576.     }
  577.   }
  578.  
  579.  
  580.  
  581.   if(ON)
  582.   {
  583.     if(ON->Flags & ON_FONT)
  584.       if(textfont)
  585.         CloseFont(textfont);
  586.     
  587.     if(scr)
  588.     {
  589.       ON->Screen=scr;
  590.       if(ON->Flags & ON_PUBLIC)
  591.       {
  592.         if(n->PubOptions == 1)
  593.         {
  594.           PubScreenStatus(scr,0);
  595.         }
  596.       }
  597.       AddHead(&MPSem->OpenList,(struct Node *)ON);
  598.     }
  599.     else
  600.       FreeOpenNode(ON);
  601.   }
  602.   
  603. /*
  604.   if(scr)
  605.   {
  606.     VideoControlTags(scr->ViewPort.ColorMap,
  607.                       VTAG_BORDERSPRITE_SET,TRUE,
  608.                       TAG_DONE);
  609.   }
  610. */
  611.   if(ns) ns->Font=storedfont;
  612.  
  613.   if(!scr) scr=OldOpenScreenTagList((struct ExtNewScreen *)ns,taglist,IntuitionBase);
  614.  
  615.   ReleaseSemaphore(&MPSem->ListSem);
  616.   ReleaseSemaphore(&MPSem->NodeSem);
  617.   return(scr);
  618. }
  619.  
  620. BOOL __saveds ASM NewCloseScreen(REG __a0 struct Screen *S)
  621. {
  622.   struct OpenNode *on;
  623.   BOOL rv,ok=FALSE;
  624.   ULONG pub=0;
  625.  
  626.  
  627.   ObtainSemaphore(&MPSem->OpenListSem);
  628.   
  629.   on=(struct OpenNode *)MPSem->OpenList.lh_Head;
  630.   while(on->on_Node.ln_Succ)
  631.   {
  632.     if(on->Screen==S)
  633.     {
  634.       Remove((struct Node *)on);
  635.       pub=on->Flags & ON_PUBLIC;
  636.       ok=TRUE;
  637.       break;
  638.     }
  639.     on=(struct OpenNode *)on->on_Node.ln_Succ;
  640.   }
  641.   
  642.   if(!ok) on=NULL;
  643.   
  644.   if(!pub)
  645.   {
  646.     if(rv=OldCloseScreen(S,IntuitionBase))
  647.       FreeOpenNode(on);
  648.     else
  649.       if(on)
  650.         AddHead(&MPSem->OpenList,(struct Node *)on);  
  651.   }
  652.   else  // Public
  653.   {
  654.     on->Flags&=(~ON_OPEN);
  655.     S->DefaultTitle=S->Title=on->PubName;
  656.     ShowTitle(S,TRUE);
  657.     AddHead(&MPSem->OpenList,(struct Node *)on);
  658.     rv=TRUE;
  659.     Signal((struct Task *)MPTask,1<<PublicSignal);
  660.   }          
  661.   ReleaseSemaphore(&MPSem->OpenListSem);   
  662.  
  663.   return(rv);
  664. }
  665.  
  666. LONG __saveds ASM NewCloseWorkBench(void)
  667. {   
  668.   LONG retval;
  669.   
  670.   ObtainSemaphore(&MPSem->OpenListSem);
  671.   
  672.   if(retval=OldCloseWorkBench(IntuitionBase))
  673.     FreeWBOpenNode();
  674.   
  675.   ReleaseSemaphore(&MPSem->OpenListSem);
  676.   return(retval);
  677. }
  678.   
  679. void FreeOpenNode(struct OpenNode *on)
  680. {
  681.   if(on) 
  682.   { 
  683.     //if(on->TA.tta_Name)
  684.     FreeVec(on->TA.tta_Name);
  685.     //if(on->TA.tta_Tags)
  686.     FreeVec(on->TA.tta_Tags);
  687.     //if(on->Cx)
  688.     DeleteCxObjAll(on->Cx);
  689.     FreeVec(on->HotKey);
  690.     FreeMem(on,sizeof(struct OpenNode));
  691.   }
  692. }
  693.  
  694. void FreeWBOpenNode(void)
  695. {
  696.   struct OpenNode *on;
  697.  
  698.   on=(struct OpenNode *)MPSem->OpenList.lh_Head;
  699.   while(on->on_Node.ln_Succ)
  700.   {
  701.     if((on->Flags & ON_WORKBENCH))
  702.     {
  703.       Remove((struct Node *)on);
  704.       FreeOpenNode(on);
  705.       return;
  706.     }
  707.     on=(struct OpenNode *)on->on_Node.ln_Succ;
  708.   }
  709. }
  710.  
  711. struct Window __saveds ASM *NewOpenWindow(REG __a0 struct ExtNewWindow *nw)
  712. {
  713.   return(NewOpenWindowTagList(nw,nw->Flags & WFLG_NW_EXTENDED ? nw->Extension:0));
  714. }
  715.  
  716. struct Window __saveds ASM *NewOpenWindowTagList(REG __a0 struct ExtNewWindow *nw,
  717.                                                  REG __a1 struct TagItem *TagList)
  718. {
  719.   struct Window *w;
  720.   struct TagItem ti[]={WA_NewLookMenus , TRUE , 
  721.                        TAG_DONE , 0};
  722.  
  723. //  ObtainSemaphoreShared(&MPSem->ListSem);
  724.  
  725.   if(MPSem->EnabledNLM)  
  726.   {
  727.     if(TagList)
  728.     {
  729.       ti[1].ti_Tag =TAG_MORE;
  730.       ti[1].ti_Data=(ULONG)TagList;
  731.     }
  732.     TagList=ti;              
  733.   }
  734.  
  735.   w=(struct Window *)OldOpenWindowTagList((struct NewWindow *)nw,TagList,IntuitionBase);
  736.  
  737. //  ReleaseSemaphore(&MPSem->ListSem);
  738.   
  739.   return(w); 
  740. }
  741.  
  742. BOOL __saveds ASM NewLayoutMenusA(REG __a0 struct Menu *fm,
  743.                                   REG __a1 APTR vi, 
  744.                                   REG __a2 struct TagItem *tags)
  745. {
  746.   BOOL rv;
  747.   struct TagItem ti[2]=
  748.   {
  749.     GTMN_NewLookMenus,TRUE,
  750.     TAG_DONE,0
  751.   };
  752.  
  753. //  ObtainSemaphoreShared(&MPSem->ListSem);
  754.  
  755.   if(MPSem->EnabledNLM)    
  756.   {
  757.     if(tags)
  758.     {
  759.       ti[1].ti_Tag=TAG_MORE;
  760.       ti[1].ti_Data=(ULONG)tags;
  761.     }
  762.     rv=(BOOL)OldLayoutMenusA(fm,vi,ti,GadToolsBase);
  763.   }
  764.   else
  765.     rv=(BOOL)OldLayoutMenusA(fm,vi,tags,GadToolsBase);
  766.   
  767. //  ReleaseSemaphore(&MPSem->ListSem);
  768.   return(rv); 
  769. }
  770.  
  771. void CatchDNode(ULONG dest, UBYTE *Name)
  772. {
  773.   struct DefaultNode *dnode;
  774.   LONG l;
  775.   
  776.   if(dnode=AllocVec(sizeof(struct DefaultNode),MEMF_CLEAR|MEMF_PUBLIC))
  777.   {
  778.     if(dnode->Def_Node.ln_Name=AllocVec(strlen(Name)+1,MEMF_CLEAR|MEMF_PUBLIC))
  779.     {
  780.       strcpy(dnode->Def_Node.ln_Name,Name);
  781.       dnode->Type         =dest;
  782.       dnode->Width        =width;
  783.       dnode->Height       =height;
  784.       dnode->AutoScroll   =autoscroll;
  785.       dnode->ModeSelect   =0;
  786.       dnode->ModeID       =modeid;
  787.       dnode->OverscanType =overscan;
  788.       dnode->Look3D       =look3d;
  789.       dnode->Flags        =0;
  790.       dnode->Depth        =depth;
  791.       if(interleave)
  792.         dnode->Flags|=INTERLEAVE;
  793.       l=0;
  794.  
  795.       if(screenpens)
  796.         for(;l<NumDriPens && screenpens[l]!=(~0);l++)
  797.           dnode->Pens[l]=screenpens[l]; 
  798.  
  799.       for(;l<NumDriPens;l++)
  800.         dnode->Pens[l]=0;//defaultpens[l];
  801.  
  802.       PutMsg(CatchPort,(struct Message *)dnode);
  803.       return;
  804.     }
  805.     FreeVec(dnode);
  806.   }
  807. }
  808.  
  809. /*
  810.  
  811. void PrintTags(struct TagItem *tags)
  812. {
  813.   struct TagItem *ti;
  814.   
  815.   while(ti=NextTagItem(&tags))
  816.   {
  817.     printf("%s  %10u\n",FindTagSting(ti->ti_Tag),ti->ti_Data);
  818.   }
  819. }
  820.  
  821.  
  822. ULONG TagID[]=
  823. {
  824.   SA_Left,
  825.   SA_Top,
  826.   SA_Width,
  827.   SA_Height,
  828.   SA_Depth,
  829.   SA_DetailPen,
  830.   SA_BlockPen,
  831.   SA_Title,
  832.   SA_Colors,
  833.   SA_ErrorCode,
  834.   SA_Font,
  835.   SA_SysFont,
  836.   SA_Type,
  837.   SA_BitMap,
  838.   SA_PubName,
  839.   SA_PubSig,
  840.   SA_PubTask,
  841.   SA_DisplayID,
  842.   SA_DClip,
  843.   SA_Overscan,
  844.   SA_Obsolete1,
  845.   SA_ShowTitle,
  846.   SA_Behind,
  847.   SA_Quiet,
  848.   SA_AutoScroll,
  849.   SA_Pens,
  850.   SA_FullPalette,
  851.   SA_ColorMapEntries,
  852.   SA_Parent,
  853.   SA_Draggable,
  854.   SA_Exclusive,
  855.   SA_SharePens,
  856.   SA_BackFill,
  857.   SA_Interleaved,
  858.   SA_Colors32,
  859.   SA_VideoControl,
  860.   SA_FrontChild,
  861.   SA_BackChild,
  862.   SA_LikeWorkbench,
  863.   SA_Reserved,
  864.   SA_MinimizeISG,
  865.   0xffffffff,
  866. };
  867.  
  868. UBYTE *TagStrings[]=
  869. {
  870.   "SA_Left",
  871.   "SA_Top",
  872.   "SA_Width",
  873.   "SA_Height",
  874.   "SA_Depth",
  875.   "SA_DetailPen",
  876.   "SA_BlockPen",
  877.   "SA_Title",
  878.   "SA_Colors",
  879.   "SA_ErrorCode",
  880.   "SA_Font",
  881.   "SA_SysFont",
  882.   "SA_Type",
  883.   "SA_BitMap",
  884.   "SA_PubName",
  885.   "SA_PubSig",
  886.   "SA_PubTask",
  887.   "SA_DisplayID",
  888.   "SA_DClip",
  889.   "SA_Overscan",
  890.   "SA_Obsolete1",
  891.   "SA_ShowTitle",
  892.   "SA_Behind",
  893.   "SA_Quiet",
  894.   "SA_AutoScroll",
  895.   "SA_Pens",
  896.   "SA_FullPalette",
  897.   "SA_ColorMapEntries",
  898.   "SA_Parent",
  899.   "SA_Draggable",
  900.   "SA_Exclusive",
  901.   "SA_SharePens",
  902.   "SA_BackFill",
  903.   "SA_Interleaved",
  904.   "SA_Colors32",
  905.   "SA_VideoControl",
  906.   "SA_FrontChild",
  907.   "SA_BackChild",
  908.   "SA_LikeWorkbench",
  909.   "SA_Reserved",
  910.   "SA_MinimizeISG",
  911.   "Unknown Tag"
  912. };
  913.  
  914.  
  915.  
  916.  
  917.  
  918. UBYTE *FindTagSting(ULONG id)
  919. {
  920.   ULONG l;
  921.   
  922.   for(l=0;;l++)
  923.   {
  924.     if(TagID[l]==id || TagID[l]==0xffffffff)
  925.       return(TagStrings[l]);
  926.   }
  927.   return(TagStrings[l]);
  928. }
  929.  
  930. */
  931.  
  932.  
  933. void CloneTextAttr(struct TTextAttr *Source, struct TTextAttr *Dest)
  934. {
  935.   CopyMem(Source,Dest,sizeof(struct TextAttr));
  936.     
  937.   if(Dest->tta_Name=AllocVec(strlen(Source->tta_Name)+1,MEMF_CLEAR|MEMF_PUBLIC))
  938.   {
  939.     strcpy(Dest->tta_Name,Source->tta_Name);
  940.     if(Dest->tta_Style & FSF_TAGGED)
  941.     {
  942.       if(!(Dest->tta_Tags=CloneTagItems(Source->tta_Tags)))
  943.         Dest->tta_Style &= (~FSF_TAGGED);
  944.     }
  945.   }
  946.   else
  947.   {
  948.     Dest->tta_Name=Topaz;
  949.     Dest->tta_YSize=8;
  950.     Dest->tta_Style=0;
  951.     Dest->tta_Flags=0;
  952.   }
  953. }
  954.  
  955.