home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / misc / wingnuplot / source.lha / source / PlotImage.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-10  |  6.1 KB  |  255 lines
  1. /* this implements the Plot BOOPSI Gagdet */
  2.  
  3. #include "struct.c"
  4. #include "WinPlot.h"
  5. #include "OutlineFont.h"
  6. #include "amigawin.h"
  7.  
  8. struct MUI_Palette_Entry ColorEntries[] =
  9. {
  10.  {  0, 0x00000000, 0x00000000, 0x00000000,  0}, /* border */
  11.  {  1, 0x22222222, 0x22222222, 0x22222222,  1}, /* axes */
  12.  {  2, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,  2}, /* background */
  13.  {  3, 0x00000000, 0x00000000, 0x00000000,  6},
  14.  {  4, 0x33333333, 0x33333333, 0x33333333,  7},
  15.  {  5, 0x77777777, 0x77777777, 0x77777777,  8},
  16.  {  6, 0xBBBBBBBB, 0xBBBBBBBB, 0xBBBBBBBB,  9},
  17.  {  7, 0xFFFFFFFF, 0x00000000, 0x00000000,  3},
  18.  {  8, 0x00000000, 0xFFFFFFFF, 0x00000000,  4},
  19.  {  9, 0x00000000, 0x00000000, 0xFFFFFFFF,  5},
  20.  { MUIV_Palette_Entry_End,0,0,0,0 },
  21. };
  22.  
  23. char *ColorNames[] =
  24. {
  25.  "Border",
  26.  "Axes",
  27.  "BackGround",
  28.  "Color 0",
  29.  "Color 1",
  30.  "Color 2",
  31.  "Color 3",
  32.  "Color 4",
  33.  "Color 5",
  34.  "Color 6",
  35. };
  36.  
  37. Class *PlotImgClass = NULL;
  38.  
  39. struct PlotImageData
  40. {
  41.  struct ColorMap *cm;
  42.  UWORD            Pens[NUMCOLORS];
  43. };
  44.  
  45. static ULONG __asm DispatchPlotImage(register __a0 Class *, 
  46.                      register __a2 Object *,
  47.                      register __a1 Msg);
  48.  
  49. int _STI_10000_InitPlotImgClass(void)
  50. {                                
  51.  Class *cl;
  52.  
  53.  if (cl = MakeClass(NULL, GADGETCLASS, NULL, sizeof(struct PlotImageData), 0))
  54.   {
  55.    cl->cl_Dispatcher.h_Entry = (ULONG(*)()) DispatchPlotImage;
  56.    PlotImgClass = cl;
  57.  
  58.    return 0;
  59.   }
  60.  
  61.  return 1;
  62. }
  63.  
  64. void _STD_10000_FreePlotImgClass(void)
  65. {
  66.  if (PlotImgClass) FreeClass(PlotImgClass);
  67. }
  68.  
  69. /* a quick&dirty emulation of OS3 ObtainBestPen */
  70. static int GetPen(struct ColorMap *cm, UBYTE Depth, ULONG lr, ULONG lg, ULONG lb)
  71. {
  72.  ULONG entrie;
  73.  ULONG  sum, best;
  74.  BYTE  r1, g1, b1;
  75.  UBYTE r, g, b;
  76.  int   i, bestpen;
  77.  
  78.  r = lr >> 28; g = lg >> 28; b = lb >> 28;
  79.  best = INT_MAX; bestpen = 0;
  80.  for(i = 0; i<Depth; i++)
  81.   {
  82.    entrie = GetRGB4(cm, i);
  83.    r1 = (entrie >> 16) & 0x0F;
  84.    g1 = (entrie >>  8) & 0x0F;
  85.    b1 = entrie & 0x0F;
  86.  
  87.    sum = (r1-r)*(r1-r)+(g1-g)*(g1-g)+(b1-b)*(b1-b);
  88.    if (sum < best)
  89.     {
  90.      best = sum;
  91.      bestpen = i;
  92.     }
  93.   }
  94.  
  95.  return bestpen;
  96. }
  97.  
  98. struct PlotCommand *commands = NULL;
  99. int                 ncommands = 0;
  100.  
  101. /* this the main plot routine, which interprets the GnuPlot draw-commands */
  102. static void __interrupt RenderImage(struct gpRender *gpr, struct Gadget *g,
  103.                     struct PlotImageData *pig)
  104. {
  105.  int              i, w, h;
  106.  int              justify = 0;
  107.  int              x,y,xmin,xmax,ymin,ymax,txlen; 
  108.  BOOL             Vertical = FALSE;
  109.  struct Task     *MyTask; 
  110.  struct RastPort *rp = gpr->gpr_RPort;
  111.  
  112.  MyTask = FindTask(NULL);
  113.  if (MyTask->tc_Node.ln_Type == NT_PROCESS)
  114.   {
  115.    if (GfxBase->LibNode.lib_Version >= 39)
  116.     {
  117.      if (pig->cm != NULL)
  118.       for(i=0; i<NUMCOLORS; i++)
  119.        ReleasePen(pig->cm, pig->Pens[i]);
  120.      else
  121.       pig->cm = gpr->gpr_GInfo->gi_Screen->ViewPort.ColorMap;
  122.  
  123.      for(i=0; i<NUMCOLORS; i++)
  124.       pig->Pens[i] = ObtainBestPen(pig->cm,
  125.                    ColorEntries[i].mpe_Red,
  126.                    ColorEntries[i].mpe_Green,
  127.                    ColorEntries[i].mpe_Blue,
  128.                    OBP_Precision, PRECISION_IMAGE,
  129.                    TAG_END);
  130.     }
  131.    else
  132.     {
  133.      UBYTE Depth = 1 << gpr->gpr_GInfo->gi_DrInfo->dri_Depth;
  134.  
  135.      pig->cm = gpr->gpr_GInfo->gi_Screen->ViewPort.ColorMap;
  136.      for(i=0; i<NUMCOLORS; i++)
  137.       pig->Pens[i] = GetPen(pig->cm, Depth,
  138.                 ColorEntries[i].mpe_Red,
  139.                 ColorEntries[i].mpe_Green,
  140.                 ColorEntries[i].mpe_Blue);
  141.     }
  142.    SetAPen(rp, pig->Pens[2]);
  143.    RectFill(rp, g->LeftEdge, g->TopEdge,
  144.         g->LeftEdge+g->Width-1, g->TopEdge+g->Height-1);
  145.    SetAPen(rp, pig->Pens[0]);
  146.    SetDrMd(rp, JAM1);
  147.    
  148.    w = g->Width;
  149.    h = g->Height;
  150.    SetFontSize(w, h);
  151.    for(i=0; i<ncommands; i++)
  152.     switch (commands[i].pc_com)
  153.      {
  154.      case LINETYP:
  155.       if (commands[i].pc_arg1 == -2)
  156.        SetAPen(rp, pig->Pens[0]);
  157.       else if (commands[i].pc_arg1 == -1)
  158.        SetAPen(rp, pig->Pens[1]);
  159.       else 
  160.        SetAPen(rp, pig->Pens[3+ commands[i].pc_arg1 % (NUMCOLORS-3)]);
  161.       break;
  162.      case JUSTIFY:
  163.       justify = commands[i].pc_arg1;
  164.       break;
  165.      case TEXT_ANGLE:
  166.       Vertical = commands[i].pc_arg1 == 1;
  167.       break;
  168.      case PUT_TEXT:
  169.       txlen = TextLen(commands[i].pc_argstr);
  170.       x = (commands[i].pc_arg1 * w) / RESOLUTION;
  171.       y = h-(commands[i].pc_arg2 * h) / RESOLUTION;
  172.       if (!Vertical)
  173.        {
  174.     switch (justify)
  175.      {
  176.      case 0 :
  177.       xmin = x;
  178.       xmax = x + txlen;
  179.       break;
  180.      case 1:
  181.       xmin = x - txlen/2;
  182.       xmax = x + txlen/2;
  183.       break;
  184.      case 2:
  185.       xmin = x - txlen;
  186.       xmax = x;
  187.       break;
  188.      }
  189.     ymin = y;
  190.     ymax = ymin+h/70;
  191.     PrintString(rp, g->LeftEdge+xmin, g->TopEdge+ ymax,
  192.             commands[i].pc_argstr, FALSE); 
  193.        }
  194.       else
  195.        {
  196.     ymax = y + txlen/2;
  197.     PrintString(rp, g->LeftEdge+x, g->TopEdge+ymax, commands[i].pc_argstr, TRUE);
  198.        }
  199.       break;
  200.      case MOVE:
  201.       Move(rp,
  202.        g->LeftEdge + (commands[i].pc_arg1 * w) / RESOLUTION,
  203.        g->TopEdge + h - (commands[i].pc_arg2 * h) / RESOLUTION);
  204.       break;
  205.      case VECTOR:
  206.       Draw(rp,
  207.        g->LeftEdge + (commands[i].pc_arg1 * w) / RESOLUTION,
  208.        g->TopEdge + h - (commands[i].pc_arg2 * h) / RESOLUTION);
  209.       break;
  210.      }
  211.   }
  212. }
  213.  
  214. /* the BOOPSI stuff, quite standard */
  215. /* Although this is a BOOPSI-Gadget, we only need its image, */
  216. /* so the input related stuff ist not implemented */
  217. static ULONG __interrupt __asm __saveds DispatchPlotImage(register __a0 Class *cl,
  218.                               register __a2 Object *o,
  219.                               register __a1 Msg msg)
  220. {
  221.  ULONG                 retval = FALSE;
  222.  int                   i;
  223.  Object               *object;
  224.  struct PlotImageData *this;
  225.  
  226.  switch (msg->MethodID)
  227.   {
  228.   case GM_RENDER:
  229.    this = INST_DATA(cl, o);
  230.    RenderImage((struct gpRender *)msg, (struct Gadget *)o, this);
  231.    retval = TRUE;
  232.    break;
  233.   case OM_NEW:
  234.    if (object = (Object *)DoSuperMethodA(cl, o, msg))
  235.     {
  236.      this = INST_DATA(cl, object);
  237.      this->cm = NULL;
  238.     }
  239.    retval = (ULONG)object;
  240.    break;
  241.   case OM_DISPOSE:
  242.    this = INST_DATA(cl, o);
  243.    if (GfxBase->LibNode.lib_Version >= 39 && this->cm)
  244.     for(i=0; i<NUMCOLORS; i++)
  245.      ReleasePen(this->cm, this->Pens[i]);
  246.    retval = TRUE;
  247.    break;
  248.   default:
  249.    retval = DoSuperMethodA(cl, o, msg);
  250.    break;
  251.   }
  252.  
  253.  return retval;
  254. }
  255.