home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 092.lha / ColorFull / palette.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-21  |  16.8 KB  |  568 lines
  1. /***************************************************************************
  2. * palette.c  by: Keith Young                                      12/20/87
  3. *
  4. *   These routines were origionally written by: Charlie Heath of Microsmiths
  5. * (palette.c on Manx Aztec C examples disk) and were Heavily modified by me
  6. * ( Keith Young ) for use in my ShareWare terminal program: "Access!" and
  7. * then further modified for "portability" and infestation into the public.
  8. * (as FREEWARE).
  9. *  I'll not attemp to list all the modifications made (sounds to much like
  10. * work). Nor will I guarantee that they even work at all (but hey, they work
  11. * for me :-). 
  12. *
  13. *  You may Use these source files, modify 'em, throw 'em away, give 'em away,
  14. * without obligation. JUST DON'T SELL 'EM! (I doubt you'd get much anyway:-)
  15. * 
  16. *   If you do use 'em (in a noncomercial manner), I would appeciate a small
  17. * "mention" in the docs somewhere. (small print, lower left hand corner will
  18. * do )
  19. *  
  20. *  These routines now compile using AZTEC 3.4a using 16 bit ints.(horay!)
  21. * (see included makefile)
  22. *
  23. *   Any bug reports/suggestions/fixes/etc... would be appreciated.
  24. * 
  25. *   I can be reached at:              (703) 297-7639
  26. *
  27. * via    E-MAIL->  GEnie: K.Young
  28. *                 CA-AUG: Keith Young
  29. *           Deep Thought: Keith Young
  30. *             COMPUSERVE: 73170,307
  31. *
  32. * via Snail-Mail-> Keith Young
  33. *                  Rt.2 Box 261
  34. *                  Goodview, Va.   (yes, really :-)
  35. *                           24095
  36. *  
  37. ***************************************************************************/
  38.  
  39. #include "standard.h"
  40. #include <stdio.h>
  41.  
  42. #define FAST register       /* Register type variable  */
  43. #define CTSIZ  8L           /* Color table size   */
  44. #define PLX 230L            /* Palette Window Size  */
  45. #define PLY 95L
  46. #define PGAD 0L             /* You can offset the gadgets here  */
  47. #define PGHI PGAD+CTSIZ     /* Offset frm color selectors       */
  48.  
  49. extern struct Window       *OpenWindow();
  50. extern struct IntuiMessage *GetMsg();
  51.  
  52. /* these are "included" into "getfile.c" currently... */
  53. extern struct Image        okupImage,okdnImage,canupImage,candnImage,
  54.                            reupImage,rednImage,ldupImage,lddnImage,
  55.                            svupImage,svdnImage;
  56.  
  57. extern UBYTE  *get_fname();
  58. extern UBYTE  *prep_file();
  59.  
  60. static struct IntuiText rtxt = {3,2,JAM1,-10,2,NULL,(UBYTE *)"R",NULL};
  61. static struct IntuiText gtxt = {6,2,JAM1,-10,2,NULL,(UBYTE *)"G",NULL};
  62. static struct IntuiText btxt = {7,2,JAM1,-10,2,NULL,(UBYTE *)"B",NULL};
  63.  
  64. static char frog[] = "hex";
  65. static struct IntuiText hxtxt = {3,2,JAM2,180,19,NULL,(UBYTE *)frog,NULL};
  66. static char hxtab[16] = { '0','1','2','3','4','5','6','7',
  67.                           '8','9','a','b','c','d','e','f' };
  68.  
  69. static struct Image    r_img, g_img, b_img; 
  70. static struct PropInfo r_prop,g_prop,b_prop;
  71.  
  72.  
  73. /* border around color gadgets */
  74.  
  75. static SHORT oXY[] = {
  76.     0,0,
  77.     155,0,
  78.     155,21,
  79.     0,21,
  80.     0,0,
  81. };
  82.  
  83. static struct Border cbdr = {
  84.     0,0,
  85.     0,0,JAM1,
  86.     5,
  87.     oXY,
  88.     NULL
  89. };
  90.  
  91. /* border around selected color image */
  92.  
  93. static SHORT oXY1[] = {
  94.     0,0,
  95.     52,0,
  96.     52,21,
  97.     0,21,
  98.     0,0
  99. };
  100.  
  101. static struct Border sbdr = {
  102.     0,0,
  103.     0,0,JAM1,
  104.     5,
  105.     oXY1,
  106.     NULL
  107. };
  108.  
  109. static struct Gadget blue_gad = {
  110.    NULL, 17,61, 130,11, 
  111.    GADGHCOMP,                                 /* BLUE_PROP */
  112.    GADGIMMEDIATE | RELVERIFY,
  113.    PROPGADGET,
  114.    (APTR)&b_img, 
  115.    NULL,
  116.    &btxt, NULL,(APTR)&b_prop, PGHI+3, NULL };
  117.  
  118. static struct Gadget green_gad = {
  119.    &blue_gad, 17,49, 130,11, 
  120.    GADGHCOMP,                             /* GREEN_PROP */
  121.    GADGIMMEDIATE | RELVERIFY,
  122.    PROPGADGET,
  123.    (APTR)&g_img, 
  124.    NULL,
  125.    >xt, NULL,(APTR)&g_prop, PGHI+4, NULL };
  126.  
  127. static struct Gadget red_gad = {
  128.    &green_gad, 17,37, 130,11, 
  129.    GADGHCOMP,                              /* RED_PROP */
  130.    GADGIMMEDIATE | RELVERIFY,
  131.    PROPGADGET,
  132.    (APTR)&r_img, 
  133.    NULL,
  134.    &rtxt, NULL,(APTR)&r_prop, PGHI+5, NULL };
  135.  
  136. static struct Gadget ld_gad = {
  137.    &red_gad, PLX-75,39, 58,12, 
  138.    GADGIMAGE | GADGHIMAGE, 
  139.    RELVERIFY,                        /* load */
  140.    BOOLGADGET,
  141.    (APTR)&ldupImage, 
  142.    (APTR)&lddnImage,
  143.    NULL,NULL,NULL, PGHI+7, NULL };
  144.  
  145. static struct Gadget sv_gad = {
  146.    &ld_gad, PLX-75,57, 58,12, 
  147.    GADGIMAGE | GADGHIMAGE, 
  148.    RELVERIFY,                        /* save */
  149.    BOOLGADGET,
  150.    (APTR)&svupImage, 
  151.    (APTR)&svdnImage,
  152.    NULL,NULL,NULL, PGHI+6, NULL };
  153.  
  154.  
  155. static struct Gadget re_gad = {
  156.    &sv_gad, (PLX/2)-33,PLY-19, 58,12, 
  157.    GADGIMAGE | GADGHIMAGE, 
  158.    RELVERIFY,                        /* RESET */
  159.    BOOLGADGET,
  160.    (APTR)&reupImage, 
  161.    (APTR)&rednImage,
  162.    NULL,NULL,NULL, PGHI+2, NULL };
  163.  
  164. static struct Gadget cn_gad = {
  165.    &re_gad, PLX-75,PLY-19, 58,12, 
  166.    GADGIMAGE | GADGHIMAGE, 
  167.    RELVERIFY,                        /* CANCEL */
  168.    BOOLGADGET,
  169.    (APTR)&canupImage, 
  170.    (APTR)&candnImage,
  171.    NULL,NULL,NULL, PGHI+1, NULL };
  172.  
  173. static struct Gadget ok_gad = {
  174.    &cn_gad, 10,PLY-19, 58,12, 
  175.    GADGIMAGE | GADGHIMAGE, 
  176.    RELVERIFY,                        /* OKAY */
  177.    BOOLGADGET,
  178.    (APTR)&okupImage, 
  179.    (APTR)&okdnImage,
  180.    NULL,NULL,NULL, PGHI, NULL };
  181.  
  182. static struct Image m3C[CTSIZ] = {
  183.    {0,0,18,18,1, NULL ,0,0,NULL },        /* Color images */
  184.    {0,0,18,18,1, NULL ,0,1,NULL },
  185.    {0,0,18,18,1, NULL ,0,2,NULL },
  186.    {0,0,18,18,1, NULL ,0,3,NULL },
  187.    {0,0,18,18,1, NULL ,0,4,NULL },
  188.    {0,0,18,18,1, NULL ,0,5,NULL },
  189.    {0,0,18,18,1, NULL ,0,6,NULL },
  190.    {0,0,18,18,1, NULL ,0,7,NULL }
  191.  
  192. };
  193.  
  194. /* gadgets for Color images */
  195.    
  196. static struct Gadget palg[CTSIZ] = { 
  197.    { &palg[1], 8,15,  18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  198.       BOOLGADGET,  (APTR)&m3C[0], NULL,NULL,NULL,NULL, PGAD+0, NULL},
  199.    { &palg[2], 27,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  200.       BOOLGADGET,  (APTR)&m3C[1], NULL,NULL,NULL,NULL, PGAD+1, NULL},
  201.    { &palg[3], 46,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  202.       BOOLGADGET,  (APTR)&m3C[2], NULL,NULL,NULL,NULL, PGAD+2, NULL},
  203.    { &palg[4], 65,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  204.       BOOLGADGET,  (APTR)&m3C[3], NULL,NULL,NULL,NULL, PGAD+3, NULL},
  205.    { &palg[5], 84,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  206.       BOOLGADGET,  (APTR)&m3C[4], NULL,NULL,NULL,NULL, PGAD+4, NULL},
  207.    { &palg[6], 103,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  208.       BOOLGADGET,  (APTR)&m3C[5], NULL,NULL,NULL,NULL, PGAD+5, NULL},
  209.    { &palg[7], 122,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  210.       BOOLGADGET,  (APTR)&m3C[6], NULL,NULL,NULL,NULL, PGAD+6, NULL},
  211.    { &ok_gad, 141,15, 18,18, GADGHNONE | GADGIMAGE, RELVERIFY,
  212.       BOOLGADGET,  (APTR)&m3C[7], NULL,NULL,NULL,NULL, PGAD+7, NULL}
  213.  };
  214.   
  215.  
  216. /* Used to open a Window   */
  217. static struct NewWindow NewCmod = {
  218.    200,30,
  219.    PLX,PLY,
  220.    7,4, NULL,                     /* IDCMP set up AFTER CALL */
  221.    ACTIVATE | SMART_REFRESH | WINDOWDRAG,
  222.    &palg[0],NULL,
  223.    (UBYTE *)"Sample Color Palette",              /*Title */
  224.    NULL,NULL,              /* MUST SET SCREEN AFTER CALL!!! */
  225.    PLX,PLY,PLX,PLY, 
  226.    CUSTOMSCREEN        
  227. };
  228.  
  229.  
  230. /****    Variables Initialized (needed) by init_palette()  **********/
  231.  
  232. extern struct ViewPort      *ViewPortAddress();
  233. static struct Window        *pW   = NULL;   /* Palette Window handle */
  234. static struct RastPort      *p_Rp;
  235. static struct ViewPort      *p_Vp;
  236. static USHORT               p_ct[CTSIZ];    /* color table */
  237. static USHORT               new_colors[CTSIZ];
  238. static USHORT               def_colors[CTSIZ] =
  239.    {
  240.     0x000,
  241.     0x999,
  242.     0x555,
  243.     0x900,      /* put your own colors in here */
  244.     0xD60,
  245.     0xF90,
  246.     0x071,
  247.     0x009
  248.    };
  249.  
  250. /********************************************************************
  251.  * these buffers are sent to and maintained by get_fname() 
  252.  * (see: getfile.c)
  253.  *******************************************************************/
  254.  
  255. UBYTE def_dir[80]="SYS:\0";
  256. UBYTE cfile[32]="Color.file\0";
  257.  
  258. /*********************** init_palette() *****************************/
  259.  
  260. void init_palette(win,screen)
  261.  struct Window *win;
  262. {
  263. FAST int i;
  264.  
  265.  p_Vp = (struct ViewPort *)ViewPortAddress(win);
  266.  for ( i =0; i<CTSIZ; i++)
  267.     *(p_ct+i) = new_colors[i] = def_colors[i];
  268.  
  269.  set_cmap(); /* initialize begining colors as def_colors[] */   
  270. }
  271.  
  272. /********************************************************************
  273. * palette(window,screen)
  274. *    This is the meat. This routine opens the palette window and
  275. * retains control until the user selects the OK or CANCEL gadget.
  276. *     The calling arguements are a window & a screen pointer . The window
  277. * is expected to have opened an IDCMP port, which palette uses.
  278. ********************************************************************/
  279.  
  280. void palette(calling_window,screen)
  281.  struct Window *calling_window;
  282.  struct Screen *screen;
  283. {
  284.  FAST struct IntuiMessage *imsg;
  285.  FAST struct Gadget       *egad;
  286.  FAST ULONG  i,class,cursel;        /* cursel = current selected color */
  287.  BOOL keepon,munge;
  288.  
  289.  USHORT backup[CTSIZ];    /* This table restores calling colors... */
  290.  
  291. /* if ( ! (fW = calling_window) )  return;*/
  292.  
  293.  for ( cursel = 0L; cursel<CTSIZ; cursel++) 
  294.       backup[cursel] = *(p_ct+cursel);     /* backup the current colors */
  295.  
  296.  cursel--;                                 /* Get Back into Palette range */
  297.  
  298.  r_prop.Flags = g_prop.Flags = b_prop.Flags = FREEHORIZ | AUTOKNOB;
  299.  r_prop.HorizBody = g_prop.HorizBody = b_prop.HorizBody = 0x1000;
  300.  
  301.  /* Set Color Palette's Screen */
  302.  
  303.  NewCmod.Screen = screen;
  304.       
  305.  if ( ! (pW = (struct Window *)OpenWindow(&NewCmod)) )  /* Open Window */
  306.    {
  307.      return; /* Oops...  */
  308.    }
  309.  
  310.  p_Rp = pW->RPort;                        /* get a handle for RastPort */
  311.  
  312.  pW->UserPort = calling_window->UserPort; /* use calling window's UserPort */
  313.        
  314.  ModifyIDCMP(pW,(ULONG)(GADGETUP | GADGETDOWN | MENUVERIFY ));  /* Flags */
  315.  
  316.  /* Fill in the window, then Refresh the Gadgets */
  317.  
  318.  SetAPen(p_Rp,2L);                 
  319.  RectFill(p_Rp,4L,11L,(ULONG)(PLX-5),(ULONG)(PLY-3));
  320.  DrawBorder(p_Rp,&cbdr,6L,13L); 
  321.  DrawBorder(p_Rp,&sbdr,165L,13L); 
  322.  
  323.  RefreshGadgets(&palg[0],pW,NULL); 
  324.  
  325.  for ( munge = keepon = TRUE; keepon; )     /* The BIG LOOP */
  326.     {
  327.       if ( munge ) 
  328.         {
  329.          SetAPen(p_Rp,cursel);
  330.          RectFill(p_Rp,169L,15L,(ULONG)(PLX-17),32L); /* selected color */
  331.  
  332.          /* RJ will proably cringe if he see's this, but it is proably */
  333.          /* safe to modify the HorizPot values this way, UNLESS the    */
  334.          /* gadgets were being fiddled with when you do it. Here that  */
  335.          /* is quite unlikely, since another gadget was just activated */
  336.          /* to cause the munge flag to be set...                       */
  337.  
  338.          /* Make the prop gadgets represent the current selected color */
  339.  
  340.          r_prop.HorizPot = (p_ct[cursel] & 0xf00) << 4;
  341.          g_prop.HorizPot = (p_ct[cursel] & 0x0f0) << 8;
  342.          b_prop.HorizPot = p_ct[cursel] << 12;
  343.  
  344.      RefreshGadgets(&red_gad,pW,NULL); 
  345.  
  346.      munge = FALSE;
  347.          hxtxt.FrontPen = cursel ^ 15;
  348.          hxtxt.BackPen  = cursel;
  349.         }
  350.  
  351.       while ( ! (imsg=(struct IntuiMessage *)GetMsg(pW->UserPort)) )
  352.         {
  353.          class = p_ct[cursel] = ((r_prop.HorizPot >> 4) & 0xf00) +
  354.          ((g_prop.HorizPot >> 8) & 0xf0) + (b_prop.HorizPot >>12);
  355.  
  356.       set_cmap(); 
  357.  
  358.          /* get HEX values for selected color */
  359.  
  360.          frog[0] = hxtab[class >> 8];
  361.          frog[1] = hxtab[ (class >> 4) & 0x0f];
  362.          frog[2] = hxtab[class & 0x0f];
  363.          PrintIText(p_Rp,&hxtxt,0L,0L); 
  364.           
  365.          /* Proably, should do a WaitPort(pW->UserPort); */
  366.          /* I didn't, so the color updates faster.       */
  367.          /* In a multitasking environment, the system is */
  368.          /* being gronked...                             */
  369.  
  370.         }
  371.       egad =(struct Gadget *) imsg->IAddress;
  372.       if ( (class = imsg->Class) == MENUVERIFY )
  373.         {
  374.          imsg->Code = MENUCANCEL;      /* Don't Let Em Out! */
  375.          DisplayBeep(NULL);
  376.         }
  377.       ReplyMsg(imsg);
  378.  
  379.       switch ( class ) 
  380.         {
  381.          case GADGETUP:
  382.          case GADGETDOWN:
  383.             if ((egad->GadgetID >= PGAD)&&(egad->GadgetID < PGAD+CTSIZ)) 
  384.                { /* must be one of the color gadgets... */
  385.                cursel = egad->GadgetID - PGAD;
  386.                munge = TRUE;
  387.                break;
  388.                }
  389.             else switch ( egad->GadgetID ) 
  390.                  { /* otherwise.... */
  391.                case PGHI+1:                                /* CANCEL */
  392.                   for ( i =0L ; i<CTSIZ; i++)
  393.                      *(p_ct+i) = backup[i];
  394.                   set_cmap();
  395.  
  396.                case PGHI:                                  /* OK */
  397.                   for (i =0L ; i<CTSIZ; i++)
  398.                     new_colors[i] = p_ct[i]; 
  399.                   keepon = FALSE;
  400.                   break;
  401.  
  402.                case PGHI+2:                                /* RESET */
  403.                   for (i =0L ; i<CTSIZ ; i++)
  404.                      *(p_ct+i) = def_colors[i];
  405.                   set_cmap();
  406.                   munge = TRUE;
  407.                   break;
  408.  
  409.                case PGHI+6:                                 /* SAVE */
  410.                   if(get_fname(calling_window,screen,
  411.                     "Save Color Palette filename",cfile,def_dir))
  412.                    {
  413.                     Save_colors(prep_file(cfile,def_dir));
  414.                    }
  415.                   break;
  416.  
  417.                case PGHI+7:                                /* LOAD */
  418.                   if(get_fname(calling_window,screen,
  419.                     "Load Color Palette filename",cfile,def_dir))
  420.                    {
  421.                     Load_colors(prep_file(cfile,def_dir));
  422.                     for (i =0 ; i<CTSIZ ; i++)
  423.                        *(p_ct+i) = new_colors[i];
  424.                     set_cmap();
  425.                     munge = TRUE;
  426.                    }
  427.                   break;
  428.         }
  429.      }
  430.   }
  431.  
  432.  pW->UserPort = NULL;
  433.  CloseWindow(pW);
  434.  return;
  435. }
  436.  
  437. /***************************************************************
  438. * prep_file() 
  439. *
  440. *   little routine to add file name and dir together
  441. ***************************************************************/     
  442.  
  443. UBYTE *prep_file(name,dir)
  444. UBYTE   *name,*dir;
  445. {
  446. FAST UBYTE *retval;
  447.  
  448.  if(index(name,':') == 0)
  449.    strcpy(retval,dir);
  450.  strcat(retval,name);
  451.  return (retval); 
  452. }
  453.  
  454. /****************************************************************
  455. * set_cmap()
  456. *     This routine loads an updated p_ct color table into the
  457. * viewport.  You must have initialized the variables p_ct and
  458. * p_Vp to point at color table and ViewPort                     
  459. *****************************************************************/
  460.  
  461. set_cmap()
  462. {
  463.   LoadRGB4(p_Vp,p_ct,CTSIZ);
  464. }
  465.  
  466. /**************************** Save_colors() ********************************/
  467.  
  468. Save_colors(name)
  469. UBYTE *name;
  470. {
  471.  FILE   *out;
  472.  FAST int i,error;
  473.  
  474.  if((out = fopen(name,"w")) == NULL)
  475.    {
  476.     /* print_failure_string_to_screen() */
  477.     return ;
  478.    }
  479.  
  480.  fprintf(out,"%s\n",  " ________________________________________________");
  481.  fprintf(out,"%s\n",  "|                                                ");
  482.  fprintf(out,"%s%s\n","| File: ",name                                    );
  483.  fprintf(out,"%s\n",  "| Palette Colors generated by: My Program        ");
  484.  fprintf(out,"%s\n",  "|________________________________________________");
  485.  
  486. /*
  487.  *  I use the '%' char. to tell the "Load_Colors()" routine that there are
  488.  * no more comments, so the next lines should be the colors it's looking
  489.  * for. 
  490.  */
  491.  
  492.  fprintf(out,"%c\n",'%');
  493.  
  494. /*
  495.  * This may not be the best way to do this but... I print the values out 
  496.  * as a HEX string (and load them in the same way). The following code   
  497.  * just makes sure that the HEX value takes up all three spaces (after   
  498.  * the leading "0x") for readability.                                        
  499.  * i.e. the colors are printed as: 0xf00
  500.  *                                 0x0f0
  501.  *                                 0x00f
  502.  *                                 0x909
  503.  *                                 etc...                                                                          
  504.  */
  505.  
  506.  for(i = 0; i < CTSIZ; i++)
  507.     { 
  508.      fprintf(out,"%s","0x");     
  509.  
  510.      if (*(p_ct+i) < 0x010)
  511.         fprintf(out,"%d%d",0,0);
  512.  
  513.      else if (*(p_ct+i) < 0x100)
  514.         fprintf(out,"%d",0);    
  515.  
  516.      fprintf(out,"%x\n",*(p_ct+i));
  517.     }
  518.  error = ferror(out);
  519.  fclose( out );
  520.  if( error )
  521.    {
  522.     /* print_error_message_to_screen() */
  523.     return ;
  524.    }
  525. }
  526.  
  527. /******************* Load_Colors() ***********************/
  528.  
  529. Load_colors(name)
  530. UBYTE *name;
  531. {
  532.  FAST int      i;
  533.  int           n;
  534.  char          c;
  535.  FILE          *lib;
  536.  USHORT        t[CTSIZ];
  537.     
  538.  
  539.  if((lib = fopen(name,"r")) == NULL) 
  540.   {
  541.    /* print_failure_string_to_screen() */
  542.    return ;                 
  543.   }
  544.  
  545. /* 
  546.  *  Again, probably not the best way to do this...
  547.  *  (but hey, it works for me :-)
  548.  */
  549.  n=0;
  550.  while(!n)
  551.      n = (getc(lib) == '%');   /* stip off chars. until '%' char */
  552.  
  553.  c = getc(lib);                /* strip off '\n' char. */
  554.    
  555.  fscanf(lib,"%x%x%x%x%x%x%x%x",&t[0],&t[1],&t[2],&t[3],&t[4],&t[5],&t[6],
  556.                                &t[7]);
  557.  fclose(lib);
  558.  
  559. /*
  560.  * should do some error checking in here before copying in the new colors,
  561.  * but I got lazy :-)
  562.  *
  563.  */
  564.  
  565.  for (i=0; i<CTSIZ; i++)
  566.     new_colors[i] = t[i];  /* copy the new colors into new_colors[] */
  567. }
  568.