home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / Intuition / Window / Window.c
Encoding:
C/C++ Source or Header  |  1995-02-12  |  15.7 KB  |  847 lines
  1.  
  2. #include <classes/Intuition/Window.h>
  3.  
  4. #pragma -
  5. #include <pragma/intuition_lib.h>
  6. #include <pragma/exec_lib.h>
  7. #include <pragma/layers_lib.h>
  8. #pragma +
  9.  
  10. #ifndef CPP_LIBRARIES_GADTOOLS_H
  11. #include <classes/libraries/gadtools.h>
  12. #endif
  13.  
  14. #ifndef EXEC_LIBRARIES_H
  15. #include <exec/libraries.h>
  16. #endif
  17.  
  18. extern struct Library *IntuitionBase;
  19.  
  20. WindowSnapshotC::WindowSnapshotC()
  21. {
  22. }
  23.  
  24. // *************************************************************
  25.  
  26. WindowC::WindowC(IDCMPortC &p, Tag tag1Type, ...)
  27.     : idcmport(p), inittags((struct TagItem *) &tag1Type)
  28. {
  29.     window_ob = NULL;
  30.     menuattached = FALSE;
  31.     menu = NULL;
  32.     idcmps = inittags.getData(WA_IDCMP, 0);
  33.     inittags.filter(TAGFILTER_NOT,WA_IDCMP,WA_Gadgets,TAG_END);
  34.     gadgetlistattached = FALSE;
  35.     gadgets = NULL;
  36.     busy = FALSE;
  37.     busyReq = NULL;
  38. }
  39.  
  40. WindowC::WindowC(IDCMPortC &p, struct TagItem *tags)
  41.     : idcmport(p), inittags(tags)
  42. {
  43.     window_ob = NULL;
  44.     menuattached = FALSE;
  45.     menu = NULL;
  46.     idcmps = inittags.getData(WA_IDCMP, 0);
  47.     inittags.filter(TAGFILTER_NOT,WA_IDCMP,WA_Gadgets,TAG_END);
  48.     gadgetlistattached = FALSE;
  49.     gadgets = NULL;
  50.     busy = FALSE;
  51.     busyReq = NULL;
  52. }
  53.  
  54. WindowC::WindowC(const WindowC &s)
  55.     : idcmport(s.idcmport), inittags(s.inittags)
  56. {
  57.     window_ob = NULL;
  58.     menuattached = s.menuattached;
  59.     menu = s.menu;
  60.     idcmps = s.idcmps;
  61.     gadgetlistattached = FALSE;
  62.     gadgets = NULL;
  63.     busy = s.busy;
  64.     busyReq = NULL;
  65. }
  66.  
  67. WindowC::~WindowC()
  68. {
  69.     close();
  70. }
  71.  
  72. WindowC &WindowC::operator= (const WindowC &s)
  73. {
  74.     if (this != &s)
  75.     {
  76.         close();
  77.         idcmport = s.idcmport;
  78.         inittags = s.inittags;
  79.         window_ob = NULL;
  80.         menuattached = s.menuattached;
  81.         menu = s.menu;
  82.         idcmps = s.idcmps;
  83.         gadgetlistattached = FALSE;
  84.         gadgets = NULL;
  85.         busy = s.busy;
  86.         busyReq = NULL;
  87.     };
  88.     return *this;
  89. }
  90.  
  91. VOID WindowC::open(struct TagItem *tagList)
  92. {
  93.     if (window_ob)
  94.         return;
  95.     TagItemC t = inittags;
  96.     t.set(tagList);
  97.     idcmps |= t.getData(WA_IDCMP, 0);
  98.     t.filter(TAGFILTER_NOT,WA_IDCMP,TAG_END);
  99.     if (gadgets && gadgets->gadget())
  100.     {
  101.         t.set(WA_Gadgets,gadgets->gadget(),TAG_END);
  102.         gadgetlistattached = TRUE;
  103.     }
  104.     else {
  105.         t.set(WA_Gadgets,NULL,TAG_END);
  106.         gadgetlistattached = FALSE;
  107.     };
  108.     if ((window_ob = OpenWindowTagList(NULL,t.tags())) == NULL)
  109.         throw WindowX();
  110.     window_ob->UserData = (BYTE *) this;
  111.     window_ob->UserPort = idcmport.port();
  112.     if (idcmps != 0)
  113.         ModifyIDCMP(window_ob,idcmps);
  114.     if (menu)
  115.         menuattached =  SetMenuStrip(window_ob,menu->menu());
  116. //    resetGadgetList();
  117.     setBusy(busy);
  118. }
  119.  
  120. VOID WindowC::close(BOOL snapshot)
  121. {
  122.     if (window_ob)
  123.     {
  124.         if (snapshot)
  125.         {
  126.             inittags.set(
  127.                 WA_Left, window_ob->LeftEdge,
  128.                 WA_Top, window_ob->TopEdge,
  129.                 WA_Width, window_ob->Width,
  130.                 WA_Height, window_ob->Height,
  131.                 TAG_END);
  132.         };
  133.         clearBusy();
  134.         clearMenuStrip();
  135.         clearGadgetList(FALSE,FALSE);
  136.         freeIDCMP();
  137.         CloseWindow(window_ob);
  138.         window_ob = NULL;
  139.     }
  140. }
  141.  
  142. // *************************************************************
  143.  
  144. VOID WindowC::setIDCMP(ULONG idcmpFlags)
  145. {
  146.     if (window_ob)
  147.     {
  148.         if (idcmpFlags)
  149.         {
  150.             if (!idcmps)
  151.                 window_ob->UserPort = idcmport.port();
  152.             ModifyIDCMP(window_ob,idcmpFlags);
  153.         }
  154.         else
  155.             freeIDCMP();
  156.     };
  157.     idcmps = idcmpFlags;
  158. }
  159.  
  160. VOID WindowC::addIDCMP(ULONG idcmpFlags)
  161. {
  162.     setIDCMP(idcmps|idcmpFlags);
  163. }
  164.  
  165. VOID WindowC::subIDCMP(ULONG idcmpFlags)
  166. {
  167.     setIDCMP(idcmps&(!idcmpFlags));
  168. }
  169.  
  170. // *************************************************************
  171.  
  172. BOOL WindowC::setMenuStrip(class MenuC &m)
  173. {
  174.     clearMenuStrip();
  175.     menu = &m;
  176.     if (window_ob)
  177.     {
  178.         menuattached =  SetMenuStrip(window_ob,menu->menu());
  179.         return menuattached;
  180.     };
  181.     return FALSE;
  182. }
  183.  
  184. BOOL WindowC::resetMenuStrip()
  185. {
  186.     clearMenuStrip();
  187.     if ((window_ob) && (menu))
  188.     {
  189.         menuattached =  ResetMenuStrip(window_ob,menu->menu());
  190.         return menuattached;
  191.     };
  192.     return FALSE;
  193. }
  194.  
  195. VOID WindowC::clearMenuStrip(BOOL forget)
  196. {
  197.     if (window_ob)
  198.     {
  199.         if (menuattached)
  200.         {
  201.             ClearMenuStrip(window_ob);
  202.             menuattached = FALSE;
  203.         };
  204.     };
  205.     if (forget)
  206.         menu = NULL;
  207. }
  208.  
  209. // *************************************************************
  210.  
  211. BOOL WindowC::setGadgetList(class GadgetListC &gl)
  212. {
  213.     clearGadgetList(TRUE,FALSE);
  214.     gadgets = ≷
  215.     if (window_ob)
  216.     {
  217.         if (gadgets->gadget())
  218.             addGadgets(gadgets->gadget());
  219.         refreshGadgets();
  220.         gadgetlistattached = TRUE;
  221.     };
  222.     return TRUE;
  223. }
  224.  
  225. VOID WindowC::resetGadgetList(BOOL refresh)
  226. {
  227.     clearGadgetList(FALSE,FALSE);
  228.     if ((window_ob) && (gadgets))
  229.     {
  230.         if (gadgets->gadget())
  231.             addGadgets(gadgets->gadget());
  232.         if (refresh)
  233.             refreshGadgets();
  234.         gadgetlistattached = TRUE;
  235.     };
  236. }
  237.  
  238. VOID WindowC::clearGadgetList(BOOL forget, BOOL refresh)
  239. {
  240.     if (window_ob)
  241.     {
  242.         if (gadgetlistattached)
  243.         {
  244.             if (gadgets->gadget())
  245.             {
  246.                 RemoveGList(window_ob,gadgets->gadget(),~0);
  247. //                remGadgets(gadgets->gadget());
  248.             };
  249.             if (refresh)
  250.                 refreshGadgets();
  251.             gadgetlistattached = FALSE;
  252.         };
  253.     };
  254.     if (forget)
  255.         gadgets = NULL;
  256. }
  257.  
  258. VOID WindowC::refreshGadgets()
  259. {
  260.     if (window_ob)
  261.     {
  262.         if (gadgets->gadget())
  263.             refreshGadgets(gadgets->gadget());
  264.     };
  265. }
  266.  
  267. // ***************************************************************
  268.  
  269. #pragma chip
  270. static UWORD waitPointer[] = {
  271.     0x0000,0x0000,
  272.     0x0400,0x07c0,
  273.     0x0000,0x07c0,
  274.     0x0100,0x0380,
  275.     0x0000,0x07e0,
  276.     0x07c0,0x1ff8,
  277.     0x1ff0,0x3fec,
  278.     0x3ff8,0x7fde,
  279.     0x3ff8,0x7fbe,
  280.     0x7ffc,0xff7f,
  281.     0x7efc,0xffff,
  282.     0x7ffc,0xffff,
  283.     0x3ff8,0x7ffe,
  284.     0x3ff8,0x7ffe,
  285.     0x1ff0,0x3ffc,
  286.     0x07c0,0x1ff8,
  287.     0x0000,0x07e0,
  288.     0x0000,0x0000
  289. };
  290. #pragma fast
  291.  
  292. BOOL WindowC::setBusy(BOOL status)
  293. {
  294.     BOOL retval = TRUE;
  295.     if (status)
  296.     {
  297.         if (window_ob)
  298.         {
  299.             if (!busyReq)
  300.             {
  301.                 busyReq = (struct Requester *) AllocMem(sizeof(struct Requester),0);
  302.                 if (busyReq)
  303.                 {
  304.                     InitRequester(busyReq);
  305.                     if (!Request(busyReq,window_ob))
  306.                     {
  307.                         FreeMem(busyReq,sizeof(struct Requester));
  308.                         busyReq = NULL;
  309.                         retval = FALSE;
  310.                     };
  311.                     busyPointer = window_ob->Pointer;
  312.                     busyHeight = window_ob->PtrHeight;
  313.                     busyWidth = window_ob->PtrWidth;
  314.                     busyXOffset = window_ob->XOffset;
  315.                     busyYOffset = window_ob->YOffset;
  316.                     if (IntuitionBase->lib_Version >= 39)
  317.                     {
  318.                         SetWindowPointer(window_ob,
  319.                             WA_BusyPointer,TRUE,
  320.                             TAG_END);
  321.                     }
  322.                     else {
  323.                         SetPointer(window_ob,waitPointer,16,16,-6,0);
  324.                     };
  325.                 }
  326.                 else
  327.                     retval = FALSE;
  328.             };
  329.         };
  330.         busy = TRUE;
  331.     }
  332.     else {
  333.         clearBusy();
  334.         busy = FALSE;
  335.     };
  336.     return retval;
  337. }
  338.  
  339. // ***************************************************************
  340.  
  341. BOOL WindowC::snapshot(WindowSnapshotC &snap)
  342. {
  343.     if (isOpen())
  344.     {
  345.         snap.setTop(window_ob->TopEdge);
  346.         snap.setLeft(window_ob->LeftEdge);
  347.         snap.setWidth(window_ob->Width);
  348.         snap.setHeight(window_ob->Height);
  349.         snap.setBusy(isBusy());
  350.     }
  351.     else {
  352.         snap.setTop(inittags.getData(WA_Top,0));
  353.         snap.setLeft(inittags.getData(WA_Left,0));
  354.         snap.setWidth(inittags.getData(WA_Width,~0));
  355.         snap.setHeight(inittags.getData(WA_Height,~0));
  356.         snap.setBusy(isBusy());
  357.     };
  358.     return TRUE;
  359. }
  360.  
  361. BOOL WindowC::stamp(WindowSnapshotC &snap)
  362. {
  363.  
  364.     inittags.set(
  365.         WA_Top,snap.top(), WA_Left,snap.left(),
  366.         WA_Width,snap.width(), WA_Height,snap.height(),
  367.         TAG_END);
  368.     if (isOpen())
  369.     {
  370.         change(snap.left(),snap.top(),snap.width(),snap.height());
  371.     };
  372.     setBusy(snap.busy());
  373.     return TRUE;
  374. }
  375.  
  376. // ***************************************************************
  377.  
  378. BOOL WindowC::addGadget(struct Gadget *gadget)
  379. {
  380.     if (window_ob)
  381.     {
  382.         AddGadget(window_ob,gadget,-1);
  383.         return TRUE;
  384.     };
  385.     return FALSE;
  386. }
  387.  
  388. BOOL WindowC::addGadgets(struct Gadget *gadgets)
  389. {
  390.     if (window_ob)
  391.     {
  392.         AddGList(window_ob,gadgets,-1,-1,NULL);
  393.         return TRUE;
  394.     };
  395.     return FALSE;
  396. }
  397.  
  398. BOOL WindowC::remGadget(struct Gadget *gadget)
  399. {
  400.     if (window_ob)
  401.     {
  402.         return RemoveGadget(window_ob,gadget) != -1;
  403.     };
  404.     return FALSE;
  405. }
  406.  
  407. BOOL WindowC::remGadgets(struct Gadget *gadgets, WORD number)
  408. {
  409.     if (window_ob)
  410.     {
  411.         return RemoveGList(window_ob,gadgets,number) != -1
  412.     };
  413.     return FALSE;
  414. }
  415.  
  416. BOOL WindowC::refreshGadgets(struct Gadget *gadgets, WORD number)
  417. {
  418.     if (window_ob)
  419.     {
  420.         RefreshGList(gadgets,window_ob,NULL,number);
  421.         return TRUE;
  422.     };
  423.     return FALSE;
  424. }
  425.  
  426. // *************************************************************
  427.  
  428. VOID WindowC::activate()
  429. {
  430.     if (window_ob)
  431.         ActivateWindow(window_ob);
  432. }
  433.  
  434. BOOL WindowC::changeSize(WORD Width, WORD Height)
  435. {
  436.     if (window_ob)
  437.     {
  438.         WORD swidth = window_ob->WScreen->Width;
  439.         WORD sheight = window_ob->WScreen->Height;
  440.         if (Width > swidth || Height > sheight)
  441.             return FALSE;
  442.         WORD left = window_ob->LeftEdge;
  443.         WORD top = window_ob->TopEdge;
  444.         if (left + Width > swidth)
  445.         {
  446.             left = swidth - Width;
  447.         };
  448.         if (top + Height > sheight)
  449.         {
  450.             top = sheight - Height;
  451.         };
  452.         ChangeWindowBox(window_ob,left,top,Width,Height);
  453.     }
  454.     else {
  455.         inittags.set(
  456.             WA_Width, Width,
  457.             WA_Height, Height,
  458.             TAG_END);
  459.     };
  460.     return TRUE;
  461. }
  462.  
  463. VOID WindowC::move(WORD LeftEdge, WORD TopEdge)
  464. {
  465.     if (window_ob)
  466.     {
  467.         MoveWindow(window_ob,LeftEdge - window_ob->LeftEdge,
  468.             TopEdge - window_ob->TopEdge);
  469.     }
  470.     else {
  471.         inittags.set(
  472.             WA_Left,LeftEdge,
  473.             WA_Top,TopEdge,
  474.             TAG_END);
  475.     };
  476. }
  477.  
  478. VOID WindowC::change(WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height)
  479. {
  480.     if (window_ob)
  481.     {
  482.         ChangeWindowBox(window_ob,LeftEdge,TopEdge,Width,Height);
  483.     }
  484.     else {
  485.         inittags.set(
  486.             WA_Left,LeftEdge,
  487.             WA_Top,TopEdge,
  488.             WA_Width,Width,
  489.             WA_Height,Height,
  490.             TAG_END);
  491.     };
  492. }
  493.  
  494. BOOL WindowC::limits(WORD MinWidth, WORD MinHeight, WORD MaxWidth, WORD MaxHeight)
  495. {
  496.     if (window_ob)
  497.         return WindowLimits(window_ob,MinWidth,MinHeight,MaxWidth,MaxHeight)
  498.     else {
  499.         inittags.set(
  500.             WA_MinWidth,MinWidth,
  501.             WA_MaxWidth,MaxWidth,
  502.             WA_MinHeight,MinHeight,
  503.             WA_MaxHeight,MaxHeight);
  504.     };
  505.     return TRUE;
  506. }
  507.  
  508. BOOL WindowC::limitMin(WORD MinWidth, WORD MinHeight)
  509. {
  510.     if (window_ob)
  511.         return WindowLimits(window_ob,MinWidth,MinHeight,0,0)
  512.     else {
  513.         inittags.set(
  514.             WA_MinWidth,MinWidth,
  515.             WA_MinHeight,MinHeight,
  516.             TAG_END);
  517.     };
  518.     return TRUE;
  519. }
  520.  
  521. BOOL WindowC::limitMax(WORD MaxWidth, WORD MaxHeight)
  522. {
  523.     if (window_ob)
  524.         return WindowLimits(window_ob,0,0,MaxWidth,MaxHeight)
  525.     else {
  526.         inittags.set(
  527.             WA_MaxWidth,MaxWidth,
  528.             WA_MaxHeight,MaxHeight,
  529.             TAG_END);
  530.     };
  531.     return TRUE;
  532. }
  533.  
  534. VOID WindowC::toFront()
  535. {
  536.     if (window_ob)
  537.         WindowToFront(window_ob);
  538. }
  539.  
  540. VOID WindowC::toBack()
  541. {
  542.     if (window_ob)
  543.         WindowToBack(window_ob);
  544. }
  545.  
  546. VOID WindowC::moveInFrontOf(struct Window *BehindWindow)
  547. {
  548.     if (window_ob)
  549.         MoveWindowInFrontOf(window_ob,BehindWindow);
  550. }
  551.  
  552. VOID WindowC::moveInFrontOf(const WindowC &BehindWindow)
  553. {
  554.     if (window_ob)
  555.         MoveWindowInFrontOf(window_ob,BehindWindow.window_ob);
  556. }
  557.  
  558. VOID WindowC::zip()
  559. {
  560.     if (window_ob)
  561.         ZipWindow(window_ob)
  562. }
  563.  
  564. VOID WindowC::setTitles(STRPTR WindowTitle, STRPTR ScreenTitle)
  565. {
  566.     if (window_ob)
  567.         SetWindowTitles(window_ob,WindowTitle,ScreenTitle);
  568.     inittags.set(
  569.         WA_Title, WindowTitle,
  570.         WA_ScreenTitle, ScreenTitle,
  571.         TAG_END);
  572. }
  573.  
  574. VOID WindowC::setWindowTitle(STRPTR WindowTitle)
  575. {
  576.     if (window_ob)
  577.         SetWindowTitles(window_ob,WindowTitle,(STRPTR) -1);
  578.     inittags.set(
  579.         WA_Title, WindowTitle,
  580.         TAG_END);
  581. }
  582.  
  583. VOID WindowC::setScreenTitle(STRPTR ScreenTitle)
  584. {
  585.     if (window_ob)
  586.         SetWindowTitles(window_ob,(STRPTR) -1,ScreenTitle);
  587.     inittags.set(
  588.         WA_ScreenTitle, ScreenTitle,
  589.         TAG_END);
  590. }
  591.  
  592. VOID WindowC::setPointer(UWORD *Pointer,
  593.         WORD Height, WORD Width, WORD XOffset, WORD YOffset)
  594. {
  595.     if (window_ob)
  596.         SetPointer(window_ob,Pointer,Height,Width,XOffset,YOffset);
  597. }
  598.  
  599. VOID WindowC::clearPointer()
  600. {
  601.     if (window_ob)
  602.         ClearPointer(window_ob);
  603. }
  604.  
  605. VOID WindowC::disableMenu(ULONG number, BOOL v)
  606. {
  607.     if (window_ob)
  608.     {
  609.         if (v)
  610.             OffMenu(window_ob,number)
  611.         else
  612.             OnMenu(window_ob,number);
  613.     };
  614. }
  615.  
  616. VOID WindowC::beginRefresh()
  617. {
  618.     if (window_ob)
  619.         BeginRefresh(window_ob);
  620. }
  621.  
  622. VOID WindowC::endRefresh(BOOL Complete)
  623. {
  624.     if (window_ob)
  625.         EndRefresh(window_ob,Complete);
  626. }
  627.  
  628. VOID WindowC::refreshFrame()
  629. {
  630.     if (window_ob)
  631.         RefreshWindowFrame(window_ob);
  632. }
  633.  
  634. VOID WindowC::freeIDCMP()
  635. {
  636.     Forbid();
  637.     MsgPort *idcmport = window_ob->UserPort;
  638.     struct IntuiMessage *msg;
  639.     struct Node *succ;
  640.     if (idcmport)
  641.     {
  642.         msg = (struct IntuiMessage *) idcmport->mp_MsgList.lh_Head;
  643.         while (succ = msg->ExecMessage.mn_Node.ln_Succ)
  644.         {
  645.             if (msg->IDCMPWindow == window_ob)
  646.             {
  647.                 Remove((struct Node *) msg);
  648.                 ReplyMsg((struct Message *) msg);
  649.             }
  650.             msg = (IntuiMessage *) succ;
  651.         };
  652.     };
  653.     window_ob->UserPort = NULL;
  654.     ModifyIDCMP(window_ob,0);
  655.     Permit();
  656. }
  657.  
  658. VOID WindowC::clearBusy()
  659. {
  660.     if (window_ob)
  661.     {
  662.         if (busyReq)
  663.         {
  664.             if (busyPointer)
  665.             {
  666.                 SetPointer(window_ob,busyPointer,busyHeight,busyWidth,
  667.                     busyXOffset,busyYOffset);
  668.             }
  669.             else {
  670.                 ClearPointer(window_ob);
  671.             };
  672.             EndRequest(busyReq,window_ob);
  673.             FreeMem(busyReq,sizeof(struct Requester));
  674.             busyReq = NULL;
  675.         };
  676.     };
  677. }
  678.  
  679. // *************************************************************
  680.  
  681. WindowListC::WindowListC()
  682. {
  683. }
  684.  
  685. VOID WindowListC::close(BOOL snapshot)
  686. {
  687.     ListCursorC lc(*this);
  688.     while (!lc.isDone()) {
  689.         ((WindowC *) lc.item())->close(snapshot);
  690.         lc.next();
  691.     };
  692. }
  693.  
  694. BOOL WindowListC::setBusy(BOOL state, WindowC *except)
  695. {
  696.     BOOL retval = TRUE;
  697.     ListCursorC lc(*this);
  698.     while (!lc.isDone()) {
  699.         if ((WindowC *) lc.item() != except)
  700.             if (!((WindowC *) lc.item())->setBusy(state))
  701.                 retval = FALSE;
  702.         lc.next();
  703.     };
  704.     return retval;
  705. }
  706.  
  707. // *************************************************************
  708.  
  709. WindowEventHandlerC::WindowEventHandlerC(WindowC &w, ULONG IDCMPclass)
  710.     : IDCMPEventHandlerC(IDCMPclass)
  711. {
  712.     cWindow = &w;
  713.     cWindow->idcmPort().add(*this);
  714.     cWindow->addIDCMP(IDCMPclass);
  715. }
  716.  
  717. WindowEventHandlerC::WindowEventHandlerC(WindowEventHandlerChainC &c)
  718.     : IDCMPEventHandlerC(c.eventClass())
  719. {
  720.     cWindow = c.window();
  721.     c.add(*this);
  722. }
  723.  
  724. BOOL WindowEventHandlerC::_forMe(IntuiMessageC &msg)
  725. {
  726.     return (msg.Class == eventClass())
  727.         && (msg.IDCMPWindow == cWindow->window());
  728. }
  729.  
  730. // *************************************************************
  731.  
  732. WindowEventHandlerChainC::WindowEventHandlerChainC(WindowC &w,
  733.     ULONG IDCMPclass)
  734.     : WindowEventHandlerC(w,IDCMPclass), HandlerChainC()
  735. {
  736. }
  737.  
  738. // *************************************************************
  739.  
  740. WindowCloseHandlerC::WindowCloseHandlerC(WindowC &w)
  741.     : WindowEventHandlerC(w,IDCMP_CLOSEWINDOW)
  742. {
  743.     _exit = FALSE;
  744. }
  745.  
  746. BOOL WindowCloseHandlerC::_handle(IntuiMessageC &)
  747. {
  748.     close();
  749.     return TRUE;
  750. };
  751.  
  752. // **************************************************************
  753.  
  754. WindowActiveHandlerC::WindowActiveHandlerC(WindowC &w)
  755.     : WindowEventHandlerC(w,IDCMP_ACTIVEWINDOW)
  756. {
  757. }
  758.  
  759. BOOL WindowActiveHandlerC::_handle(IntuiMessageC &)
  760. {
  761.     activated();
  762.     return TRUE;
  763. };
  764.  
  765. // **************************************************************
  766.  
  767. WindowInactiveHandlerC::WindowInactiveHandlerC(WindowC &w)
  768.     : WindowEventHandlerC(w,IDCMP_INACTIVEWINDOW)
  769. {
  770. }
  771.  
  772. BOOL WindowInactiveHandlerC::_handle(IntuiMessageC &)
  773. {
  774.     inactivated();
  775.     return TRUE;
  776. };
  777.  
  778. // **************************************************************
  779.  
  780. WindowRefreshHandlerChainC::WindowRefreshHandlerChainC(WindowC &w)
  781.     : WindowEventHandlerChainC(w,IDCMP_REFRESHWINDOW)
  782. {
  783. }
  784.  
  785. BOOL WindowRefreshHandlerChainC::handle(MessageC &msg)
  786. {
  787.     LockLayerInfo(&window()->window()->WScreen->LayerInfo);
  788.     window()->beginRefresh();
  789.     BOOL b = WindowEventHandlerChainC::handle(msg);
  790.     window()->endRefresh();
  791.     UnlockLayerInfo(&window()->window()->WScreen->LayerInfo);
  792.     return b;
  793. }
  794.  
  795. // **************************************************************
  796.  
  797. WindowRefreshHandlerC::WindowRefreshHandlerC(WindowRefreshHandlerChainC &c)
  798.     : WindowEventHandlerC((WindowEventHandlerChainC &) c)
  799. {
  800. }
  801.  
  802. BOOL WindowRefreshHandlerC::_handle(IntuiMessageC &)
  803. {
  804.     refresh();
  805.     return TRUE;
  806. };
  807.  
  808. // **************************************************************
  809.  
  810. WindowNewsizeHandlerC::WindowNewsizeHandlerC(WindowC &w)
  811.     : WindowEventHandlerC(w,IDCMP_NEWSIZE)
  812. {
  813. }
  814.  
  815. BOOL WindowNewsizeHandlerC::_handle(IntuiMessageC &)
  816. {
  817.     newsize();
  818.     return TRUE;
  819. };
  820.  
  821. // **************************************************************
  822.  
  823. WindowSizeverifyHandlerC::WindowSizeverifyHandlerC(WindowC &w)
  824.     : WindowEventHandlerC(w,IDCMP_SIZEVERIFY)
  825. {
  826. }
  827.  
  828. BOOL WindowSizeverifyHandlerC::_handle(IntuiMessageC &)
  829. {
  830.     verify();
  831.     return TRUE;
  832. };
  833.  
  834. // **************************************************************
  835.  
  836. WindowChangeHandlerC::WindowChangeHandlerC(WindowC &w)
  837.     : WindowEventHandlerC(w,IDCMP_CHANGEWINDOW)
  838. {
  839. }
  840.  
  841. BOOL WindowChangeHandlerC::_handle(IntuiMessageC &)
  842. {
  843.     change();
  844.     return TRUE;
  845. };
  846.  
  847.