home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / xpaint-244 / src / pattern.c < prev    next >
Text File  |  1996-07-28  |  16KB  |  584 lines
  1. /* +-------------------------------------------------------------------+ */
  2. /* | Copyright 1992, 1993, David Koblas (koblas@netcom.com)            | */
  3. /* | Copyright 1995, 1996 Torsten Martinsen (bullestock@dk-online.dk)  | */
  4. /* |                                                                   | */
  5. /* | Permission to use, copy, modify, and to distribute this software  | */
  6. /* | and its documentation for any purpose is hereby granted without   | */
  7. /* | fee, provided that the above copyright notice appear in all       | */
  8. /* | copies and that both that copyright notice and this permission    | */
  9. /* | notice appear in supporting documentation.  There is no           | */
  10. /* | representations about the suitability of this software for        | */
  11. /* | any purpose.  this software is provided "as is" without express   | */
  12. /* | or implied warranty.                                              | */
  13. /* |                                                                   | */
  14. /* +-------------------------------------------------------------------+ */
  15.  
  16. /* $Id: pattern.c,v 1.6 1996/04/19 08:53:22 torsten Exp $ */
  17.  
  18. #include <X11/IntrinsicP.h>
  19. #include <X11/Shell.h>
  20. #include <X11/StringDefs.h>
  21. #ifndef VMS
  22. #include <X11/Xaw/Box.h>
  23. #include <X11/Xaw/Form.h>
  24. #include <X11/Xaw/Scrollbar.h>
  25. #include <X11/Xaw/Viewport.h>
  26. #include <X11/Xaw/Command.h>
  27. #include <X11/CoreP.h>
  28. #include <X11/Xaw/ToggleP.h>
  29. #else
  30. #include <X11Xaw/Box.h>
  31. #include <X11Xaw/Form.h>
  32. #include <X11Xaw/Scrollbar.h>
  33. #include <X11Xaw/Viewport.h>
  34. #include <X11Xaw/Command.h>
  35. #include <X11/CoreP.h>
  36. #include <X11Xaw/ToggleP.h>
  37. #endif
  38.  
  39. #include <X11/cursorfont.h>
  40. #include <stdio.h>
  41. #include "Colormap.h"
  42. #include "Paint.h"
  43. #include "palette.h"
  44. #include "xpaint.h"
  45. #include "menu.h"
  46. #include "image.h"
  47. #include "misc.h"
  48. #include "cutCopyPaste.h"
  49. #include "text.h"
  50. #include "graphic.h"
  51. #include "operation.h"
  52. #include "color.h"
  53. #include "protocol.h"
  54.  
  55. #ifndef NOSTDHDRS
  56. #include <stdlib.h>
  57. #include <unistd.h>
  58. #endif
  59.  
  60. static PaintMenuItem fileMenu[] =
  61. {
  62.     MI_SIMPLE("read"),
  63.     MI_SIMPLE("save"),
  64.     MI_SIMPLE("close"),
  65. };
  66. static PaintMenuItem editMenu[] =
  67. {
  68.     MI_SIMPLE("undo"),
  69.     MI_SEPERATOR(),
  70.     MI_SIMPLE("cut"),
  71.     MI_SIMPLE("copy"),
  72.     MI_SIMPLE("paste"),
  73.     MI_SIMPLE("clear"),
  74.     MI_SEPERATOR(),
  75.     MI_SIMPLE("dup"),
  76.     MI_SIMPLE("all"),
  77. };
  78. static PaintMenuItem sizeMenu[] =
  79. {
  80. #define SZ_N1    0
  81.     MI_FLAG("16x16", MF_CHECK | MF_GROUP1),
  82. #define SZ_N2    1
  83.     MI_FLAG("24x24", MF_CHECK | MF_GROUP1),
  84. #define SZ_N3    2
  85.     MI_FLAG("32x32", MF_CHECK | MF_GROUP1),
  86. #define SZ_N4    3
  87.     MI_FLAG("48x48", MF_CHECK | MF_GROUP1),
  88. #define SZ_N5    4
  89.     MI_FLAG("64x64", MF_CHECK | MF_GROUP1),
  90.     MI_SEPERATOR(),
  91. #define SZ_N6    6
  92.     MI_FLAG("other", MF_CHECK | MF_GROUP1),
  93. };
  94. static PaintMenuItem imageMenu[] =
  95. {
  96.     MI_FLAG("grid", MF_CHECK),
  97. };
  98. static PaintMenuItem helpMenu[] =
  99. {
  100.     MI_SIMPLECB("help", HelpDialog, "canvas.patBox.pattern"),
  101. };
  102. static PaintMenuBar menuBar[] =
  103. {
  104.     {None, "file", XtNumber(fileMenu), fileMenu},
  105.     {None, "edit", XtNumber(editMenu), editMenu},
  106.     {None, "size", XtNumber(sizeMenu), sizeMenu},
  107.     {None, "image", XtNumber(imageMenu), imageMenu},
  108.     {None, "help", XtNumber(helpMenu), helpMenu},
  109. };
  110.  
  111. #define    RED    1
  112. #define    GREEN    2
  113. #define    BLUE    3
  114.  
  115. Widget ColorPickerPalette(Widget, Palette *, Pixel *);
  116.  
  117. typedef struct {
  118.     int add;
  119.     Pixmap pix;
  120.     void *iconList;
  121.     Widget fat, norm, paint;
  122.     Widget cpick, color;
  123.     Widget curCheck;
  124.     Widget sizeChecks[XtNumber(sizeMenu) - 1];
  125.     Palette *map;
  126. } LocalInfo;
  127.  
  128. static void 
  129. activePixel(LocalInfo * l, Pixel p)
  130. {
  131.     if (l->color != None)
  132.     XtVaSetValues(l->color, XtNcolor, p, NULL);
  133.     XtVaSetValues(l->fat, XtNforeground, p,
  134.           XtNlineForeground, p,
  135.           NULL);
  136.     if (l->cpick != None)
  137.     ColorPickerSetPixel(l->cpick, p);
  138.     PaletteSetInvalid(l->map, p);
  139. }
  140.  
  141. static void 
  142. cpickCallback(Widget w, LocalInfo * l, Pixel p)
  143. {
  144.     activePixel(l, p);
  145. }
  146.  
  147. static void 
  148. colorCallback(Widget w, LocalInfo * l, XColor * color)
  149. {
  150.     activePixel(l, color->pixel);
  151. }
  152.  
  153. static void 
  154. matchCallback(Widget w, LocalInfo * l, XtPointer junk)
  155. {
  156.     Colormap cmap;
  157.     Pixel p;
  158.  
  159.     DoGrabPixel(w, &p, &cmap);
  160.  
  161.     if (l->map->cmap == cmap) {
  162.     activePixel(l, p);
  163.     } else {
  164.     XColor col;
  165.  
  166.     col.flags = DoRed | DoGreen | DoBlue;
  167.     col.pixel = p;
  168.     XQueryColor(XtDisplay(w), cmap, &col);
  169.     if (PaletteLookupColor(l->map, &col, &p)) {
  170.         activePixel(l, p);
  171.     } else {
  172.         Notice(w, "Selected color is from a different colormap,\n"
  173.            "with no matching color on this colormap");
  174.     }
  175.     }
  176. }
  177.  
  178.  
  179. static void 
  180. grabCallback(Widget w, XtPointer infoArg, XtPointer junk2)
  181. {
  182.     LocalInfo *info = (LocalInfo *) infoArg;
  183.     Image *image;
  184.     Colormap cmap;
  185.     Pixmap pix;
  186.     int grabW, grabH;
  187.  
  188.     XtVaGetValues(info->fat, XtNdrawWidth, &grabW,
  189.           XtNdrawHeight, &grabH,
  190.           NULL);
  191.  
  192.     image = DoGrabImage(w, grabW, grabH);
  193.  
  194.     XtVaGetValues(info->paint, XtNcolormap, &cmap, NULL);
  195.     pix = None;
  196.     if (ImageToPixmapCmap(image, info->fat, &pix, cmap))
  197.     PwPutPixmap(info->fat, pix);
  198. }
  199.  
  200. static void 
  201. closeCallback(Widget w, XtPointer infoArg, XtPointer junk2)
  202. {
  203.     LocalInfo *info = (LocalInfo *) infoArg;
  204.  
  205.     XtDestroyWidget(GetShell(info->fat));
  206.     StateShellBusy(info->paint, False);
  207.     XtFree((XtPointer) info);
  208. }
  209. static void 
  210. buttonCallback(Widget w, XtPointer infoArg, XtPointer junk2)
  211. {
  212.     LocalInfo *info = (LocalInfo *) infoArg;
  213.     Pixmap pix;
  214.     Widget icon;
  215. #if 0
  216.     XtPointer data;
  217. #endif
  218.  
  219.     if (info != NULL) {
  220.     void *pi = XawToggleGetCurrent(info->iconList);
  221.     PwRegionFinish(info->fat, True);
  222.     PwGetPixmap(info->fat, &pix, NULL, NULL);
  223.  
  224.     if (info->add) {
  225.         icon = AddPatternInfo(pi, pix, 0);
  226.  
  227. #if 0
  228.         XtVaGetValues(icon, XtNradioData, &data, NULL);
  229.  
  230.         XawToggleSetCurrent(icon, data);
  231. #endif
  232.     } else {
  233.         ChangePattern(pi, pix);
  234.     }
  235.  
  236. #if 0
  237.     XtVaSetValues(info->paint, XtNpattern, pix, NULL);
  238. #endif
  239.     StateShellBusy(info->paint, False);
  240.     XtFree((XtPointer) info);
  241.     }
  242.     XtDestroyWidget(GetShell(w));
  243. }
  244. static void 
  245. readFileCallback(Widget paint, XtPointer fileArg, XtPointer imageArg)
  246. {
  247.     Image *image = (Image *) imageArg;
  248.     Pixmap pix;
  249.     Colormap cmap;
  250.  
  251.     /*  XXX - allocating a new colormap! */
  252.     if (ImageToPixmap(image, paint, &pix, &cmap)) {
  253.     XtVaSetValues(paint, XtNcolormap, cmap, NULL);
  254.     PwPutPixmap(paint, pix);
  255.     return;
  256.     }
  257. }
  258. static void 
  259. readCallback(Widget w, XtPointer paint, XtPointer junk)
  260. {
  261.     GetFileName((Widget) paint, False, NULL, readFileCallback, NULL);
  262. }
  263.  
  264. static void 
  265. cac(LocalInfo * info, int inW, int inH)
  266. {
  267.     int width, height, i;
  268.     String lbl;
  269.  
  270.     for (i = 0; i < XtNumber(info->sizeChecks); i++) {
  271.     Widget w = info->sizeChecks[i];
  272.     XtVaGetValues(w, XtNlabel, &lbl, NULL);
  273.     width = -1;
  274.     height = -1;
  275.     sscanf(lbl, "%dx%d", &width, &height);
  276.     if (width <= 0 || height <= 0 || (width == inW && height == inH)) {
  277.         MenuCheckItem(info->curCheck = w, True);
  278.         break;
  279.     }
  280.     }
  281. }
  282. static void 
  283. sizeOkChoiceCallback(Widget w, LocalInfo * l, TextPromptInfo * info)
  284. {
  285.     int width = atoi(info->prompts[0].rstr);
  286.     int height = atoi(info->prompts[1].rstr);
  287.  
  288.     if (width <= 0 || height <= 0) {
  289.     Notice(w, "Invalid width or height,\nmust be greater than 0");
  290.     } else if (width > 128 || height > 128) {
  291.     Notice(w, "Invalid width or height,\nmust be less than 129");
  292.     } else {
  293.     XtVaSetValues(l->fat, XtNdrawWidth, width,
  294.               XtNdrawHeight, height,
  295.               NULL);
  296.     MenuCheckItem(l->curCheck, False);
  297.     l->curCheck = None;
  298.     cac(l, width, height);
  299.     }
  300. }
  301. static void 
  302. sizeChoiceCallback(Widget w, XtPointer larg, XtPointer junk)
  303. {
  304.     static TextPromptInfo info;
  305.     static struct textPromptInfo values[3];
  306.     char bufA[16], bufB[16];
  307.     int width, height;
  308.     LocalInfo *l = (LocalInfo *) larg;
  309.  
  310.     XtVaGetValues(l->fat, XtNdrawWidth, &width,
  311.           XtNdrawHeight, &height,
  312.           NULL);
  313.  
  314.     info.prompts = values;
  315.     info.nprompt = 2;
  316.     info.title = "Enter the desired pattern size:";
  317.  
  318.     values[0].prompt = "Width:";
  319.     values[0].str = bufA;
  320.     values[0].len = 4;
  321.     values[1].prompt = "Height:";
  322.     values[1].str = bufB;
  323.     values[1].len = 4;
  324.  
  325.     sprintf(bufA, "%d", width);
  326.     sprintf(bufB, "%d", height);
  327.  
  328.     TextPrompt(w, "sizeselect", &info, (XtCallbackProc) sizeOkChoiceCallback,
  329.            NULL, larg);
  330. }
  331. static void 
  332. sizeCallback(Widget w, XtPointer larg, XtPointer junk)
  333. {
  334.     LocalInfo *l = (LocalInfo *) larg;
  335.     int width, height;
  336.     String lbl;
  337.  
  338.     if (l->curCheck == w)
  339.     return;
  340.  
  341.     XtVaGetValues(w, XtNlabel, &lbl, NULL);
  342.     width = -1;
  343.     height = -1;
  344.     sscanf(lbl, "%dx%d", &width, &height);
  345.     if (width <= 0 || height <= 0 || width >= 256 || height >= 256) {
  346.     Notice(w, "Invalid width/height specification must be between 0..256");
  347.     return;
  348.     }
  349.     MenuCheckItem(l->curCheck = w, True);
  350.  
  351.     /*
  352.     **  Just change the size, no OK
  353.      */
  354.     XtVaSetValues(l->fat, XtNdrawWidth, width,
  355.           XtNdrawHeight, height,
  356.           NULL);
  357.     XtVaSetValues(l->norm, XtNdrawWidth, width,
  358.           XtNdrawHeight, height,
  359.           NULL);
  360. }
  361. static void 
  362. gridCallback(Widget w, XtPointer larg, XtPointer junk)
  363. {
  364.     LocalInfo *l = (LocalInfo *) larg;
  365.     Boolean v;
  366.  
  367.     XtVaGetValues(l->fat, XtNgrid, &v, NULL);
  368.     v = !v;
  369.     XtVaSetValues(l->fat, XtNgrid, v, NULL);
  370.  
  371.     MenuCheckItem(w, v);
  372. }
  373.  
  374. void 
  375. PatternEdit(Widget w, Pixmap pix, Widget button)
  376. {
  377.     Widget shell, form, topf, norm, box, vp;
  378.     Widget color, fat, bar, cpick;
  379.     Widget okButton, cancelButton, grabButton, matchButton;
  380.     Colormap cmap;
  381.     Pixel pval = WhitePixelOfScreen(XtScreen(w));
  382.     LocalInfo *info = (LocalInfo *) XtMalloc(sizeof(LocalInfo));
  383.     Palette *map;
  384.     int width, height;
  385.     Position x, y;
  386.  
  387.     info->paint = w;
  388.     info->add = (pix == None);
  389.     info->iconList = button;
  390.  
  391.     StateShellBusy(w, True);
  392.     XtVaGetValues(GetShell(w), XtNcolormap, &cmap, XtNx, &x, XtNy, &y, NULL);
  393.     info->map = map = PaletteFind(w, cmap);
  394.  
  395.     shell = XtVaCreatePopupShell("pattern", transientShellWidgetClass,
  396.                  GetShell(w),
  397.                  XtNcolormap, cmap,
  398.                  XtNx, x + 24,
  399.                  XtNy, y + 24,
  400.                  NULL);
  401.     PaletteAddUser(map, shell);
  402.  
  403.     topf = XtVaCreateManagedWidget("form", formWidgetClass, shell,
  404.                    NULL);
  405.  
  406.     bar = MenuBarCreate(topf, XtNumber(menuBar), menuBar);
  407.  
  408.     form = XtVaCreateManagedWidget("box", formWidgetClass, topf,
  409.                    XtNfromVert, bar,
  410.                    XtNtop, XtChainTop,
  411.                    XtNbottom, XtChainBottom,
  412.                    NULL);
  413.     vp = XtVaCreateManagedWidget("viewport", viewportWidgetClass, form,
  414.                  XtNfromVert, bar,
  415.                  XtNallowVert, True,
  416.                  XtNallowHoriz, True,
  417.                  XtNuseBottom, True,
  418.                  XtNuseRight, True,
  419.                  XtNleft, XtChainLeft,
  420.                  XtNright, XtChainRight,
  421.                  NULL);
  422.     box = XtVaCreateManagedWidget("patternBox", boxWidgetClass, vp,
  423.                 XtNbackgroundPixmap, GetBackgroundPixmap(vp),
  424.                   XtNorientation, XtorientHorizontal,
  425.                   NULL);
  426.  
  427.     if (pix == None)
  428.     fat = XtVaCreateManagedWidget("paint", paintWidgetClass, box,
  429.                       XtNpixmap, pix,
  430.                       XtNdrawWidth, 24,
  431.                       XtNdrawHeight, 24,
  432.                       XtNfillRule, FillSolid,
  433.                       NULL);
  434.     else
  435.     fat = XtVaCreateManagedWidget("paint", paintWidgetClass, box,
  436.                       XtNpixmap, pix,
  437.                       XtNfillRule, FillSolid,
  438.                       NULL);
  439.     norm = XtVaCreateManagedWidget("norm", paintWidgetClass, box,
  440.                    XtNpaint, fat,
  441.                    XtNfillRule, FillSolid,
  442.                    XtNzoom, 1,
  443.                    NULL);
  444.     OperationSetPaint(fat);
  445.     ccpAddStdPopup(fat);
  446.  
  447.  
  448.     cpick = None;
  449. #ifndef VMS
  450.     if (!map->isMapped || !map->readonly || map->ncolors > 256)
  451. #else
  452.     if (!map->isMapped || !map->Readonly || map->ncolors > 256)
  453. #endif
  454.     cpick = ColorPickerPalette(form, map, &pval);
  455.  
  456.     if (map->isMapped) {
  457.     color = XtVaCreateManagedWidget("cedit", colormapWidgetClass, form,
  458.                     XtNwidth, 256,
  459.                     XtNheight, 256,
  460.                     XtNcolormap, cmap,
  461.                     XtNfromHoriz, vp,
  462.                     XtNleft, XtChainRight,
  463.                     XtNright, XtChainRight,
  464.                     NULL);
  465.     if (cpick != None)
  466.         XtVaSetValues(cpick, XtNfromHoriz, color,
  467.               XtNleft, XtChainRight,
  468.               NULL);
  469.     XtAddCallback(color, XtNcallback,
  470.               (XtCallbackProc) colorCallback, (XtPointer) info);
  471.     } else {
  472.     color = None;
  473.     if (cpick != None) {
  474.         XtVaSetValues(cpick, XtNfromHoriz, vp,
  475.               XtNleft, XtChainRight,
  476.               XtNright, XtChainRight,
  477.               NULL);
  478.         ColorPickerSetFunction(cpick,
  479.                (XtCallbackProc) cpickCallback, (XtPointer) info);
  480.     }
  481.     }
  482.  
  483.     info->cpick = cpick;
  484.     info->color = color;
  485.     info->fat = fat;
  486.     info->norm = norm;
  487.  
  488.     okButton = XtVaCreateManagedWidget("ok",
  489.                        commandWidgetClass, topf,
  490.                        XtNfromVert, form,
  491.                        XtNtop, XtChainBottom,
  492.                        XtNbottom, XtChainBottom,
  493.                        XtNleft, XtChainLeft,
  494.                        XtNright, XtChainLeft,
  495.                        NULL);
  496.  
  497.     cancelButton = XtVaCreateManagedWidget("cancel",
  498.                        commandWidgetClass, topf,
  499.                        XtNfromVert, form,
  500.                        XtNfromHoriz, okButton,
  501.                        XtNtop, XtChainBottom,
  502.                        XtNbottom, XtChainBottom,
  503.                        XtNleft, XtChainLeft,
  504.                        XtNright, XtChainLeft,
  505.                        NULL);
  506.     grabButton = XtVaCreateManagedWidget("grab",
  507.                      commandWidgetClass, topf,
  508.                      XtNfromVert, form,
  509.                      XtNfromHoriz, cancelButton,
  510.                      XtNtop, XtChainBottom,
  511.                      XtNbottom, XtChainBottom,
  512.                      XtNleft, XtChainLeft,
  513.                      XtNright, XtChainLeft,
  514.                      NULL);
  515.     matchButton = XtVaCreateManagedWidget("lookup",
  516.                       commandWidgetClass, topf,
  517.                       XtNfromVert, form,
  518.                       XtNfromHoriz, grabButton,
  519.                       XtNtop, XtChainBottom,
  520.                       XtNbottom, XtChainBottom,
  521.                       XtNleft, XtChainLeft,
  522.                       XtNright, XtChainLeft,
  523.                       NULL);
  524.  
  525.     ccpAddUndo(XtNameToWidget(bar, "edit.editMenu.undo"), fat);
  526.     ccpAddCut(XtNameToWidget(bar, "edit.editMenu.cut"), fat);
  527.     ccpAddCopy(XtNameToWidget(bar, "edit.editMenu.copy"), fat);
  528.     ccpAddPaste(XtNameToWidget(bar, "edit.editMenu.paste"), fat);
  529.     ccpAddClear(XtNameToWidget(bar, "edit.editMenu.clear"), fat);
  530.     ccpAddDuplicate(XtNameToWidget(bar, "edit.editMenu.dup"), fat);
  531.  
  532.     XtAddCallback(XtNameToWidget(bar, "edit.editMenu.all"),
  533.           XtNcallback, StdSelectAllCallback, (XtPointer) fat);
  534.  
  535.     XtAddCallback(XtNameToWidget(bar, "file.fileMenu.close"),
  536.           XtNcallback, closeCallback, (XtPointer) info);
  537.     XtAddCallback(XtNameToWidget(bar, "file.fileMenu.save"),
  538.           XtNcallback, StdSaveFile, (XtPointer) fat);
  539.     XtAddCallback(XtNameToWidget(bar, "file.fileMenu.read"),
  540.           XtNcallback, readCallback, (XtPointer) fat);
  541.  
  542.     XtAddCallback(sizeMenu[SZ_N1].widget,
  543.           XtNcallback, sizeCallback, (XtPointer) info);
  544.     XtAddCallback(sizeMenu[SZ_N2].widget,
  545.           XtNcallback, sizeCallback, (XtPointer) info);
  546.     XtAddCallback(sizeMenu[SZ_N3].widget,
  547.           XtNcallback, sizeCallback, (XtPointer) info);
  548.     XtAddCallback(sizeMenu[SZ_N4].widget,
  549.           XtNcallback, sizeCallback, (XtPointer) info);
  550.     XtAddCallback(sizeMenu[SZ_N5].widget,
  551.           XtNcallback, sizeCallback, (XtPointer) info);
  552.     XtAddCallback(sizeMenu[SZ_N6].widget,
  553.           XtNcallback, sizeChoiceCallback, (XtPointer) info);
  554.     XtAddCallback(imageMenu[0].widget,
  555.           XtNcallback, gridCallback, (XtPointer) info);
  556.  
  557.     info->sizeChecks[0] = sizeMenu[SZ_N1].widget;
  558.     info->sizeChecks[1] = sizeMenu[SZ_N2].widget;
  559.     info->sizeChecks[2] = sizeMenu[SZ_N3].widget;
  560.     info->sizeChecks[3] = sizeMenu[SZ_N4].widget;
  561.     info->sizeChecks[4] = sizeMenu[SZ_N5].widget;
  562.     info->sizeChecks[5] = sizeMenu[SZ_N6].widget;
  563.  
  564.     XtVaGetValues(info->fat, XtNdrawWidth, &width, XtNdrawHeight, &height, NULL);
  565.     cac(info, width, height);
  566.  
  567.     XtAddCallback(okButton, XtNcallback,
  568.           (XtCallbackProc) buttonCallback, (XtPointer) info);
  569.     XtAddCallback(cancelButton, XtNcallback,
  570.           (XtCallbackProc) closeCallback, (XtPointer) info);
  571.     AddDestroyCallback(shell, (DestroyCallbackFunc) closeCallback, info);
  572.     XtAddCallback(grabButton, XtNcallback,
  573.           (XtCallbackProc) grabCallback, (XtPointer) info);
  574.     XtAddCallback(matchButton, XtNcallback,
  575.           (XtCallbackProc) matchCallback, (XtPointer) info);
  576.  
  577.     XtPopup(shell, XtGrabNone);
  578.  
  579.     activePixel(info, 0);
  580.  
  581.     GraphicAdd(fat);
  582.     GraphicAdd(norm);
  583. }