home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 500-599 / ff589.lza / Term / TermSrc.lha / FastMacros.c < prev    next >
C/C++ Source or Header  |  1991-10-03  |  9KB  |  481 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1991 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: FastMacros.c
  6.  *    Created ..: Monday 19-Aug-91 19:49
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    19-Aug-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "TermGlobal.h"
  16.  
  17. STATIC WORD         Left = -1,Top = -1,Height = -1;
  18. STATIC struct Gadget    *GadgetList = NULL;
  19. STATIC WORD         Dims[4] = { -1,-1,-1,-1 };
  20.  
  21. #define WIDTH    192
  22. #define HEIGHT    99
  23.  
  24. VOID
  25. RefreshFastWindow(WORD Height)
  26. {
  27.     struct Gadget        *Gadget;
  28.     struct NewGadget     NewGadget;
  29.     WORD             TopEdge = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  30.  
  31.     memset(&NewGadget,0,sizeof(struct NewGadget));
  32.  
  33.     if(GadgetList)
  34.     {
  35.         RemoveGList(FastWindow,GadgetList,-1);
  36.  
  37.         SetAPen(FastWindow -> RPort,0);
  38.  
  39.         RectFill(FastWindow -> RPort,FastWindow -> BorderRight,FastWindow -> BorderTop,FastWindow -> Width - (FastWindow -> BorderLeft + 1),FastWindow -> Height - (FastWindow -> BorderBottom + 1));
  40.  
  41.         FreeGadgets(GadgetList);
  42.  
  43.         GadgetList = NULL;
  44.     }
  45.  
  46.     if(Gadget = CreateContext(&GadgetList))
  47.     {
  48.         NewGadget . ng_Width        = 180;
  49.         NewGadget . ng_Height        = Height - (TopEdge + 4 + 8);
  50.         NewGadget . ng_GadgetText    = "";
  51.         NewGadget . ng_GadgetID        = 0;
  52.         NewGadget . ng_LeftEdge        = 6;
  53.         NewGadget . ng_TopEdge        = 1 + TopEdge;
  54.         NewGadget . ng_TextAttr        = &DefaultFont;
  55.         NewGadget . ng_VisualInfo    = VisualInfo;
  56.     
  57.         FastGadget = Gadget = CreateGadget(LISTVIEW_KIND,Gadget,&NewGadget,
  58.             GTLV_Labels,    &FastMacroList,
  59.         TAG_DONE);
  60.     }
  61.  
  62.     if(Gadget)
  63.     {
  64.         AddGList(FastWindow,GadgetList,(UWORD)-1,(UWORD)-1,NULL);
  65.         RefreshGList(GadgetList,FastWindow,NULL,(UWORD)-1);
  66.         GT_RefreshWindow(FastWindow,NULL);
  67.     }
  68.     else
  69.     {
  70.         FreeGadgets(GadgetList);
  71.  
  72.         GadgetList = NULL;
  73.     }
  74. }
  75.  
  76. VOID
  77. CloseFastWindow()
  78. {
  79.     if(FastWindow)
  80.     {
  81.         Left    = FastWindow -> LeftEdge;
  82.         Top    = FastWindow -> TopEdge;
  83.         Height    = FastWindow -> Height;
  84.  
  85.         ClearMenuStrip(FastWindow);
  86.         CloseWindowSafely(FastWindow);
  87.  
  88.         FastWindow = NULL;
  89.     }
  90.  
  91.     if(GadgetList)
  92.     {
  93.         FreeGadgets(GadgetList);
  94.  
  95.         GadgetList = NULL;
  96.     }
  97. }
  98.  
  99. BYTE
  100. OpenFastWindow()
  101. {
  102.     if(Height == -1)
  103.         Height = HEIGHT;
  104.  
  105.     if(Left == -1)
  106.         Left = Screen -> Width - WIDTH;
  107.  
  108.     if(Top == -1)
  109.         Top = (Screen -> Height - Height) >> 1;
  110.  
  111.     if(Top + Height > Screen -> Height)
  112.     {
  113.         if(Top >= Screen -> Height - (HEIGHT - 56))
  114.             Top = Screen -> Height - (HEIGHT - 56);
  115.  
  116.         while(Top + Height > Screen -> Height)
  117.             Height--;
  118.     }
  119.  
  120.     if(Dims[0] == -1)
  121.     {
  122.         Dims[0] = 0;
  123.         Dims[1] = 0;
  124.         Dims[2] = WIDTH;
  125.         Dims[3] = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  126.     }
  127.  
  128.     if(FastWindow = OpenWindowTags(NULL,
  129.         WA_Width,    WIDTH,
  130.         WA_Height,    Height,
  131.  
  132.         WA_Left,    Left,
  133.         WA_Top,        Top,
  134.  
  135.         WA_DragBar,    TRUE,
  136.         WA_DepthGadget,    TRUE,
  137.         WA_CloseGadget,    TRUE,
  138.         WA_RMBTrap,    TRUE,
  139.         WA_Zoom,    Dims,
  140.  
  141.         WA_SizeGadget,    TRUE,
  142.         WA_SizeBBottom,    TRUE,
  143.  
  144.         WA_MinWidth,    WIDTH,
  145.         WA_MaxWidth,    WIDTH,
  146.  
  147.         WA_MinHeight,    HEIGHT - 56,
  148.         WA_MaxHeight,    ~0,
  149.  
  150.         WA_Title,    "Fast! Macros",
  151.  
  152.         WA_CustomScreen,Screen,
  153.     TAG_DONE))
  154.     {
  155.         FastWindow -> UserPort = Window -> UserPort;
  156.  
  157.         ModifyIDCMP(FastWindow,Window -> IDCMPFlags);
  158.  
  159.         SetMenuStrip(FastWindow,Menu);
  160.  
  161.         FastWindow -> Flags &= ~WFLG_RMBTRAP;
  162.  
  163.         RefreshFastWindow(Height);
  164.  
  165.         return(TRUE);
  166.     }
  167.  
  168.     return(FALSE);
  169. }
  170.  
  171. struct MacroNode *
  172. NewFastMacro(UBYTE *Macro,UBYTE *Code)
  173. {
  174.     struct MacroNode *Node;
  175.  
  176.     if(Node = (struct MacroNode *)AllocVec(sizeof(struct MacroNode) + 21 + 257,MEMF_PUBLIC|MEMF_CLEAR))
  177.     {
  178.         Node -> mn_Macro    = (UBYTE *)(Node + 1);
  179.         Node -> mn_Code        = &Node -> mn_Macro[21];
  180.  
  181.         strcpy(Node -> mn_Macro,Macro);
  182.         strcpy(Node -> mn_Code ,Code);
  183.  
  184.         return(Node);
  185.     }
  186.  
  187.     return(NULL);
  188. }
  189.  
  190. VOID
  191. RemFastMacro(struct MacroNode *Node)
  192. {
  193.     Remove((struct Node *)Node);
  194.  
  195.     FreeVec(Node);
  196. }
  197.  
  198. struct MacroNode *
  199. GetFastMacro(LONG Offset)
  200. {
  201.     struct MacroNode    *Node;
  202.     LONG             i;
  203.  
  204.     Node = (struct MacroNode *)FastMacroList . lh_Head;
  205.  
  206.     for(i = 0 ; i < Offset ; i++)
  207.     {
  208.         if(!Node -> mn_Succ -> mn_Succ)
  209.             return(NULL);
  210.  
  211.         Node = Node -> mn_Succ;
  212.     }
  213.  
  214.     return(Node);
  215. }
  216.  
  217. VOID
  218. ClearFastMacroList(struct List *List)
  219. {
  220.     struct Node *Node,*NextNode;
  221.  
  222.     Node = List -> lh_Head;
  223.  
  224.     while(Node -> ln_Succ)
  225.     {
  226.         NextNode = Node -> ln_Succ;
  227.  
  228.         Remove(Node);
  229.  
  230.         FreeVec(Node);
  231.  
  232.         Node = NextNode;
  233.     }
  234. }
  235.  
  236. LONG
  237. GetFastMacroOffset(struct MacroNode *MacroNode)
  238. {
  239.     struct MacroNode    *Node;
  240.     LONG             Offset = 0;
  241.  
  242.     Node = (struct MacroNode *)FastMacroList . lh_Head;
  243.  
  244.     while(Node -> mn_Succ)
  245.     {
  246.         if(Node == MacroNode)
  247.             return(Offset);
  248.  
  249.         Offset++;
  250.  
  251.         Node = Node -> mn_Succ;
  252.     }
  253.  
  254.     return(~0);
  255. }
  256.  
  257. BYTE
  258. SaveFastMacros(UBYTE *Name)
  259. {
  260.     struct IFFHandle    *Handle;
  261.     BYTE             Success = FALSE;
  262.  
  263.     if(Handle = (struct IFFHandle *)AllocIFF())
  264.     {
  265.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  266.         {
  267.             InitIFFasDOS(Handle);
  268.  
  269.             if(!OpenIFF(Handle,IFFF_WRITE))
  270.             {
  271.                 if(!PushChunk(Handle,'TERM',ID_CAT,IFFSIZE_UNKNOWN))
  272.                 {
  273.                     if(!PushChunk(Handle,'TERM',ID_FORM,IFFSIZE_UNKNOWN))
  274.                     {
  275.                         if(!PushChunk(Handle,0,'VERS',IFFSIZE_UNKNOWN))
  276.                         {
  277.                             struct TermInfo TermInfo;
  278.  
  279.                             TermInfo . Version    = TermVersion;
  280.                             TermInfo . Revision    = TermRevision;
  281.  
  282.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  283.                             {
  284.                                 if(PopChunk(Handle))
  285.                                     Success = FALSE;
  286.                                 else
  287.                                 {
  288.                                     struct MacroNode *Node;
  289.  
  290.                                     Node = (struct MacroNode *)FastMacroList . lh_Head;
  291.  
  292.                                     while(Node -> mn_Succ)
  293.                                     {
  294.                                         if(!PushChunk(Handle,'TERM',ID_FORM,IFFSIZE_UNKNOWN))
  295.                                         {
  296.                                             if(!PushChunk(Handle,0,'FAST',IFFSIZE_UNKNOWN))
  297.                                             {
  298.                                                 if(WriteChunkBytes(Handle,Node -> mn_Macro,20) != 20)
  299.                                                 {
  300.                                                     Success = FALSE;
  301.  
  302.                                                     break;
  303.                                                 }
  304.                                                 else
  305.                                                 {
  306.                                                     if(WriteChunkBytes(Handle,Node -> mn_Code,256) != 256)
  307.                                                     {
  308.                                                         Success = FALSE;
  309.  
  310.                                                         break;
  311.                                                     }
  312.                                                     else
  313.                                                     {
  314.                                                         if(PopChunk(Handle))
  315.                                                         {
  316.                                                             Success = FALSE;
  317.  
  318.                                                             break;
  319.                                                         }
  320.                                                         else
  321.                                                             Success = TRUE;
  322.                                                     }
  323.                                                 }
  324.                                             }
  325.  
  326.                                             if(Success)
  327.                                             {
  328.                                                 if(PopChunk(Handle))
  329.                                                 {
  330.                                                     Success = FALSE;
  331.  
  332.                                                     break;
  333.                                                 }
  334.                                             }
  335.                                         }
  336.  
  337.                                         Node = Node -> mn_Succ;
  338.                                     }
  339.                                 }
  340.                             }
  341.                         }
  342.  
  343.                         if(PopChunk(Handle))
  344.                             Success = FALSE;
  345.                     }
  346.  
  347.                     if(PopChunk(Handle))
  348.                         Success = FALSE;
  349.                 }
  350.  
  351.                 CloseIFF(Handle);
  352.             }
  353.  
  354.             Close(Handle -> iff_Stream);
  355.         }
  356.  
  357.         FreeIFF(Handle);
  358.     }
  359.  
  360.     if(Success)
  361.         SetProtection(Name,FIBF_EXECUTE);
  362.     else
  363.         DeleteFile(Name);
  364.  
  365.     return(Success);
  366. }
  367.  
  368. VOID __regargs
  369. MoveList(struct List *From,struct List *To)
  370. {
  371.     struct Node *Node,*NextNode;
  372.  
  373.     Node = From -> lh_Head;
  374.  
  375.     while(NextNode = Node -> ln_Succ)
  376.     {
  377.         Remove(Node);
  378.  
  379.         AddTail(To,Node);
  380.  
  381.         Node = NextNode;
  382.     }
  383. }
  384.  
  385. BYTE
  386. LoadFastMacros(UBYTE *Name)
  387. {
  388.     STATIC ULONG Stops[4] =
  389.     {
  390.         'TERM','VERS',
  391.         'TERM','FAST'
  392.     };
  393.  
  394.     struct List __aligned     NewFastMacroList;
  395.     LONG             NewFastMacroCount = 0;
  396.     struct IFFHandle    *Handle;
  397.     BYTE             Success = FALSE;
  398.     struct MacroNode    *Node;
  399.     struct ContextNode    *Chunk;
  400.  
  401.     NewList(&NewFastMacroList);
  402.  
  403.     if(Handle = AllocIFF())
  404.     {
  405.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  406.         {
  407.             InitIFFasDOS(Handle);
  408.  
  409.             if(!OpenIFF(Handle,IFFF_READ))
  410.             {
  411.                 if(!StopChunks(Handle,&Stops[0],2))
  412.                 {
  413.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  414.                     {
  415.                         Chunk = CurrentChunk(Handle);
  416.  
  417.                         if(Chunk -> cn_ID == 'VERS')
  418.                         {
  419.                             struct TermInfo TermInfo;
  420.  
  421.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  422.                             {
  423.                                 if(TermInfo . Version > TermVersion || TermInfo . Revision > 9 || TermInfo . Revision < 6)
  424.                                     break;
  425.                             }
  426.                             else
  427.                                 break;
  428.                         }
  429.  
  430.                         if(Chunk -> cn_ID == 'FAST')
  431.                         {
  432.                             if(Node = NewFastMacro("",""))
  433.                             {
  434.                                 if(ReadChunkBytes(Handle,Node -> mn_Macro,20) == 20)
  435.                                 {
  436.                                     if(ReadChunkBytes(Handle,Node -> mn_Code,256) == 256)
  437.                                     {
  438.                                         AddTail(&NewFastMacroList,(struct Node *)Node);
  439.  
  440.                                         NewFastMacroCount++;
  441.  
  442.                                         Success = TRUE;
  443.                                     }
  444.                                     else
  445.                                         break;
  446.                                 }
  447.                                 else
  448.                                     break;
  449.                             }
  450.                             else
  451.                                 break;
  452.                         }
  453.                     }
  454.  
  455.                     if(Success)
  456.                     {
  457.                         if(NewFastMacroList . lh_Head -> ln_Succ)
  458.                         {
  459.                             ClearFastMacroList(&FastMacroList);
  460.  
  461.                             MoveList(&NewFastMacroList,&FastMacroList);
  462.  
  463.                             FastMacroCount = NewFastMacroCount;
  464.                         }
  465.                     }
  466.                     else
  467.                         ClearFastMacroList(&NewFastMacroList);
  468.                 }
  469.  
  470.                 CloseIFF(Handle);
  471.             }
  472.  
  473.             Close(Handle -> iff_Stream);
  474.         }
  475.  
  476.         FreeIFF(Handle);
  477.     }
  478.  
  479.     return(Success);
  480. }
  481.