home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / PAPILL22.LZH / PAPILLON / BSPMODUL / BEISPIEL.C / BEISPIEL
Text File  |  1994-11-07  |  15KB  |  494 lines
  1. /* ============================================================= */
  2. /* BEISPIEL.C von Dirk Sabiwalsky 8/93 (Tabulator 5)            */
  3. /* ------------------------------------------------------------- */
  4. /* Ein beispielhaftes Papillon-Modul zum Invertieren des selek-    */
  5. /* tierten Blocks                                        */
  6. /* ------------------------------------------------------------- */
  7. /* Lassen Sie sich nicht durch die Länge dieser C-Quelle        */
  8. /* entmutigen. Im Prinzip ist's ganz einfach! Das einzig        */
  9. /* problematische sind eventuell die eingeschränkten AES-        */
  10. /* aufrufe (nur die Funktionen, für die hier unten auch        */
  11. /* ein Makro angegeben ist, dürfen verwendet werden). An-        */
  12. /* sonsten kann man wie gewohnt GEM-Dialoge programmieren.        */
  13. /* Allerdings müssen wir uns Event- und Fenster-Aufrufe hier    */
  14. /* verkneifen, weil das Protokoll einen gemeinsamen Modul-        */
  15. /* und Papillon-Redraws doch etwas ZU knifflig werden            */
  16. /* würde. Aber die bereitgestellten AES-Routinen sollten schon    */
  17. /* für Radiobuttons, Slider, Dialoge etc. ausreichen, oder?     */
  18. /* ------------------------------------------------------------- */
  19. /* Viel Spa₧ beim Programmieren eigener Module wünschen Ihnen    */
  20. /* Stefan Becker und Dirk Sabiwalsky                        */
  21. /* ============================================================= */
  22.  
  23. /* -------- */
  24. /* Includes */
  25. /* -------- */
  26.  
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <vdi.h>
  30. #include <aes.h>        /* NUR für Prototypen! AES-Calls sind NUR */
  31.                     /* über die Funktionszeiger im Parameterblock */
  32.                     /* erlaubt! */
  33.  
  34. #include "beispiel.h"
  35. #include "beispiel.rsh"    /* decompiliertes Resource */
  36.  
  37. #include "pap_mod.h"    /* Typen für Papillon-Datenstrukturen */
  38.  
  39. /* ---------- */
  40. /* Konstanten */
  41. /* ---------- */
  42.  
  43. #define TRUE    1
  44. #define FALSE    0
  45.  
  46. /* ------ */
  47. /* Makros */
  48. /* ------ */
  49.  
  50. #define ABS(x)     (((x)>0) ? (x) : (-(x)))
  51. #define MAX(x,y)    (((x)>(y)) ? (x) : (y))
  52. #define MIN(x,y)    (((x)<(y)) ? (x) : (y))
  53.  
  54. /* ---------- */
  55. /* Prototypen */
  56. /* ---------- */
  57.  
  58. void cdecl do_module_job(void);   /* damit Konstantendeklaration unten möglich */
  59.  
  60. /* -------- */
  61. /* Variable */
  62. /* -------- */
  63.  
  64. int    vdi_handle,    /* Handle der VDI-Arbeitsstation */
  65.     cb,ch;        /* Breite und Höhe eines Systemfont-Buchstabens */
  66.  
  67. /* ----------------------- */
  68. /* Papillon-Parameterblock */
  69. /* ----------------------- */
  70.  
  71. /* Den Papillon-Parameterblock NICHT umbenennen, weil sonst die */
  72. /* Zugriffsmakros nicht mehr funktionieren würden! */
  73. /* Es darf nur einen solchen Parameterblock im Modul geben! */
  74.  
  75. EXTPAP_PARMS par = {
  76.                     MOD_MAGIC,    /* magic: Magic, welches Papillon sucht, */
  77.                                 /* um den Parameterblock zu finden */
  78.  
  79.                     /* die folgenden Werte trägt Papillon ein, bevor */
  80.                     /* er das Modul startet */
  81.  
  82.                     0,            /* pap_vers: Papillon-Version */
  83.                     0,            /* appl_id: Applikations-ID */
  84.                     0,            /* vdi_handle: Handle einer VDI-Arbeitsstation */
  85.                     0,            /* char_width: Breite eines Systemfont-Buchstabens */
  86.                     0,            /* char_height: Höhe eines Systemfont-Buchstabens */
  87.                     0,            /* sys_planes: Anzahl der auf dem Monitor verfügbaren Farbebenen */
  88.                     NULL,        /* fsel_path: Zeiger auf aktuellen Fileselektor-Pfad */
  89.                     NULL,        /* in_pic_bm: Zeiger auf Eingabebild */
  90.                     NULL,        /* in_blk_bm: Zeiger auf Eingabeblock */
  91.                     NULL,        /* in_blk_msk: Zeiger auf die Maske zum Eingabeblock (kann NULL sein!) */
  92.                     NULL,        /* pic_name: Zeiger auf den Namen einer Bilddatei, */
  93.                                 /* die das Modul laden soll (für Module, die keine */
  94.                                 /* Eingabe erhalten und neue Bilder liefern und sich */
  95.                                 /* in <file_ext> für einen Bildtyp verantwortlich erklärt */
  96.                                 /* haben */
  97.  
  98.                     /* allgemeine Funktionszeiger */
  99.  
  100.                     NULL,        /* pap_new_pic */
  101.                     NULL,        /* pap_free_pic */
  102.                     NULL,        /* pap_malloc */
  103.                     NULL,        /* pap_calloc */
  104.                     NULL,        /* pap_free */
  105.                     NULL,        /* pap_alert */
  106.  
  107.                     /* AES-Funktionszeiger */
  108.  
  109.                     NULL,        /* pap_form_center */
  110.                     NULL,        /* pap_form_dial */
  111.                     NULL,        /* pap_objc_draw */
  112.                     NULL,        /* pap_form_do */
  113.                     NULL,        /* pap_rsrc_obfix */
  114.                     NULL,        /* pap_graf_mkstate */
  115.                     NULL,        /* pap_objc_offset */
  116.                     NULL,        /* pap_graf_slidebox */
  117.                     NULL,        /* pap_appl_find */
  118.                     NULL,        /* pap_appl_read */
  119.                     NULL,        /* pap_appl_write */
  120.                     NULL,        /* pap_graf_mouse */
  121.                     NULL,        /* pap_fsel_input */
  122.                     NULL,        /* pap_fsel_exinput */
  123.  
  124.                     /* USERDEF-Routinen für Checkboxen, Radiobuttons */
  125.                     /* und unterstrichenen Text */
  126.  
  127.                     NULL,        /* pap_init_userdefs */
  128.                     NULL,        /* pap_forget_userdefs */
  129.  
  130.                     /* reservierte Bytes */
  131.  
  132.                     "",            /* res1 */
  133.  
  134.                     /* die folgenden Werte sind modulspezifisch, also */
  135.                     /* bitte selbst eintragen! */
  136.  
  137.                     {
  138.                         0x00,0x00,0x03,0x00,0x00,0x00,0x05,0x80,0x00,0x00,0x0B,0x80,0x00,0x1C,0x17,0x00,
  139.                         0x00,0x12,0x2E,0x00,0x00,0x19,0x5C,0x00,0x00,0x14,0xB8,0x06,0x00,0x22,0x70,0x0B,
  140.                         0x00,0x41,0x20,0x17,0x00,0x80,0x90,0x2E,0x01,0x00,0x48,0x5C,0x02,0x00,0x24,0xB8,
  141.                         0x04,0x00,0x13,0x70,0x04,0x00,0x09,0xE0,0x04,0x00,0x04,0xC0,0x04,0x00,0x02,0x40,
  142.                         0x04,0x00,0x01,0x20,0x04,0x00,0x00,0x90,0x04,0x00,0x01,0x50,0x04,0x00,0x02,0xF0,
  143.                         0x04,0x00,0x05,0xE0,0x04,0x00,0x0B,0x00,0x08,0x00,0x16,0x00,0x10,0x7F,0xEC,0x00,
  144.                         0x20,0x80,0x18,0x00,0x41,0x7F,0xF0,0x00,0x82,0xFF,0xE0,0x00,0x85,0x80,0x00,0x00,
  145.                         0x4B,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  146.                     },            /* mod_icon: das Icon des Moduls (schwarz/wei₧, 32 * 32 Pixel) */
  147.  
  148.                     "Invertieren", /* mod_name: der Name des Moduls */
  149.  
  150.                     "",            /* file_ext: hier trägt man den Dateityp ein, den das Modul */
  151.                                 /* laden kann (z.B. "IMG" für GEM-Image-Bilder) */
  152.                                 /* <mod_gets> mu₧ dann M_GETS_NIX und <mod_sends> mu₧ M_SENDS_PIC */
  153.                                 /* sein. */
  154.                                 /* in <pic_name> liefert Papillon dann den kompletten Namen */
  155.                                 /* der zu ladenden Bilddatei */
  156.  
  157.                     M_GETS_BLOCK,    /* mod_gets: was erhält das Modul vom Papillon? (hier: einen Block) */
  158.                     M_SENDS_BLOCK, /* mod_sends: was liefert das Modul zurück? (hier: einen Block) */
  159.  
  160.                     /* hier werden die Ausgabedaten eingetragen */
  161.                     /* !Achtung! ALLE Ausgabebitmaps müssen vom Modul allokiert werden! */
  162.                     /* das Modul darf KEINE Eingabebitmaps freigeben oder als Ausgabebitmap verwenden! */
  163.                     
  164.                     NULL,        /* out_pic_bm: dieses Bild liefert das Modul */
  165.                     NULL,        /* out_blk_bm: diesen Block liefert das Modul */
  166.                     NULL,        /* out_blk_mask: diese Maske liefert das Modul (kann auch NULL sein!) */
  167.  
  168.                     do_module_job, /* do_job: Verweis auf die Modul-Hauptroutine */
  169.                     0,            /* erg_code: Ergebniscode des Moduls */
  170.                                 /* (erg_code<=0 bedeutet Fehler, erg_code>0 alles OK) */
  171.  
  172.                     /* reservierte Bytes */
  173.                     ""            /* res2 */
  174.                 };
  175.  
  176. /* ------------------------- */
  177. /* Hilfsroutinen für Dialoge */
  178. /* ------------------------- */
  179.  
  180. int get_objflags(OBJECT *ob, int item)
  181. {
  182.     return(ob[item].ob_flags);
  183. }
  184.  
  185. void set_objflag(OBJECT *ob, int item, int flag)
  186. {
  187.     ob[item].ob_flags|=flag;
  188. }
  189.  
  190. void clear_objflag(OBJECT *ob, int item, int flag)
  191. {
  192.     ob[item].ob_flags&=~flag;
  193. }
  194.  
  195. int get_objstate(OBJECT *ob, int item)
  196. {
  197.     return(ob[item].ob_state);
  198. }
  199.  
  200. void set_objstate(OBJECT *ob, int item, int state)
  201. {
  202.     ob[item].ob_state|=state;
  203. }
  204.  
  205. void clear_objstate(OBJECT *ob, int item, int state)
  206. {
  207.     ob[item].ob_state&=~state;
  208. }
  209.  
  210. void set_objselection(OBJECT *ob, int item, int flag)
  211. {
  212.     if(flag)
  213.     {
  214.         set_objstate(ob,item,SELECTED);
  215.     }
  216.     else
  217.     {
  218.         clear_objstate(ob,item,SELECTED);
  219.     }
  220. }
  221.  
  222. int object_selected(OBJECT *ob, int item)
  223. {
  224.     return(get_objstate(ob,item) & SELECTED);
  225. }
  226.  
  227. void enable_button(OBJECT *ob, int item)
  228. {
  229.     set_objflag(ob,item,SELECTABLE);
  230.     clear_objstate(ob,item,DISABLED);
  231. }
  232.  
  233. void disable_button(OBJECT *ob, int item)
  234. {
  235.     clear_objflag(ob,item,SELECTABLE);
  236.     set_objstate(ob,item,DISABLED);
  237. }
  238.  
  239. void get_objtext(OBJECT *ob, int item, char *s)
  240. {
  241.      switch(ob[item].ob_type & 0xff)
  242.      {
  243.           case G_USERDEF :    strcpy(s,(char*)ob[item].ob_spec.userblk->ub_parm);
  244.                               break;
  245.           case G_TEXT :
  246.           case G_BOXTEXT :
  247.           case G_FTEXT :
  248.           case G_FBOXTEXT :   strcpy(s,ob[item].ob_spec.tedinfo->te_ptext);
  249.                               break;
  250.           case G_BUTTON:
  251.           case G_STRING :
  252.           case G_TITLE :      strcpy(s,ob[item].ob_spec.free_string);
  253.                               break;
  254.      }
  255. }
  256.  
  257. void set_objtext(OBJECT *ob, int item, char *s)
  258. {
  259.      switch(ob[item].ob_type & 0xff)
  260.      {
  261.           case G_USERDEF :    strcpy((char*)ob[item].ob_spec.userblk->ub_parm,s);
  262.                               break;
  263.           case G_TEXT :
  264.           case G_BOXTEXT :
  265.           case G_FTEXT :
  266.           case G_FBOXTEXT :   strcpy(ob[item].ob_spec.tedinfo->te_ptext,s);
  267.                               break;
  268.           case G_BUTTON:
  269.           case G_STRING :
  270.           case G_TITLE :      strcpy(ob[item].ob_spec.free_string,s);
  271.                               break;
  272.      }
  273. }
  274.  
  275. /* ---------------------------------------------------------- */
  276. /* decompiliertes Resource an aktuelle die Auflösung anpassen */
  277. /* ---------------------------------------------------------- */
  278.  
  279. void init_rsc(void)
  280. {
  281.     int    i;
  282.  
  283.     for(i=0;i<NUM_OBS;i++)
  284.     {
  285.         rsrc_obfix(rs_object,i);
  286.     }
  287. }
  288.  
  289. void fix_pixels(int *coord,int this_size, int design_size)
  290. {
  291.     int    px;
  292.  
  293.     px=*coord>>8;
  294.     if(px)
  295.     {
  296.         px=px*this_size/design_size;
  297.         *coord=(*coord & 0xff) | (px<<8);
  298.     }
  299. }
  300.  
  301. void fix_koordinates(void)
  302. {
  303.     int        i;
  304.     OBJECT    *this_ob;
  305.     
  306.     for(i=0;i<NUM_OBS;i++)
  307.     {
  308.         this_ob=&rs_object[i];
  309.     
  310.         if(   this_ob>=TREE[1]
  311.            && (this_ob->ob_type & 0xff)!=G_IMAGE
  312.            && (this_ob->ob_type & 0xff)!=G_ICON)
  313.         {
  314.             fix_pixels(&(this_ob->ob_x),cb,8);
  315.             fix_pixels(&(this_ob->ob_y),ch,16);
  316.             fix_pixels(&(this_ob->ob_width),cb,8);
  317.             fix_pixels(&(this_ob->ob_height),ch,16);
  318.         }
  319.     }
  320. }
  321.  
  322. /* ----------------------- */
  323. /* eine Bitmap invertieren */
  324. /* ----------------------- */
  325.  
  326. void invert_plane(char *plane, long size)
  327. {
  328.     long    *lptr;
  329.     char    *cptr;
  330.     
  331.     lptr=(long*)plane;
  332.     while(size>sizeof(long)*8)
  333.     {
  334.         *lptr++ ^= 0xFFFFFFFFL;
  335.         *lptr++ ^= 0xFFFFFFFFL;
  336.         *lptr++ ^= 0xFFFFFFFFL;
  337.         *lptr++ ^= 0xFFFFFFFFL;
  338.         *lptr++ ^= 0xFFFFFFFFL;
  339.         *lptr++ ^= 0xFFFFFFFFL;
  340.         *lptr++ ^= 0xFFFFFFFFL;
  341.         *lptr++ ^= 0xFFFFFFFFL;
  342.  
  343.         size -= sizeof(long)*8;
  344.     }
  345.  
  346.     cptr=(char*)lptr;
  347.     while(size-- > 0)
  348.     {
  349.         *cptr++ ^= 0xFF;
  350.     }
  351. }
  352.  
  353. void invert_bitmap(C_BITMAP *bm)
  354. {
  355.     int    i;
  356.  
  357.     if(bm==NULL) return;
  358.     
  359.     for(i=0;i<bm->bm_planes;i++)
  360.     {
  361.         invert_plane(bm->bm_adr[i],(long)bm->bm_words * 2L * (long)bm->bm_height);
  362.     }
  363. }
  364.  
  365. /* --------------------------------------------------- */
  366. /* Modul-Hauptroutine (wird vom Papillon angesprungen) */
  367. /* --------------------------------------------------- */
  368.  
  369. void cdecl do_module_job(void)
  370. {
  371.     int        xd,yd,wd,hd,exit_obj;
  372.     C_BITMAP    *new_block=NULL,*new_mask=NULL;
  373.  
  374.     /* wurde vom Papillon ein Block übergeben? */
  375.     if(par.in_blk_bm==NULL)
  376.     {
  377.         alert("Dieses Modul benötigt einen selektierten Block als Eingabe!","Abbruch");
  378.         par.erg_code=-1;    /* Ergebniscode: Fehler */
  379.         return;            /* zurück zum Papillon */
  380.     }
  381.  
  382.     /* globale Variablen vorbelegen */
  383.     vdi_handle=par.vdi_handle;
  384.     cb=par.char_width;
  385.     ch=par.char_height;
  386.  
  387.     /* Resource an Auflösung anpassen */
  388.     init_rsc();
  389.     fix_koordinates();
  390.  
  391.     /* USERDEFS initialisieren (für Checkboxen, Radiobuttons, unterstrichenen Text) */
  392.     init_userdefs(rs_object,NUM_OBS);
  393.     
  394.     /* Maus auf Pfeil */
  395.     graf_mouse(ARROW,0);
  396.  
  397.     /* Dialog abarbeiten */
  398.      form_center(TREE[DMAIN],&xd,&yd,&wd,&hd);
  399.      form_dial(FMD_START,0,0,0,0,xd,yd,wd,hd);
  400.      objc_draw(TREE[DMAIN],0,MAX_DEPTH,xd,yd,wd,hd);
  401.      exit_obj=form_do(TREE[DMAIN],0) & 0x7fff;
  402.      clear_objstate(TREE[DMAIN],exit_obj,SELECTED);
  403.      form_dial(FMD_FINISH,0,0,0,0,xd,yd,wd,hd);
  404.  
  405.     /* was hat der User ausgewählt? */
  406.     if(exit_obj==RSD_CANCEL)
  407.     {
  408.         par.erg_code=0;                    /* Nix passiert! */
  409.         forget_userdefs(rs_object,NUM_OBS);    /* Userdefs wieder freigeben */
  410.         return;                            /* zurück zum Papillon */
  411.     }
  412.  
  413.     /* Maus auf Biene */
  414.     graf_mouse(BUSYBEE,0);
  415.     
  416.     /* einen neuen Block allokieren */
  417.     if(new_bitmap(&new_block,par.in_blk_bm->bm_width,par.in_blk_bm->bm_height,par.in_blk_bm->bm_planes,par.in_blk_bm->bm_colors,TRUE)<0)
  418.     {
  419.         /* Speichermangel! */
  420.         par.erg_code=-1;    /* Ergebniscode: Fehler */
  421.         return;            /* zurück zum Papillon */
  422.     }
  423.     
  424.     /* den alten Block in den neuen kopieren */
  425.     memcpy(new_block->bm_adr[0],
  426.           par.in_blk_bm->bm_adr[0],
  427.           (long)par.in_blk_bm->bm_words * 2L * (long)par.in_blk_bm->bm_height * (long)par.in_blk_bm->bm_planes);
  428.  
  429.     /* Wenn das Modul zum Block zusätzlich eine Maske als */
  430.     /* Eingabeparameter erhalten hat, wird auch eine Maske */
  431.     /* zurückgeliefert, die allerdings extra allokiert werden */
  432.     /* mu₧! */
  433.     
  434.     if(par.in_blk_msk!=NULL)    /* Maske da? */
  435.     {
  436.         /* neue Maske allokieren */
  437.         if(new_bitmap(&new_mask,par.in_blk_msk->bm_width,par.in_blk_msk->bm_height,1,NULL,TRUE)<0)
  438.         {
  439.             /* Speichermangel! */
  440.             par.erg_code=-1;    /* Ergebniscode: Fehler */
  441.             return;            /* zurück zum Papillon */
  442.         }
  443.  
  444.         /* die alte Maske in die neue kopieren */
  445.         memcpy(new_mask->bm_adr[0],
  446.               par.in_blk_msk->bm_adr[0],
  447.               (long)par.in_blk_msk->bm_words * 2L * (long)par.in_blk_msk->bm_height);
  448.     }
  449.     
  450.     /* den Block invertieren */
  451.     invert_bitmap(new_block);
  452.  
  453.     /* Maus auf Pfeil */
  454.     graf_mouse(ARROW,0);
  455.     
  456.     /* Ergebnisbitmaps des Moduls eintragen */
  457.     par.out_blk_bm = new_block;
  458.     par.out_blk_msk = new_mask;
  459.  
  460.     par.erg_code = 1;            /* Ergebniscode: alles klar! */
  461.  
  462.     /* RSC-Userdefs wieder freigeben */
  463.     forget_userdefs(rs_object,NUM_OBS);
  464. }
  465.  
  466. /* -------------------------------- */
  467. /* Hauptprogramm (NICHT verändern!) */
  468. /* -------------------------------- */
  469.  
  470. int main(void)
  471. {
  472.     int    niemals=FALSE;
  473.  
  474.     /* damit der Linker die Funktion <do_module_job> */
  475.     /* nicht kurzerhand rauswirft: */
  476.     
  477.     if(niemals)            /* Immer FALSE ;-) */
  478.     {
  479.         do_module_job();    /* Dummy-Call, der nie aufgerufen wird */
  480.     }
  481.     
  482.     /* eine Meldung ausgeben, falls das Modul irrtümlich gestartet wird */
  483.     
  484.     puts("\nPapillon-Module können nicht als eigenständige\n"
  485.         "Programme gestartet werden!\nBitte Taste drücken\n!");
  486.         
  487.     getchar();    /* Auf Tastendruck warten */
  488.     return(-1);    /* Auf Wiedersehen */
  489. }
  490.  
  491. /* =================== */
  492. /* Ende von BEISPIEL.C */
  493. /* =================== */
  494.