workbench/tools/Edit/Macros.c

   1 /***************************************************
   2 **                                                **
   3 **      $VER: Macros.c 1.0 (15.8.2001)            **
   4 **      Record sequence of keystrokes             **
   5 **                                                **
   6 **      © T.Pierron, C.Guilaume. Free software    **
   7 **      under terms of GNU public license.        **
   8 **                                                **
   9 ***************************************************/
  10
  11 #include <intuition/intuition.h>
  12 #include <intuition/screens.h>
  13 #include <exec/memory.h>
  14 #include "Project.h"
  15 #include "Macros.h"
  16 #include "Gui.h"
  17 #include "Utility.h"
  18 #include "Cursor.h"
  19 #include "Jed.h"
  20 #include "Events.h"
  21 #include "ProtoTypes.h"
  22
  23 #define CATCOMP_NUMBERS
  24 #include "strings.h"
  25
  26 extern STRPTR  InfoTmpl;
  27 extern UBYTE   record;
  28 extern Project edit;
  29 static STRPTR  OldInfo = NULL;
  30
  31 UBYTE NewTmpl[20], TmplLen, TmplWid;
  32
  33 /** Manage a set of macros **/
  34 Macro MainMacro = NULL, MacCur = NULL, LastChunk;
  35
  36 UBYTE SzOp[] = {
  37         sizeof( *(ActChar)0L ),
  38         sizeof( *(ActMenu)0L ),
  39         sizeof( *(ActShortcut)0L )
  40 };
  41
  42 /*** Setup some variables ***/
  43 void init_macros( void )
  44 {
  45         TmplLen = strlen(
  46         strcpy(NewTmpl, ErrMsg(WARN_REC)));
  47         strcat(NewTmpl, "  "); TmplLen += 2;
  48         strcat(NewTmpl, InfoTmpl);
  49 }
  50
  51 /*** Free memory used by a macro ***/
  52 void free_macro( Macro m )
  53 {
  54         Macro next;
  55         for(; m ; next = m->next, FreeVec(m), m = next);
  56 }
  57 void free_macros( void )
  58 {
  59         free_macro(MainMacro);
  60         free_macro(MacCur);
  61 }
  62
  63 /*** Start recording keystrokes ***/
  64 void start_macro( void )
  65 {
  66         if(OldInfo == NULL)
  67         {
  68                 /* Show a special msg in info template to show reccording state */
  69                 free_macro(MacCur);
  70                 OldInfo  = InfoTmpl;
  71                 InfoTmpl = NewTmpl;
  72                 TmplWid  = TextLength(prefs.backdrop ? &Scr->RastPort : &RPT, NewTmpl, TmplLen);
  73                 record   = 0x81;
  74                 MacCur   = LastChunk = NULL;
  75                 gui.xinfo -= TmplWid;
  76                 ThrowError(Wnd, ErrMsg(WARN_RECORD));
  77                 draw_info( edit );
  78         }
  79 }
  80
  81 void stop_macro( void )
  82 {
  83         if(OldInfo != NULL)
  84         {
  85                 InfoTmpl = OldInfo; OldInfo = NULL;
  86                 record   = FALSE;
  87                 gui.xinfo += TmplWid;
  88                 /* Do not save something if nothing has been recorded */
  89                 if(MacCur != NULL) {
  90                         free_macro( MainMacro ); MainMacro = MacCur; MacCur = NULL;
  91                         ThrowError(Wnd, ErrMsg(WARN_RECORDED));
  92                 }
  93                 else UpdateTitle(Wnd, edit);
  94         }
  95 }
  96
  97 /** Alloc a new chunk for recording keystroke **/
  98 void *new_action( UWORD size )
  99 {
 100         if(LastChunk == NULL || LastChunk->usage + size > SZ_MACRO)
 101         {
 102                 Macro new;
 103                 /* Alloc a new chunk, not enough room */
 104                 if(NULL == (new = (Macro) AllocVec(sizeof(*new), MEMF_CLEAR)))
 105                         return NULL;
 106
 107                 if(LastChunk) LastChunk->next = new;
 108                 else MacCur = new;  LastChunk = new;
 109                 new->usage = size;
 110                 return new->data;
 111         }
 112         else /* Still some place in current chunk */
 113         {
 114                 STRPTR new = LastChunk->data + LastChunk->usage;
 115                 LastChunk->usage += size;
 116                 return new;
 117         }
 118 }
 119
 120 /** Register actions **/
 121 void reg_act_addchar( UBYTE code )
 122 {
 123         ActChar new;
 124         if( ( new = new_action( sizeof(*new) ) ) )
 125                 new->Type = MAC_ACT_ADD_CHAR, new->Char = code;
 126 }
 127 void reg_act_com( UBYTE type, UWORD code, UWORD qual )
 128 {
 129         ActMenu new;
 130         if( ( new = new_action( sizeof(*new) ) ) )
 131                 new->Type = type, new->Code = code, new->Qual = qual;
 132 }
 133
 134 /** Play current macro **/
 135 void play_macro( int nb_times )
 136 {
 137         extern struct IntuiMessage msgbuf;
 138         WORD selmask, txtmask;
 139         Macro m;
 140
 141         if(MainMacro == NULL) return;
 142
 143         /* Disconnect display, just to be clean, not for performance */
 144         inv_curs(edit, FALSE);
 145         RP->Mask = 0; RPT.Mask = 0;
 146         selmask  = gui.selmask; gui.selmask = 0;
 147         txtmask  = gui.txtmask; gui.txtmask = 0;
 148         record   = 2;
 149
 150         while( nb_times -- )
 151         {
 152                 for(m = MainMacro; m; m = m->next)
 153                 {
 154                         STRPTR op, eoc;
 155                         for(eoc = (op = m->data) + m->usage; op < eoc; op += SzOp[*op])
 156                                 switch( *op )
 157                                 {
 158                                         case MAC_ACT_ADD_CHAR:
 159                                                 if( add_char(&edit->undo, edit->edited, edit->nbc, ((ActChar)op)->Char) )
 160                                                 {
 161                                                         REDRAW_CURLINE(edit);
 162                                                         curs_right(edit, FALSE);
 163                                                 }       break;
 164                                         case MAC_ACT_COM_MENU:
 165                                                 msgbuf.Qualifier = ((ActMenu)op)->Qual;
 166                                                 handle_menu( ((ActMenu)op)->Code ); break;
 167                                         case MAC_ACT_SHORTCUT:
 168                                                 msgbuf.Qualifier = ((ActShortcut)op)->Qual;
 169                                                 msgbuf.Code      = ((ActShortcut)op)->Code;
 170                                                 handle_kbd(edit); break;
 171                                 }
 172                 }
 173         }
 174         /* Now we can show changes */
 175         gui.selmask = selmask;
 176         gui.txtmask = txtmask;
 177         RP->Mask = (edit->ccp.select ? selmask : txtmask);
 178         RPT.Mask = 0xff;
 179         record   = 0;
 180         redraw_content(edit, edit->show, gui.topcurs, gui.nbline);
 181         prop_adj( edit );
 182         inv_curs(edit,TRUE);
 183 }
 184
 185 void repeat_macro( Project p )
 186 {
 187         LONG nb;
 188
 189         if( MainMacro && get_number(p, GetMenuText(404), &nb) )
 190                 play_macro( nb );
 191 }
 192
 193 #if     0
 194 /** Select other slot **/
 195 void new_slot( BYTE dir )
 196 {
 197         Macro *m = MacTable + CurInd - 1, *last = m;
 198
 199         for(;;) {
 200                 if(dir < 0) m--; else m++;
 201                 if(m <  MacTable)         m = MacTable + MAX_MAC;
 202                 if(m >= MacTable+MAX_MAC) m = MacTable;
 203                 if(last == m || *m != NULL) break;
 204         }
 205         CurInd = m - MacTable + 1;
 206
 207         ThrowError(Wnd, my_SPrintf(*m ? ErrMsg(WARN_SLOT) : ErrMsg(WARN_EMPTYSLOT), &CurInd));
 208 }
 209 #endif
 210