home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 532.lha / NLDaemon / Source / NL-Handler.c < prev    next >
C/C++ Source or Header  |  1991-07-09  |  9KB  |  323 lines
  1. /*
  2.  *  NL-Daemon   A program to force old programs to use NL gadget imagery.
  3.  *
  4.  *              Copyright 1989 by Davide P. Cervone.
  5.  *  You may use this code, provided this copyright notice is kept intact.
  6.  */
  7.  
  8. #include "NL-Handler.h"
  9.  
  10. static char *program   = PROGRAM;
  11. static char *copyright = COPYRIGHT;
  12.  
  13.  
  14. /*
  15.  *  The following are the data for the Image structures used to
  16.  *  replace the standard Intuition gadget images
  17.  */
  18.  
  19. extern USHORT UpFrontData[UPDEPTH][UPHEIGHT*UPWORDS];
  20. extern USHORT DownBackData[DOWNDEPTH][DOWNHEIGHT*DOWNWORDS];
  21. extern USHORT SizeData[SIZEDEPTH][SIZEHEIGHT*SIZEWORDS];
  22. extern USHORT CloseData[CLOSEDEPTH][CLOSEHEIGHT*CLOSEWORDS];
  23. extern USHORT ZoomData[ZOOMDEPTH][ZOOMHEIGHT*ZOOMWORDS];
  24.  
  25. extern USHORT LR_UpFrontData[LR_UPDEPTH][LR_UPHEIGHT*LR_UPWORDS];
  26. extern USHORT LR_DownBackData[LR_DOWNDEPTH][LR_DOWNHEIGHT*LR_DOWNWORDS];
  27. extern USHORT LR_SizeData[LR_SIZEDEPTH][LR_SIZEHEIGHT*LR_SIZEWORDS];
  28. extern USHORT LR_CloseData[LR_CLOSEDEPTH][LR_CLOSEHEIGHT*LR_CLOSEWORDS];
  29. extern USHORT LR_ZoomData[LRZOOMDEPTH][LRZOOMHEIGHT*LRZOOMWORDS];
  30.  
  31. struct Image UpFrontImage =
  32.    {0,0, UPWIDTH,UPHEIGHT,UPDEPTH, &UpFrontData[0][0], 0x03,0x00, NULL};
  33.  
  34. struct Image DownBackImage =
  35.    {0,0, DOWNWIDTH,DOWNHEIGHT,DOWNDEPTH, &DownBackData[0][0], 0x03,0x00, NULL};
  36.  
  37. struct Image SizeImage =
  38.    {0,0, SIZEWIDTH,SIZEHEIGHT,SIZEDEPTH, &SizeData[0][0], 0x03,0x00, NULL};
  39.  
  40. struct Image CloseImage =
  41.    {0,0, CLOSEWIDTH,CLOSEHEIGHT,CLOSEDEPTH, &CloseData[0][0], 0x03,0x00, NULL};
  42.  
  43. struct Image ZoomImage =
  44.    {-3,0, ZOOMWIDTH,ZOOMHEIGHT,ZOOMDEPTH, &ZoomData[0][0], 0x03,0x00, NULL};
  45.  
  46.  
  47. struct Image LR_UpFrontImage =
  48.    {0,0, LR_UPWIDTH,LR_UPHEIGHT,LR_UPDEPTH, &LR_UpFrontData[0][0],
  49.     0x03,0x00, NULL};
  50.  
  51. struct Image LR_DownBackImage =
  52.    {0,0, LR_DOWNWIDTH,LR_DOWNHEIGHT,LR_DOWNDEPTH, &LR_DownBackData[0][0],
  53.     0x03,0x00, NULL};
  54.  
  55. struct Image LR_SizeImage =
  56.    {0,0, LR_SIZEWIDTH,LR_SIZEHEIGHT,LR_SIZEDEPTH, &LR_SizeData[0][0],
  57.     0x03,0x00, NULL};
  58.  
  59. struct Image LR_CloseImage =
  60.    {0,0, LR_CLOSEWIDTH,LR_CLOSEHEIGHT,LR_CLOSEDEPTH, &LR_CloseData[0][0],
  61.     0x03,0x00, NULL};
  62.  
  63. struct Image LR_ZoomImage =
  64.    {-2,0, LRZOOMWIDTH,LRZOOMHEIGHT,LRZOOMDEPTH, &LR_ZoomData[0][0],
  65.    0x03,0x00,NULL};
  66.  
  67.  
  68. /*
  69.  *  SetImage()
  70.  *
  71.  *  Saves the gadget's current image pointer in the SelectRender field
  72.  *  and the width and left edge in the UserData field so that we can 
  73.  *  replace them if NL-Daemon is removed.  Then we set the Render 
  74.  *  pointer to the Image we want, and fix the size and positioning
  75.  *  appropriately.
  76.  */
  77.  
  78. static void SetImage(theGadget,theImage,x,w)
  79. struct Gadget *theGadget;
  80. struct Image *theImage;
  81. int x,w;
  82. {
  83.    theGadget->SelectRender = theGadget->GadgetRender;
  84.    theGadget->UserData =
  85.       (APTR)((((LONG)(theGadget->LeftEdge)) << 16) | theGadget->Width);
  86.    theGadget->GadgetRender = (APTR)theImage;
  87.    if (x != SAME) theGadget->LeftEdge = x;
  88.    theGadget->Width = theImage->Width - w;
  89. }
  90.  
  91.  
  92. /*
  93.  *  SetupGadget()
  94.  *
  95.  *  Changes the gadget imagery from the standard Intuition images to the
  96.  *  New Look images.  Uses the SYSGADGET flag and the Intuition identification
  97.  *  numbers to tell which gadget is which.  Also modifies the gadget's
  98.  *  width and left edge position to fit the new imagery.
  99.  *
  100.  *  Since the gadgets are only copies of the standard ones, changing these
  101.  *  is safe, and does not effect any other window.  Since Intuition cleans
  102.  *  up after the gadgets (and uses static images of its own) replacing
  103.  *  the imagery does not require any special clean up on our part.
  104.  */
  105.  
  106. void SetupGadgets(theGadget,Depth,Resolution,theWindow)
  107. struct Gadget *theGadget;
  108. int Depth;
  109. ULONG Resolution;
  110. struct Window *theWindow;
  111. {
  112.    int dx = 0;
  113.    
  114.    while (theGadget)
  115.    {
  116.       switch(theGadget->GadgetType & ~GADGETTYPE)
  117.       {
  118.          case SIZING:
  119.             if (Resolution == HIRES)
  120.                SetImage(theGadget,&SizeImage,SAME,0);
  121.               else
  122.                SetImage(theGadget,&LR_SizeImage,SAME,0);
  123.             break;
  124.  
  125.          case WUPFRONT:
  126.          case SUPFRONT:
  127.             if (Depth > 1)
  128.             {
  129.                if (Resolution == HIRES)
  130.                   SetImage(theGadget,&UpFrontImage,-UpFrontImage.Width+1,0);
  131.                  else
  132.                   SetImage(theGadget,&LR_UpFrontImage,SAME,0);
  133.             }
  134.             break;
  135.  
  136.          case WDOWNBACK:
  137.          case SDOWNBACK:
  138.             if (Depth > 1)
  139.             {
  140.                if (Resolution == HIRES)
  141.                   SetImage(theGadget,&DownBackImage,
  142.                      -(UpFrontImage.Width+DownBackImage.Width) + 1,0);
  143.                  else
  144.                   SetImage(theGadget,&LR_DownBackImage,SAME,0);
  145.             }
  146.             break;
  147.  
  148.          case CLOSE:
  149.             if (Resolution == HIRES)
  150.                SetImage(theGadget,&CloseImage,0,0);
  151.               else
  152.                SetImage(theGadget,&LR_CloseImage,0,0);
  153.             break;
  154.  
  155.          case BOOLGADGET:
  156.             if (theGadget->GadgetID == ZOOMGADG && Depth > 1 && theWindow)
  157.             {
  158.                if (Resolution == HIRES)
  159.                {
  160.                   dx = (theWindow->Flags & WINDOWDEPTH)? 2: 0;
  161.                   SetImage(theGadget,&ZoomImage,theGadget->LeftEdge+dx,3);
  162.                } else {
  163.                   dx = (theWindow->Flags & WINDOWDEPTH)? -2: 0;
  164.                   SetImage(theGadget,&LR_ZoomImage,theGadget->LeftEdge+dx,2);
  165.                }
  166.             }
  167.             break;
  168.       }
  169.       theGadget = theGadget->NextGadget;
  170.    }
  171. }
  172.  
  173.  
  174. /*
  175.  *  cOpenWindow()
  176.  *
  177.  *  This is called after a window has been opened:  theWindow is the 
  178.  *  pointer to the opened window.
  179.  *
  180.  *  If the window has standard IntuitionGadgets or if it receives NEWSIZE
  181.  *  IDCMP messages (which means ZOOM-DAEMON may have added a gadget) then
  182.  *  go through the gadget list to replace the imagery.
  183.  *
  184.  *  If the Detail and Block pens are the standard ones, change them to the
  185.  *  ones needed by NL-Daemon.
  186.  *
  187.  *  Once everything is set up, refresh the window imagery.
  188.  */
  189.  
  190. struct Window *cOpenWindow(theWindow)
  191. struct Window *theWindow;
  192. {
  193.    int Depth;
  194.    ULONG Resolution;
  195.  
  196.    if (theWindow)
  197.    {
  198.       Depth = theWindow->WScreen->BitMap.Depth;
  199.       Resolution = theWindow->WScreen->ViewPort.Modes & HIRES;
  200.       if ((theWindow->Flags & (WINDOWGADGETS)) ||
  201.           (theWindow->IDCMPFlags & NEWSIZE))
  202.               SetupGadgets(theWindow->FirstGadget,Depth,Resolution,theWindow);
  203.       if (Depth > 1)
  204.       {
  205.          if (theWindow->BlockPen == STDBLOCKPEN)
  206.          {
  207.             theWindow->BlockPen = BLOCKPEN | PENCHANGED;
  208.             if (theWindow->DetailPen == STDDETAILPEN ||
  209.                 theWindow->DetailPen == BLOCKPEN)
  210.                    theWindow->DetailPen = DETAILPEN | PENCHANGED;
  211.          }
  212.       }
  213.       RefreshWindowFrame(theWindow);
  214.    }
  215.    return(theWindow);
  216. }
  217.  
  218.  
  219. /*
  220.  *  CheckText()
  221.  *
  222.  *  Check the text DrawMode for needed changes.  If the draw mode is 
  223.  *  COMPLEMENT, then change it to JAM1 and set the color.  If it is JAM2,
  224.  *  make sure the background color is OK.  If wither JAM1 or JAM2, check
  225.  *  that the forground color is OK.
  226.  */
  227.  
  228. static void CheckText(theText)
  229. struct IntuiText *theText;
  230. {
  231.    if (theText)
  232.    {
  233.       switch(theText->DrawMode)
  234.       {
  235. /*
  236.          case COMPLEMENT:
  237.             theText->DrawMode = JAM1;
  238.             theText->FrontPen = DETAILPEN | PENCHANGED;
  239.             break;
  240. */
  241.  
  242.          case JAM2:
  243.             if (theText->BackPen == STDBLOCKPEN)
  244.                theText->BackPen = BLOCKPEN | PENCHANGED;
  245.          case JAM1:
  246.             if (theText->FrontPen == BLOCKPEN ||
  247.                 theText->FrontPen == STDDETAILPEN)
  248.                    theText->FrontPen = DETAILPEN | PENCHANGED;
  249.             break;
  250.       }
  251.    }
  252. }
  253.  
  254.  
  255. /*
  256.  *  CheckItemList()
  257.  *
  258.  *  Look through a MenuItem list and check each item for IntuiTexts
  259.  *  that may need to be changed.  Also check any sub-menus.
  260.  */
  261.  
  262. static void CheckItemList(theItem)
  263. struct MenuItem *theItem;
  264. {
  265.    while (theItem)
  266.    {
  267.       if (theItem->Flags & ITEMTEXT)
  268.       {
  269.          CheckText(theItem->ItemFill);
  270.          if (theItem->Flags & HIGHIMAGE) CheckText(theItem->SelectFill);
  271.       }
  272.       CheckItemList(theItem->SubItem);
  273.       theItem = theItem->NextItem;
  274.    }
  275. }
  276.    
  277.  
  278. /*
  279.  *  cSetMenuStrip()
  280.  *
  281.  *  Our replacement for SetMenuStrip.  It is called before the real
  282.  *  set menu strip.
  283.  *
  284.  *  If the window has had it's BlockPen altered, then look through
  285.  *  each menu for IntuiTexts for IntuiTexts that may need to be changed.
  286.  */
  287.  
  288. void cSetMenuStrip(theWindow,theMenu)
  289. struct Window *theWindow;
  290. struct Menu *theMenu;
  291. {
  292.    if (theWindow->BlockPen & PENCHANGED)
  293.    {
  294.       while (theMenu)
  295.       {
  296.          CheckItemList(theMenu->FirstItem);
  297.          theMenu = theMenu->NextMenu;
  298.       }
  299.    }
  300. }
  301.  
  302. struct Screen *cOpenScreen(theScreen)
  303. struct Screen *theScreen;
  304. {
  305.    if (theScreen)
  306.    {
  307.       if (theScreen->BitMap.Depth > 1)
  308.       {
  309.          SetupGadgets(theScreen->FirstGadget,theScreen->BitMap.Depth,
  310.                      (theScreen->ViewPort.Modes & HIRES),NULL);
  311.          if (theScreen->BlockPen == STDBLOCKPEN)
  312.          {
  313.             theScreen->BlockPen = BLOCKPEN | PENCHANGED;
  314.             if (theScreen->DetailPen == STDDETAILPEN ||
  315.                 theScreen->DetailPen == BLOCKPEN)
  316.                    theScreen->DetailPen = DETAILPEN | PENCHANGED;
  317.          }
  318.          ShowTitle(theScreen,(theScreen->Flags & SHOWTITLE)? TRUE: FALSE);
  319.       }
  320.    }
  321.    return(theScreen);
  322. }
  323.