home *** CD-ROM | disk | FTP | other *** search
/ M.u.C.S. Disc 2000 / MUCS2000.iso / anwend / qed453 / src / makro.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-11-09  |  10.1 KB  |  504 lines
  1. #include <support.h>
  2.  
  3. #include "global.h"
  4. #include "clipbrd.h"
  5. #include "icon.h"
  6. #include "memory.h"
  7. #include "menu.h"
  8. #include "rsc.h"
  9. #include "text.h"
  10. #include "window.h"
  11. #include "makro.h"
  12.  
  13. extern bool f_to_desk;
  14.  
  15. /* exportierte Variablen *******************************************************/
  16. bool    makro_play, makro_rec;
  17. bool    makro_shift;
  18.  
  19.  
  20. /*******************************************************************************/
  21. #define MAKRO_PLAY_LEN 100                /* Makrolen expanded */
  22. #define MAKRO_DEF_LEN  100                /* einzelne Makrolänge */
  23.  
  24. #define UNUSED    0                            /* Werte für mode */
  25. #define TASTEN    1
  26. #define BLOCK    2
  27.  
  28. /*******************************************************************************/
  29. typedef struct 
  30. {
  31.     int        mode;
  32.     int        len;
  33.     int        key;            /* F1 .. F20 */
  34.     char        name[10];
  35.     union
  36.     {
  37.         unsigned int    tasten[MAKRO_DEF_LEN];
  38.         RING                text;
  39.     } daten;
  40. } MAKRO;
  41.  
  42. /* lokale Variablen ************************************************************/
  43. static unsigned int    makro_puffer[MAKRO_PLAY_LEN],
  44.                             *makro_ptr, *makro_end;
  45. static MAKRO            makro_list[MAKRO_ANZ],
  46.                             *makro_rec_ptr,
  47.                             *makro_play_ptr;
  48. static int                makro_play_counter;
  49.  
  50.  
  51. bool from_makro(int *kstate, int *kreturn)
  52. {
  53.     if (makro_play)                                /* Macro abspielen */
  54.     {
  55. retry:
  56.         if (makro_ptr < makro_end)
  57.         {
  58.             norm_to_gem(*makro_ptr, kstate, kreturn);
  59.             makro_ptr++;
  60.             makro_shift = *kstate;
  61.             return TRUE;
  62.         }
  63.         else                                            /* Abspielen beenden */
  64.         {
  65.             if (makro_play_counter > 1)
  66.             {
  67.                 makro_play = FALSE;
  68.                 start_play(makro_play_ptr->key, makro_play_counter-1);
  69.                 goto retry;
  70.             }
  71.             else
  72.                 end_play();
  73.         }
  74.     }
  75.     return FALSE;
  76. }
  77.  
  78. void to_makro(int kstate, int kreturn)
  79. {
  80.     if (makro_rec && !makro_play)                /* Zeichen erfassen */
  81.                                                         /* wenn echtes Zeichen */
  82.     {
  83.         int pos = makro_rec_ptr->len;
  84.         
  85.         if (pos < MAKRO_DEF_LEN)
  86.         {
  87.             makro_rec_ptr->daten.tasten[pos] = gem_to_norm(kstate, kreturn);
  88.             makro_rec_ptr->len++;
  89.         }
  90.         else
  91.             Bconout(2, 7);
  92.     }
  93. }
  94.  
  95. void start_blk_rec(char *name, int key, RINGP r)
  96. {
  97.     int    new, i;
  98.     MAKRO    *m;
  99.  
  100.     new = -1;
  101.     m = makro_list;
  102.     for (i=0; i<MAKRO_ANZ; i++,m++)            /* Eintrag suchen */
  103.     {
  104.         if (m->mode==UNUSED)                        /* Leerer Eintrag */
  105.             new = i;
  106.         else if (m->key == key)                    /* Alten Eintrag überschreiben */
  107.         {
  108.             new = i;
  109.             break;
  110.         }
  111.     }
  112.     if (new >- 1)
  113.     {
  114.         m = makro_list+new;
  115.         if (m->mode == BLOCK)
  116.             free_textring(&m->daten.text);
  117.         else
  118.             init_textring(&m->daten.text);
  119.         m->len = 0;                                /* leeren */
  120.         m->mode = BLOCK;
  121.         m->key = key;
  122.         doppeln(r,&m->daten.text);
  123.         strcpy(m->name,name);
  124.     }
  125. }
  126.  
  127.  
  128. void start_rec(void)
  129. {
  130.     int    new, i;
  131.     MAKRO    *m;
  132.  
  133.     if (makro_rec_ptr!=NULL)
  134.     {
  135.         m = makro_rec_ptr;
  136.         if (m->key == -1)
  137.             m->key = UNUSED;
  138.         makro_rec_ptr = NULL;
  139.     }
  140.     new = -1;
  141.     m = makro_list;
  142.     for (i = 0; i < MAKRO_ANZ; i++,m++)            /* leeren Eintrag suchen */
  143.     {
  144.         if (m->mode == UNUSED)
  145.         {
  146.             new = i;
  147.             break;
  148.         }
  149.     }
  150.     if (new > -1)                                    /* Gefunden */
  151.     {
  152.         m = &makro_list[new];
  153.         makro_rec = TRUE;                            /* Zeichen erfassen */
  154.         makro_rec_ptr = m;
  155.         m->len = 0;                                    /* leeren */
  156.         m->key = -1;
  157.         m->name[0] = EOS;
  158.         print_headline("Makro-Rec");
  159.         menu_text(menu, MSRECORD, rsc_string(MSTOPSTR));
  160.     }
  161. }
  162.  
  163.  
  164. void end_rec(bool one_more)
  165. {
  166.     int len = makro_rec_ptr->len;
  167.  
  168.     makro_rec = FALSE;
  169.     if (len>1)
  170.     {
  171.         if (one_more)
  172.             makro_rec_ptr->len--;                    /* letztes ^M raus */
  173.         makro_rec_ptr->mode = TASTEN;                /* Makro ist O.K. */
  174.     }
  175.     else
  176.         makro_rec_ptr = NULL;
  177.     print_headline("");
  178.     menu_text(menu, MSRECORD, rsc_string(MRECSTR));
  179. }
  180.  
  181.  
  182. bool start_play(int key, int anz)
  183. {
  184.     int    i;
  185.     MAKRO    *m;
  186.     bool    ret = FALSE;
  187.  
  188.     if (key == -1)                /* aktuelles Makro */
  189.     {
  190.         m = makro_rec_ptr;
  191.         if (m == NULL)
  192.         {
  193.             Bconout(2, 7);
  194.             return FALSE;
  195.         }
  196.     }
  197.     else                            /* Funktionstaste */
  198.     {
  199.         m = makro_list;
  200.         for (i=0; i<MAKRO_ANZ; i++,m++)            /* Eintrag suchen */
  201.             if (m->mode!=UNUSED && m->key==key)
  202.                 break;
  203.         if (i == MAKRO_ANZ)
  204.         {
  205.             if (!f_to_desk)                        /* Ping nur, wenn nicht an AV-Server */
  206.                 Bconout(2, 7);
  207.             return FALSE;
  208.         }
  209.     }
  210.     if (m->mode == TASTEN)                        /* Eintrag gefunden */
  211.     {
  212.         if (!makro_play)                            /* Neues M. starten */
  213.         {
  214.             memcpy(makro_puffer, m->daten.tasten, m->len * (int) sizeof(unsigned int));
  215.             makro_end = makro_puffer+m->len;
  216.             makro_ptr = makro_puffer;
  217.             makro_play = TRUE;
  218.             makro_play_ptr = m;
  219.             makro_play_counter = max(1,anz);
  220.             print_headline("Makro-Play");
  221.             ret = TRUE;
  222.         }
  223.         else                                            /* Makro ruft Makro auf */
  224.         {
  225.             int len_old = (int) (makro_end - makro_ptr);
  226.             int len_new = m->len;
  227.             if (len_old+len_new < MAKRO_PLAY_LEN)
  228.             {
  229.                 /* Alten Rest nach hinten verschieben */
  230.                 memmove(&makro_puffer[len_new],makro_ptr, len_old * (int) sizeof(unsigned int));
  231.                 /* Neues Makro einfügen */
  232.                 memcpy(makro_puffer,m->daten.tasten,m->len * (int) sizeof(unsigned int));
  233.                 makro_end = makro_puffer+(len_old+len_new);
  234.                 makro_ptr = makro_puffer;
  235.                 ret = TRUE;
  236.             }
  237.             else
  238.                 Bconout(2, 7);
  239.         }
  240.     }
  241.     else if(m->mode==BLOCK && !makro_rec && !makro_play)
  242.     {
  243.         RING t;
  244.  
  245.         init_textring(&t);
  246.         doppeln(&m->daten.text,&t);
  247.         clip_takes_text(&t);
  248.         do_action(DO_PASTE);
  249.         ret = TRUE;
  250.     }
  251.     else                                                /* Kein Eintrag gefunden */
  252.         Bconout(2, 7);
  253.     return ret;
  254. }
  255.  
  256. void end_play(void)
  257. {
  258.     if (makro_play)
  259.     {
  260.         makro_play = FALSE;
  261.         makro_play_ptr = NULL;
  262.         print_headline("");
  263.     }
  264. }
  265.  
  266. void del_makro(int key)
  267. {
  268.     MAKRO    *m;
  269.     int    i;
  270.  
  271.     m = makro_list;
  272.     for (i = 0; i < MAKRO_ANZ; i++,m++)
  273.     {
  274.         if (m->mode != UNUSED && m->key == key)
  275.         {
  276.             if (makro_rec_ptr != NULL && makro_rec_ptr == m)
  277.                 m->key = -1;
  278.             else
  279.             {
  280.                 if (m->mode == BLOCK)
  281.                     kill_textring(&m->daten.text);
  282.                 m->mode = UNUSED;
  283.             }
  284.             break;
  285.         }
  286.     }
  287. }
  288.  
  289.  
  290. /*
  291.  * Makro-String aus CFG in Puffer wandeln.
  292. */
  293. void set_makro_str(char *ptr)
  294. {
  295.     char        *p;
  296.     int        i, l;
  297.         
  298.     if (*ptr == '"')
  299.     {
  300.         for (i = 0; i < MAKRO_ANZ; i++)        /* leeren Eintrag suchen */
  301.             if (makro_list[i].mode == UNUSED)
  302.                 break;
  303.  
  304.         if (i >= 0)
  305.         {
  306.             ptr += 1;                        /* " überspringen */
  307.             p = strchr(ptr, '"');
  308.             *p = EOS;
  309.             strcpy(makro_list[i].name, ptr);
  310.             ptr = p + 2;                    /* ", überspringen */
  311.             
  312.             p = strchr(ptr, ',');
  313.             *p = EOS;
  314.             makro_list[i].key = (int)strtol(ptr, NULL, 16);
  315.             makro_list[i].mode = TASTEN;
  316.     
  317.             ptr = p + 1;
  318.             l = 0;
  319.             while (ptr)
  320.             {
  321.                 p = strchr(ptr, ',');
  322.                 if (p)
  323.                     *p = EOS;
  324.                 makro_list[i].daten.tasten[l] = (int)strtol(ptr, NULL, 16);
  325.                 l++;
  326.                 if (p == NULL)
  327.                     ptr = NULL;
  328.                 else
  329.                     ptr = p + 1;
  330.             }
  331.             makro_list[i].len = l;
  332.         }
  333.     }
  334. }
  335.  
  336.  
  337. /*
  338.  * Puffer in Makro-String für CFG wandeln.
  339. */
  340. bool get_makro_str(int nr, char *ptr)
  341. {
  342.     char    s[5];
  343.     int    j;
  344.  
  345.     if (makro_list[nr].mode == TASTEN)
  346.     {
  347.         sprintf(ptr, "\"%s\",%X", makro_list[nr].name, makro_list[nr].key);
  348.         for (j = 0; j < makro_list[nr].len; j++)
  349.         {
  350.             sprintf(s, ",%X", makro_list[nr].daten.tasten[j]);
  351.             strcat(ptr, s);
  352.         }
  353.         return TRUE;
  354.     }
  355.     return FALSE;
  356. }
  357.  
  358.  
  359. void init_makro(void)
  360. {
  361.     int    i;
  362.  
  363.     makro_play = makro_rec = FALSE;
  364.     for (i = 0; i < MAKRO_ANZ; i++)
  365.         makro_list[i].mode = UNUSED;
  366.     makro_rec_ptr = NULL;
  367.     makro_play_ptr = NULL;
  368. }
  369.  
  370.  
  371. /***************************************************************************/
  372. /* Dialog ******************************************************************/
  373. /***************************************************************************/
  374.  
  375. static void makro_on_key(char *name, int key)
  376. {
  377.     MAKRO    *m;
  378.  
  379.     if (makro_rec_ptr!=NULL)
  380.     {
  381.         del_makro(key);
  382.         m = makro_rec_ptr;
  383.         makro_rec_ptr = NULL;
  384.         m->key = key;
  385.         strcpy(m->name, name);
  386.     }
  387. }
  388.  
  389.  
  390. static void get_makro_name(int scan, char *name)
  391. {
  392.     int    i;
  393.     MAKRO    *m;
  394.  
  395.     *name = EOS;
  396.     m = makro_list;
  397.     for (i = MAKRO_ANZ; (--i) >= 0; m++)
  398.         if (m->mode != UNUSED && m->key == scan)
  399.         {
  400.             strcpy(name, m->name);
  401.             break;
  402.         }
  403. }
  404.  
  405.  
  406. static void show_makro(int nr, MDIAL *mdial)
  407. {
  408.     char    name[9];
  409.  
  410.     if (nr < 10)
  411.         get_makro_name(0x3B00 + (nr * 0x100), name);
  412.     else
  413.         get_makro_name(0x5400 + ((nr - 10) * 0x100), name);
  414.  
  415.     set_string(funktionstasten, FNNAME, name);
  416.     set_state(funktionstasten, FNDELETE, DISABLED, (name[0] == EOS));
  417.     if (mdial != NULL)
  418.     {
  419.         redraw_mdobj(mdial, FNNAME);
  420.         redraw_mdobj(mdial, FNDELETE);
  421.     }
  422. }
  423.  
  424. void makro_dial(void)
  425. {
  426.     int    antw;
  427.     char    name[9];
  428.     MDIAL    *dial;
  429.     bool    close = FALSE;
  430.     int    y, makro_nr = 0;
  431.         
  432.     save_clip();
  433.  
  434.     set_state(funktionstasten, FNBLOCK, DISABLED, ist_leer(&clip_text));
  435.     set_string(funktionstasten, FNKEY, " F1");
  436.     show_makro(makro_nr, NULL);
  437.  
  438.     dial = open_mdial(funktionstasten, FNNAME);
  439.     if (dial != NULL)
  440.     {
  441.         while (!close)
  442.         {
  443.             antw = do_mdial(dial) & 0x7fff;
  444.             switch (antw)
  445.             {
  446.                 case FNSTR :
  447.                 case FNKEY :
  448.                     if (antw == FNKEY)
  449.                         y = handle_popup(funktionstasten, FNKEY, popups, FUNCPOP, POP_OPEN);
  450.                     else
  451.                         y = handle_popup(funktionstasten, FNKEY, popups, FUNCPOP, POP_CYCLE);
  452.                     if (y > 0)
  453.                     {
  454.                         makro_nr = y - POPF1;
  455.                         show_makro(makro_nr, dial);
  456.                     }
  457.                     break;
  458.         
  459.                 case FNDELETE:
  460.                     if (makro_nr < 10)
  461.                         del_makro(0x3B00 + (makro_nr * 0x100));
  462.                     else
  463.                         del_makro(0x5400 + ((makro_nr - 10) * 0x100));
  464.                     set_state(funktionstasten, antw, SELECTED, FALSE);
  465.                     show_makro(makro_nr, dial);
  466.                     break;
  467.         
  468.                 case FNRECORD:
  469.                 case FNBLOCK:
  470.                     get_string(funktionstasten, FNNAME, name);
  471.                     if (*name == EOS)
  472.                     {
  473.                         set_state(funktionstasten, antw, SELECTED, FALSE);
  474.                         note(1, 0, MKNAME);
  475.                         redraw_mdobj(dial, 0);
  476.                     }
  477.                     else
  478.                         close = TRUE;
  479.                     break;
  480.         
  481.                 default:
  482.                     close = TRUE;
  483.                     break;
  484.             }
  485.         }
  486.         close_mdial(dial);
  487.         set_state(funktionstasten, antw, SELECTED, FALSE);
  488.         if (antw == FNRECORD)
  489.         {
  490.             if (makro_nr < 10)
  491.                 makro_on_key(name, 0x3B00 + (makro_nr * 0x100));
  492.             else
  493.                 makro_on_key(name, 0x5400 + ((makro_nr - 10) * 0x100) );
  494.         }
  495.         if (antw == FNBLOCK)
  496.         {
  497.             if (makro_nr < 10)
  498.                 start_blk_rec(name, 0x3B00 + (makro_nr * 0x100), &clip_text);
  499.             else
  500.                 start_blk_rec(name, 0x5400 + ((makro_nr - 10) * 0x100), &clip_text);
  501.         }
  502.     }
  503. }
  504.