home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 1: Collection A / 17Bit_Collection_A.iso / files / 1112.dms / 1112.adf / ImageEd / Source / ImageRout.c < prev    next >
C/C++ Source or Header  |  1988-07-25  |  25KB  |  904 lines
  1. /*
  2.    ImageRout.c - include file for routines.
  3.  
  4.    (c)1990 Olaf Leimann
  5. */
  6.  
  7. /*#FOLD: definitions, structures, data */
  8. #define IMAGE_FROM_LEFT     8
  9. #define IMAGE_FROM_TOP     34
  10. #define COLOUR_FROM_LEFT  296
  11. #define COLOUR_FROM_TOP    12
  12. #define X_BORDERWIDTH       4
  13. #define Y_BORDERWIDTH       2
  14. #define NUMBER_OF_INFO      5
  15. #define NUMBER_OF_SAVE      5
  16.  
  17. char ExtraInfo1[32] = "Width :       Depth:   " ;
  18. char ExtraInfo2[32] = "Height:       Size :       " ;
  19. char ExtraName[128] ;
  20.  
  21. char *Info_Lines[NUMBER_OF_INFO] = {
  22.    "Image Editor Version 1.0",
  23.    "(c) 1990 by Olaf Leimann",
  24.    "data of current Image :"
  25. };
  26. char *Save_Lines[NUMBER_OF_SAVE] = {
  27.    "/*\n   Image source from ImageEd 1.0 (c)1990 Olaf Leimann\n*/",
  28.    "\nUSHORT ImEd_Data[] = {",
  29.    "\n};\n\nstruct Image ImEd_Image = {\n   ",
  30.    "0,0,   ,   , ,&ImEd_Data[0],\n",
  31.    "      ,   ,NULL\n};\n"
  32. };
  33. char *ImageEdID   = "IMED";
  34. char  ImageSize[] = "   ,   ";
  35. char ImageFileName[128] ;
  36. char UndoBuffer[128] ;
  37.  
  38. UBYTE ImageMultiplier = 2 ;
  39. UBYTE CurrentColour   = 1 ;
  40. UBYTE ImageDrawing    = 0 ;
  41.  
  42. struct Image *ColourImages[4] =
  43. {
  44.    &GadImage0,
  45.    &GadImage1,
  46.    &GadImage2,
  47.    &GadImage3
  48. };
  49.  
  50. struct Image *CurrentImage = NULL ;
  51. struct Image  FirstImage = { 0 } ;
  52. struct Image  BackImage  = { 0 } ;
  53.  
  54. SHORT NameData[10] = {
  55.    -4,-2,
  56.    371-24,-2,
  57.    371-24, 9,
  58.    -4, 9,
  59.    -4,-2
  60. };
  61.  
  62. struct Border NameBorder = {
  63.    0,0, 1,0, JAM1, 5, &NameData[0], NULL
  64. };
  65.  
  66. struct StringInfo NameInfo = {
  67.    (UBYTE *)&ImageFileName[0],
  68.    (UBYTE *)&UndoBuffer[0],
  69.    0, 128, 0
  70. };
  71.  
  72. struct Gadget NameGadget = {
  73.    NULL,
  74.    12,      IMAGE_FROM_TOP + 2,
  75.    370-24,  8,
  76.    GADGHCOMP,
  77.    RELVERIFY|STRINGCENTER,
  78.    STRGADGET,
  79.    (APTR)&NameBorder,
  80.    NULL, NULL, 0L,
  81.    (APTR)&NameInfo,
  82.    100,NULL
  83. };
  84. /*#ENDFD*/
  85.  
  86. LONG CalcPlaneSize(struct Image *im)
  87. /*#FOLD:*/
  88. {
  89.    if(im)
  90.       if(im->PlanePick > 0)
  91.          return ((im->Width + 0x000F)>> 4) * im->Height ;
  92.    return 0L ;
  93. }
  94. /*#ENDFD*/
  95.  
  96. UBYTE CalcDepth(struct Image *im)
  97. /*#FOLD:*/
  98. {
  99.    UBYTE retval,i,j ;
  100.  
  101.    retval = 0 ;
  102.    if(im){
  103.       j = im->PlanePick ;
  104.       for(i=0;i<im->Depth;i++,j >>= 1)
  105.          if(j & 0x01) retval++;
  106.    }
  107.    return retval ;
  108. }
  109. /*#ENDFD*/
  110.  
  111. #define CalcImageSize(im) (CalcPlaneSize(im) * CalcDepth(im))
  112.  
  113. VOID PutNumber(s,n,w)
  114.    char *s ;
  115.    LONG  n ;
  116.    UBYTE w ;
  117. /*#FOLD:*/
  118. {
  119.    if(s){
  120.       if(n==0 && w>0) s[--w] = (n % 10) + 48 ;
  121.       while(w>0 && n>0){
  122.          s[--w] = (n % 10) + 48 ;
  123.          n /= 10 ;
  124.       }
  125.       while(w>0) s[--w] = 32 ;
  126.    }
  127. }
  128. /*#ENDFD*/
  129.  
  130. struct Image *CopyImage(im,imto)
  131.    struct Image *im,*imto ;
  132. /*#FOLD:*/
  133. {
  134.    LONG    Size,sizeto ;
  135.    USHORT *Data ;
  136.  
  137.    if(im != NULL && imto != NULL){
  138.       Size   = CalcImageSize(im)  << 1 ;
  139.       sizeto = CalcImageSize(imto)<< 1 ;
  140.       Data = imto->ImageData ;
  141.  
  142.       if(Size){
  143.          if(Data!=NULL && Size!=sizeto){
  144.             FreeMem((UBYTE *)Data,sizeto);
  145.             Data = NULL ;
  146.          }
  147.          if(Data==NULL)
  148.             Data=(USHORT *)AllocMem(Size,MEMF_CLEAR|MEMF_CHIP);
  149.       }
  150.       else if(Data){
  151.          FreeMem((UBYTE *)Data,sizeto);
  152.          Data = NULL ;
  153.       }
  154.  
  155.       if(Data)
  156.          memcpy((char *)Data,(char *)im->ImageData,Size);
  157.  
  158.       memcpy((char *)imto,(char *)im,sizeof(struct Image));
  159.  
  160.       imto->ImageData = Data ;
  161.       imto->NextImage = NULL ;
  162.  
  163.       return(imto);
  164.    }
  165.    if(im==NULL && imto!=NULL){
  166.       if(Size=(CalcImageSize(imto) << 1))
  167.          FreeMem((UBYTE *)imto->ImageData,Size);
  168.       imto->ImageData = NULL ;
  169.       imto->Width = 0 ;
  170.       imto->Height = 0 ;
  171.       imto->Depth = 0 ;
  172.       imto->PlanePick = 0 ;
  173.    }
  174.    return(NULL);
  175. }
  176. /*#ENDFD*/
  177.  
  178. VOID XImage(im1,im2)
  179.    struct Image *im1,*im2 ;
  180. /*#FOLD:*/
  181. {
  182.    struct Image inter ;
  183.    if(im1!=NULL && im2!=NULL){
  184.       memcpy((char *)&inter,(char *)im1,   sizeof(struct Image));
  185.       memcpy((char *)im1,   (char *)im2,   sizeof(struct Image));
  186.       memcpy((char *)im2,   (char *)&inter,sizeof(struct Image));
  187.    }
  188. }
  189. /*#ENDFD*/
  190.  
  191. #define CopyBackup(im)     CopyImage(im,&BackImage)
  192. #define ReadImage(im)      CopyImage(im,&FirstImage)
  193. #define CopyBackImage(im)  CopyImage(&FirstImage,im)
  194.  
  195. VOID FreeData()
  196. /*#FOLD:*/
  197. {
  198.    LONG Size ;
  199.  
  200.    if(FirstImage.ImageData && (Size= (CalcImageSize(&FirstImage) << 1))){
  201.       FreeMem((UBYTE *)FirstImage.ImageData,Size);
  202.       FirstImage.ImageData = NULL ;
  203.    }
  204.    if(BackImage.ImageData  && (Size= (CalcImageSize(&BackImage)  << 1))){
  205.       FreeMem((UBYTE *)BackImage.ImageData,Size);
  206.       BackImage.ImageData = NULL ;
  207.    }
  208. }
  209. /*#ENDFD*/
  210.  
  211. VOID ChangeImage(mode)
  212.    int mode ;
  213. /*#FOLD:*/
  214. {
  215.    int Size,i ;
  216.  
  217.    if(CurrentImage){
  218.       if(CurrentImage->ImageData){
  219.          Size = CalcImageSize(CurrentImage);
  220.          switch(mode){
  221.          case 0:  /* Clear */
  222.             for(i=0;i<Size;i++){
  223.                CurrentImage->ImageData[i] = 0 ;
  224.             }
  225.             break ;
  226.          case 1:  /* Invert */
  227.             for(i=0;i<Size;i++){
  228.                CurrentImage->ImageData[i] = ~ CurrentImage->ImageData[i];
  229.             }
  230.          }
  231.       }
  232.       else{
  233.          CurrentImage->PlaneOnOff =
  234.             (~CurrentImage->PlaneOnOff) &
  235.             (~((-1)<< CurrentImage->Depth)) &
  236.             (~CurrentImage->PlanePick);
  237.       }
  238.    }
  239. }
  240. /*#ENDFD*/
  241.  
  242. VOID ClearArea(win)
  243.    struct Window *win ;
  244. /*#FOLD:*/
  245. {
  246.    if(win){
  247.       SetAPen(win->RPort,0);
  248.       SetDrMd(win->RPort,JAM1);
  249.       RectFill(win->RPort,
  250.          IMAGE_FROM_LEFT - X_BORDERWIDTH,
  251.          IMAGE_FROM_TOP  - Y_BORDERWIDTH,
  252.          win->Width-4,win->Height-14);
  253.       RectFill(win->RPort,
  254.          IMAGE_FROM_LEFT - X_BORDERWIDTH,
  255.          win->Height-13,
  256.          win->Width -20,win->Height-2);
  257.    }
  258. }
  259. /*#ENDFD*/
  260.  
  261. VOID RefreshImage(win)
  262.    struct Window *win ;
  263. /*#FOLD:*/
  264. {
  265.    int x,y,rx,ry ;
  266.    if(win){
  267.       ClearArea(win);
  268.       if(CurrentImage){
  269.          SetAPen(win->RPort,2);
  270.          RectFill(win->RPort,
  271.             IMAGE_FROM_LEFT - X_BORDERWIDTH,
  272.             IMAGE_FROM_TOP  - Y_BORDERWIDTH,
  273.             CurrentImage->Width * ImageMultiplier
  274.                + IMAGE_FROM_LEFT + X_BORDERWIDTH,
  275.             CurrentImage->Height * ImageMultiplier
  276.                + IMAGE_FROM_TOP  + Y_BORDERWIDTH);
  277.          DrawImage(win->RPort,CurrentImage,
  278.             IMAGE_FROM_LEFT-CurrentImage->LeftEdge,
  279.             IMAGE_FROM_TOP -CurrentImage->TopEdge);
  280.          if(ImageMultiplier > 1){
  281.             for(y=CurrentImage->Height;y>0;y--){
  282.                ry = (y-1)*ImageMultiplier + IMAGE_FROM_TOP ;
  283.                for(x=CurrentImage->Width;x>0;x--){
  284.                   SetAPen(win->RPort,
  285.                      ReadPixel(win->RPort,
  286.                         x+IMAGE_FROM_LEFT-1,
  287.                         y+IMAGE_FROM_TOP-1));
  288.                   rx = (x-1)*ImageMultiplier + IMAGE_FROM_LEFT ;
  289.                   RectFill(win->RPort,rx,ry,
  290.                      rx+ImageMultiplier-1,
  291.                      ry+ImageMultiplier-1);
  292.                }
  293.             }
  294.          }
  295.       }
  296.    }
  297. }
  298. /*#ENDFD*/
  299.  
  300. VOID ShowColour(win)
  301.    struct Window *win ;
  302. /*#FOLD:*/
  303. {
  304.    if(win){
  305.       CurrentColour &= 0x03 ;
  306.       SetAPen(win->RPort,ColourImages[CurrentColour]->PlaneOnOff);
  307.       SetDrMd(win->RPort,JAM1);
  308.       RectFill(win->RPort,
  309.          COLOUR_FROM_LEFT - 4,
  310.          COLOUR_FROM_TOP  - 1,
  311.          COLOUR_FROM_LEFT + 27,
  312.          COLOUR_FROM_TOP  + 12);
  313.       DrawImage(win->RPort,
  314.          ColourImages[CurrentColour],
  315.          COLOUR_FROM_LEFT,
  316.          COLOUR_FROM_TOP);
  317.    }
  318. }
  319. /*#ENDFD*/
  320.  
  321. VOID RefreshMul(win)
  322.    struct Window *win ;
  323. /*#FOLD:*/
  324. {
  325.    UBYTE Number ;
  326.    if(win){
  327.       SetAPen(win->RPort,1);
  328.       SetBPen(win->RPort,2);
  329.       SetDrMd(win->RPort,JAM2);
  330.       Number = ImageMultiplier + 48 ;
  331.       Move(win->RPort,334,12+win->RPort->TxBaseline);
  332.       Text(win->RPort,&Number,1L);
  333.    }
  334. }
  335. /*#ENDFD*/
  336.  
  337. VOID RefreshName(win)
  338.    struct Window *win ;
  339. /*#FOLD:*/
  340. {
  341.    strcpy(&CurrentWindowTitle[0],&FirstWindowTitle[0]);
  342.    strcat(&CurrentWindowTitle[0]," - ");
  343.    strncat(&CurrentWindowTitle[0],&ImageFileName[0],127);
  344.    SetWindowTitles(win,&CurrentWindowTitle[0],(char *)-1L);
  345. }
  346. /*#ENDFD*/
  347.  
  348. VOID PlotImage(win,im,x,y,c)
  349.    struct Window *win ;
  350.    struct Image *im ;
  351.    SHORT  x,y ;
  352.    UBYTE  c ;
  353. /*#FOLD:*/
  354. {
  355.    int    PlaneSize,Plane,index,rx,ry ;
  356.    USHORT bit,*PlaneData ;
  357.    UBYTE  pick ;
  358.  
  359.    if(im){
  360.       if(x>=0 && y>=0 && x<im->Width && y<im->Height){
  361.          if(c != (c & im->PlanePick) | im->PlaneOnOff) return ;
  362.          SetAPen(win->RPort,c);
  363.          SetDrMd(win->RPort,JAM1);
  364.          PlaneSize = CalcPlaneSize(im) ;
  365.          index = y * ((im->Width + 0x000F)>> 4) + (x >> 4);
  366.          bit   = 1 << (15 - (x & 15));
  367.          pick  = im->PlanePick ;
  368.          for(Plane = 0,PlaneData = im->ImageData ;
  369.              Plane < im->Depth ;
  370.              Plane++,PlaneData += PlaneSize){
  371.             if(pick & 0x01){
  372.                if(c & 0x01)
  373.                   PlaneData[index] |=  bit ;
  374.                else
  375.                   PlaneData[index] &= ~bit ;
  376.             }
  377.             pick >>= 1 ;
  378.             c    >>= 1 ;
  379.          }
  380.          if(ImageMultiplier > 1){
  381.             ry = y * ImageMultiplier + IMAGE_FROM_TOP ;
  382.             rx = x * ImageMultiplier + IMAGE_FROM_LEFT ;
  383.             RectFill(win->RPort,rx,ry,
  384.                rx+ImageMultiplier-1,
  385.                ry+ImageMultiplier-1);
  386.          }
  387.          else
  388.             WritePixel(win->RPort,
  389.                x + IMAGE_FROM_LEFT,
  390.                y + IMAGE_FROM_TOP);
  391.       }
  392.    }
  393. }
  394. /*#ENDFD*/
  395.  
  396. VOID WriteHexData(file,data,length)
  397.    BPTR    file ;
  398.    USHORT *data ;
  399.    LONG    length ;
  400. /*#FOLD:*/
  401. {
  402.    int  c=0,c2 ;
  403.    USHORT d;
  404.    UBYTE  e;
  405.    LONG buffer=0L ;
  406.  
  407.    if(file!=NULL && data!=NULL && length>0){
  408.       while(length > 0){
  409.          if((c % 8)==0 && c>0 && length > 1)
  410.             Write(file,(UBYTE *)",\n   0x",7L);
  411.          else if(c>0)
  412.             Write(file,(UBYTE *)",0x",3L);
  413.          else
  414.             Write(file,(UBYTE *)"\n   0x",6L);
  415.          d = *data ;
  416.          for(c2=0;c2<4;c2++){
  417.             e=(d & 0xF000) >> 12;
  418.             d <<= 4 ;
  419.             e  |= 0x30 ;
  420.             if(e > 0x39) e += 7 ;
  421.             buffer <<= 8 ;
  422.             buffer |= e ;
  423.          }
  424.          Write(file,(UBYTE *)&buffer,4L);
  425.          data ++ ;
  426.          length --;
  427.          c ++;
  428.       }
  429.    }
  430. }
  431. /*#ENDFD*/
  432.  
  433. VOID SaveUnder(name,mode)
  434.    char  *name ;
  435.    USHORT mode ;
  436. /*#FOLD:*/
  437. {
  438.    BPTR file ;
  439.    int  i;
  440.  
  441.    if(mode>=0 && mode < 2 && name!=NULL){
  442.       if(mode>0){
  443.          strcpy(&ExtraName[0],name);
  444.          strncat(&ExtraName[0],".h",128);
  445.          name = &ExtraName[0];
  446.       }
  447.       file=Open((UBYTE *)name,MODE_NEWFILE);
  448.       if(file){
  449.          if(CurrentImage){
  450.             if(mode==0){
  451.                Write(file,(UBYTE *)ImageEdID,4L);
  452.                Write(file,(UBYTE *)CurrentImage,sizeof(struct Image));
  453.                Write(file,(UBYTE *)CurrentImage->ImageData,
  454.                   CalcImageSize(CurrentImage)<< 1);
  455.             }
  456.             else{
  457.                for(i=0;i<NUMBER_OF_SAVE;i++){
  458.                   Write(file,(UBYTE *)Save_Lines[i],
  459.                      strlen(Save_Lines[i]));
  460.                   switch(i){
  461.                   case 1:
  462.                      WriteHexData(file,CurrentImage->ImageData,
  463.                         CalcImageSize(CurrentImage));
  464.                      break ;
  465.                   case 2:
  466.                      PutNumber(&Save_Lines[3][4],
  467.                         (LONG)CurrentImage->Width,3);
  468.                      PutNumber(&Save_Lines[3][8],
  469.                         (LONG)CurrentImage->Height,3);
  470.                      PutNumber(&Save_Lines[3][12],
  471.                         (LONG)CurrentImage->Depth,1);
  472.                      break ;
  473.                   case 3:
  474.                      PutNumber(&Save_Lines[4][3],
  475.                         (LONG)CurrentImage->PlanePick,3);
  476.                      PutNumber(&Save_Lines[4][7],
  477.                         (LONG)CurrentImage->PlaneOnOff,3);
  478.                      break ;
  479.                   }
  480.                }
  481.             }
  482.          }
  483.          Close(file);
  484.       }
  485.    }
  486. }
  487. /*#ENDFD*/
  488.  
  489. struct Image *LoadUnder(name)
  490.    char *name ;
  491. /*#FOLD:*/
  492. {
  493.    BPTR file ;
  494.    LONG id=0,Size ;
  495.    USHORT *buffer=NULL ;
  496.    struct Image im,*retval ;
  497.    if(name){
  498.       retval = NULL ;
  499.       file=Open(name,MODE_OLDFILE);
  500.       if(file){
  501.          Read(file,(UBYTE *)&id,4L);
  502.          if(strcmp((char *)&id,ImageEdID)==0){
  503.             Read(file,(UBYTE *)&im,sizeof(struct Image));
  504.             im.ImageData = NULL ;
  505.             Size=CalcImageSize(&im);
  506.             if(Size){
  507.                buffer = (USHORT *)AllocMem(
  508.                   Size << 1,MEMF_CLEAR|MEMF_CHIP);
  509.                if(buffer){
  510.                   im.ImageData = buffer ;
  511.                   Read(file,(UBYTE *)buffer,Size << 1);
  512.                }
  513.             }
  514.             retval = ReadImage(&im) ;
  515.             if(im.ImageData){
  516.                FreeMem((UBYTE *)im.ImageData,Size);
  517.                im.ImageData = NULL ;
  518.             }
  519.          }
  520.          Close(file);
  521.       }
  522.    }
  523.    return(retval);
  524. }
  525. /*#ENDFD*/
  526.  
  527. VOID Rectangle(win,im,c)
  528.    struct Window *win ;
  529.    struct Image  *im ;
  530.    UBYTE          c ;
  531. /*#FOLD:*/
  532. {
  533.    SetAPen(win->RPort,c);
  534.    SetDrMd(win->RPort,JAM1);
  535.    Move(win->RPort,
  536.       IMAGE_FROM_LEFT,                 IMAGE_FROM_TOP);
  537.    Draw(win->RPort,
  538.       im->Width + IMAGE_FROM_LEFT - 1, IMAGE_FROM_TOP);
  539.    Draw(win->RPort,
  540.       im->Width + IMAGE_FROM_LEFT - 1, im->Height + IMAGE_FROM_TOP - 1);
  541.    Draw(win->RPort,
  542.       IMAGE_FROM_LEFT,                 im->Height + IMAGE_FROM_TOP - 1);
  543.    Draw(win->RPort,
  544.       IMAGE_FROM_LEFT,                 IMAGE_FROM_TOP);
  545.    PutNumber(&ImageSize[0],im->Width,3);
  546.    PutNumber(&ImageSize[4],im->Height,3);
  547.    Move(win->RPort,
  548.       IMAGE_FROM_LEFT + 8,
  549.       IMAGE_FROM_TOP + 8 + win->RPort->TxBaseline);
  550.    Text(win->RPort,&ImageSize[0],7L);
  551. }
  552. /*#ENDFD*/
  553.  
  554. struct Image *GetNewImage(win,msg)
  555.    struct Window *win ;
  556.    struct IntuiMessage *msg ;
  557. /*#FOLD:*/
  558. {
  559.    struct Image im,*retval ;
  560.    int   quit=0,Drawing=0;
  561.    ULONG  class,Size ;
  562.    USHORT code ;
  563.    SHORT  Mx,My ;
  564.  
  565.    im.LeftEdge =  0 ;
  566.    im.TopEdge  =  0 ;
  567.    im.Width    = 16 ;
  568.    im.Height   = 16 ;
  569.    im.Depth    =  2 ;
  570.    im.PlanePick   = 3 ;
  571.    im.PlaneOnOff  = 0 ;
  572.    im.NextImage   = NULL ;
  573.  
  574.    ClearArea(win);
  575.    Rectangle(win,&im,1);
  576.    while(quit==0){
  577.       msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  578.       if(msg==NULL){
  579.          WaitPort(win->UserPort);
  580.          msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  581.       }
  582.       class = msg->Class ;
  583.       if(class==GADGETUP || class==GADGETDOWN)
  584.          code = ((struct Gadget *)msg->IAddress)->GadgetID ;
  585.       else
  586.          code = msg->Code ;
  587.       Mx = msg->MouseX ;
  588.       My = msg->MouseY ;
  589.       ReplyMsg((struct Message *)msg);
  590.       switch(class){
  591.       case CLOSEWINDOW:
  592.             quit=-1;
  593.             break ;
  594.       case GADGETUP:
  595.             if(code == 3) /* Refresh Gadget */
  596.                quit=1;
  597.             break ;
  598.       case MOUSEMOVE:
  599.             if(Drawing)
  600.                code = SELECTDOWN ;
  601.             else
  602.                break ;
  603.       case MOUSEBUTTONS:
  604.             if(code==SELECTDOWN){
  605.                if(Mx > IMAGE_FROM_LEFT && My > IMAGE_FROM_TOP){
  606.                   Rectangle(win,&im,0);
  607.                   im.Width = Mx-IMAGE_FROM_LEFT ;
  608.                   im.Height= My-IMAGE_FROM_TOP  ;
  609.                   Rectangle(win,&im,1);
  610.                }
  611.                Drawing = 1;
  612.             }
  613.             else
  614.                Drawing = 0;
  615.             break;
  616.       }
  617.    }
  618.    if(quit>0){
  619.       im.ImageData = (USHORT *)AllocMem(
  620.          Size=(CalcImageSize(&im) << 1),MEMF_CLEAR|MEMF_CHIP);
  621.       if(CurrentImage) CopyBackup(CurrentImage);
  622.       if(im.ImageData) retval = ReadImage(&im);
  623.       FreeMem((UBYTE *)im.ImageData,Size);
  624.       im.ImageData = NULL ;
  625.    }
  626.    else
  627.       retval = CurrentImage ;
  628.    return(retval);
  629. }
  630. /*#ENDFD*/
  631.  
  632. VOID GetName(win,msg)
  633.    struct Window *win ;
  634.    struct IntuiMessage *msg ;
  635. /*#FOLD:*/
  636. {
  637.    int   quit=0;
  638.    ULONG  class ;
  639.    USHORT code ;
  640.  
  641.       if(strlen(ImageFileName)==0)
  642.          strcpy(ImageFileName,"WorkingImage");
  643.       NameInfo.DispPos = 0 ;
  644.       NameInfo.BufferPos = 0 ;
  645.       NameGadget.Height = win->RPort->TxHeight ;
  646.       NameData[5]= NameGadget.Height + 1 ;
  647.       NameData[7]= NameGadget.Height + 1 ;
  648.       ClearArea(win);
  649.       AddGadget(win,&NameGadget,-1);
  650.       RefreshGadgets(&NameGadget,win,NULL);
  651.       ActivateGadget(&NameGadget,win,NULL);
  652.       while(quit==0){
  653.          msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  654.          if(msg==NULL){
  655.             WaitPort(win->UserPort);
  656.             msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  657.          }
  658.          class = msg->Class ;
  659.          if(class==GADGETUP || class==GADGETDOWN)
  660.             code = ((struct Gadget *)msg->IAddress)->GadgetID ;
  661.          else
  662.             code = msg->Code ;
  663.          ReplyMsg((struct Message *)msg);
  664.          if(class==GADGETUP && code==100) quit = 1 ;
  665.          if(class==CLOSEWINDOW) quit = 1 ;
  666.       }
  667.       RemoveGadget(win,&NameGadget);
  668. }
  669. /*#ENDFD*/
  670.  
  671. VOID ShowInfo(win)
  672.    struct Window *win ;
  673. /*#FOLD:*/
  674. {
  675.    int i,y,max;
  676.    if(win){
  677.       ClearArea(win);
  678.       y   = IMAGE_FROM_TOP + win->RPort->TxBaseline ;
  679.       max = NUMBER_OF_INFO - 3 ;
  680.       if(CurrentImage){
  681.          PutNumber(&ExtraInfo1[8],(LONG)CurrentImage->Width,3);
  682.          PutNumber(&ExtraInfo2[8],(LONG)CurrentImage->Height,3);
  683.          PutNumber(&ExtraInfo1[21],(LONG)CurrentImage->Depth,1);
  684.          PutNumber(&ExtraInfo2[21],(LONG)CalcImageSize(CurrentImage),6);
  685.          Info_Lines[3] = &ExtraInfo1[0] ;
  686.          Info_Lines[4] = &ExtraInfo2[0] ;
  687.          max = NUMBER_OF_INFO ;
  688.       }
  689.       for(i=0; i < max;i++,y+=win->RPort->TxHeight){
  690.          SetAPen(win->RPort,1);
  691.          Move(win->RPort,IMAGE_FROM_LEFT,y);
  692.          Text(win->RPort,Info_Lines[i],strlen(Info_Lines[i]));
  693.       }
  694.    }
  695. }
  696. /*#ENDFD*/
  697.  
  698. VOID HandleImaging(win)
  699.    struct Window *win ;
  700. /*#FOLD:*/
  701. {
  702.    struct IntuiMessage *msg ;
  703.    struct Gadget       *gad=NULL ;
  704.    struct Image        *im ;
  705.    int    quit = 0 ;
  706.    ULONG  class ;
  707.    SHORT  Mx,My ;
  708.    USHORT code,id ;
  709.    if(win){
  710.       ShowColour(win);
  711.       RefreshMul(win);
  712.       RefreshImage(win);
  713.       while(quit==0){
  714.          msg = (struct IntuiMessage *)GetMsg(win->UserPort);
  715.          if(msg==NULL){
  716.             WaitPort(win->UserPort);
  717.             msg = (struct IntuiMessage *)GetMsg(win->UserPort);
  718.          }
  719.           class = msg->Class ;
  720.           code = msg->Code ;
  721.           Mx = msg->MouseX ;
  722.           My = msg->MouseY ;
  723.           if(class == GADGETUP || class == GADGETDOWN)
  724.              id = ((struct Gadget *)msg->IAddress)->GadgetID ;
  725.          ReplyMsg((struct Message *)msg);
  726.          switch(class){
  727. /*#FOLD:*/
  728.          case CLOSEWINDOW:
  729.             quit=1;
  730.             break;
  731.          case GADGETUP:
  732.             switch(id){
  733.             case 1:         /* Clear */
  734.                ChangeImage(0);
  735.                break;
  736.             case 2:         /* Invert */
  737.                ChangeImage(1);
  738.                break;
  739.             case 3:
  740.                break;
  741.             }
  742.             CopyBackup(CurrentImage);
  743.             RefreshImage(win);
  744.             break;
  745.          case GADGETDOWN:
  746.             CurrentColour=id-4;
  747.             ShowColour(win);
  748.             break;
  749.          case MOUSEMOVE:
  750.             if(ImageDrawing)
  751.                code = SELECTDOWN ;
  752.             else
  753.                break ;
  754.          case MOUSEBUTTONS:
  755.             if(code == SELECTDOWN){    /* SetPoint */
  756.                if(CurrentImage){
  757.                   if(Mx > IMAGE_FROM_LEFT &&
  758.                      My > IMAGE_FROM_TOP){
  759.                      PlotImage(win,CurrentImage,
  760.                         (Mx - IMAGE_FROM_LEFT)/ImageMultiplier,
  761.                         (My - IMAGE_FROM_TOP)/ImageMultiplier,
  762.                         CurrentColour);
  763.                   }
  764.                   ImageDrawing = 1 ;
  765.                }
  766.             }
  767.             else ImageDrawing = 0 ;
  768.             break;
  769.          case MENUPICK:
  770.             if(code!=MENUNULL)
  771.             switch(MENUNUM(code)){
  772.             case 0:
  773.                switch(ITEMNUM(code)){
  774.                case 0:
  775.                   CurrentImage = GetNewImage(win,msg);
  776.                   RefreshImage(win);
  777.                   break;
  778.                case 1:
  779.                   if(CurrentImage) CopyBackup(CurrentImage);
  780.                   GetName(win,msg);
  781.                   CurrentImage = LoadUnder(&ImageFileName[0]);
  782.                   RefreshImage(win);
  783.                   RefreshName(win);
  784.                   break;
  785.                case 2:
  786.                   if(strlen(&ImageFileName[0])){
  787.                      if(CurrentImage)
  788.                         SaveUnder(&ImageFileName[0],SUBNUM(code));
  789.                      break ;
  790.                   }
  791.                case 3:
  792.                   if(CurrentImage){
  793.                      GetName(win,msg);
  794.                      if(strlen(&ImageFileName[0]))
  795.                         SaveUnder(&ImageFileName[0],SUBNUM(code));
  796.                      RefreshImage(win);
  797.                      RefreshName(win);
  798.                   }
  799.                   break;
  800.                case 4:
  801.                   quit=1;
  802.                   break;
  803.                case 5:
  804.                   ShowInfo(win);
  805.                   break;
  806.                }
  807.                break ;
  808.             case 1:
  809.                switch(ITEMNUM(code)){
  810.                case 0:        /* Image from first gadget */
  811.                   gad = win->FirstGadget ;
  812.                   if(gad){
  813.                      CopyBackup(CurrentImage);
  814.                      im = NULL ;
  815.                      while(gad != NULL && im == NULL){
  816.                         if((gad->Flags & GADGIMAGE) &&
  817.                            (gad->GadgetType & SYSGADGET))
  818.                            im = (struct Image *)gad->GadgetRender ;
  819.                         else
  820.                            gad = gad->NextGadget ;
  821.                      }
  822.                      CurrentImage = ReadImage(im);
  823.                      RefreshImage(win);
  824.                   }
  825.                   else DisplayBeep(win->WScreen);
  826.                   break ;
  827.                case 1:        /* Image from next gadget */
  828.                   if(gad)       gad = gad->NextGadget ;
  829.                   if(gad==NULL) gad = win->WScreen->FirstGadget ;
  830.                   if(gad){
  831.                      CopyBackup(CurrentImage);
  832.                      im = NULL ;
  833.                      while(gad != NULL && im == NULL){
  834.                         if((gad->Flags & GADGIMAGE) &&
  835.                            (gad->GadgetType & 0x00F0))
  836.                            im = (struct Image *)gad->GadgetRender ;
  837.                         else
  838.                            gad = gad->NextGadget ;
  839.                      }
  840.                      CurrentImage = ReadImage(im);
  841.                      RefreshImage(win);
  842.                   }
  843.                   else DisplayBeep(0);
  844.                   break;
  845.                case 2:        /* Copy back to real gadget */
  846.                   if(gad){
  847.                      if(gad->Flags & GADGIMAGE){
  848.                         CopyBackImage((struct Image *)gad->GadgetRender);
  849.                         RefreshGadgets(win->FirstGadget,win,NULL);
  850.                      }
  851.                   }
  852.                   else DisplayBeep(win->WScreen);
  853.                   break;
  854.                }
  855.                break ;
  856.             case 2:
  857.                switch(ITEMNUM(code)){
  858.                case 0:
  859.                   if(CalcImageSize(&BackImage)){
  860.                      XImage(&BackImage,&FirstImage);
  861.                      CurrentImage = &FirstImage ;
  862.                      RefreshImage(win);
  863.                   }
  864.                   break;
  865.                case 1:
  866.                   if(ImageMultiplier < 8){
  867.                      ImageMultiplier++;
  868.                      RefreshMul(win);
  869.                      if(CurrentImage)
  870.                         RefreshImage(win);
  871.                   }
  872.                   break ;
  873.                case 2:
  874.                   if(ImageMultiplier > 1){
  875.                      ImageMultiplier--;
  876.                      RefreshMul(win);
  877.                      if(CurrentImage)
  878.                         RefreshImage(win);
  879.                   }
  880.                   break ;
  881.                case 3:
  882.                   ImageMultiplier = 1;
  883.                   RefreshMul(win);
  884.                   if(CurrentImage)
  885.                      RefreshImage(win);
  886.                   break ;
  887.                case 4:
  888.                   ImageMultiplier = 8;
  889.                   RefreshMul(win);
  890.                   if(CurrentImage)
  891.                      RefreshImage(win);
  892.                   break ;
  893.                }
  894.             }
  895.             break;
  896. /*#ENDFD*/
  897.          }
  898.       }
  899.    }
  900.    FreeData();
  901. }
  902. /*#ENDFD*/
  903.  
  904.