//****************
//
// Name : Method.C
//
//****************


//******** Header Files

//** OS3.1 Definitions
#include <intuition/intuitionbase.h>
#include <intuition/imageclass.h>
#include <intuition/gadgetclass.h>
#include <exec/lists.h>

//** OS3.1 function Prototypes
#include <clib/graphics_protos.h>
#include <clib/intuition_protos.h>
#include <clib/exec_protos.h>
#include <clib/alib_protos.h>
#include <clib/utility_protos.h>
#include <clib/macros.h>

//OS3.1 Inline code
#include <pragmas/graphics_pragmas.h>
#include <pragmas/utility_pragmas.h>
#include <pragmas/intuition_pragmas.h>
#include <pragmas/exec_pragmas.h>

#include <string.h>

#include "Librarian.h"
#include "Method.H"
#include "MenuAux.H"
#include "Prefs.h"
#include "Promise.h"


//******** Public functions

ULONG MPMG_NEW( Class *cl, Object *o, struct opSet *ops ) {
  Object *object=NULL;
  MPMGData *inst;
  struct Image *image;

  image=(struct Image *)NewObject(NULL,FRAMEICLASS,
    IA_Recessed,    FALSE,
    IA_EdgesOnly,   FALSE,
    IA_FrameType,   FRAME_BUTTON,
    TAG_DONE);

  if (image) {
    if (object = (Object *)DoSuperMethodA(cl, o, (Msg)ops)) {
      inst = (MPMGData *) INST_DATA(cl, object);
      inst->FrameImage=image;
      inst->MainMenu    = (MPMMData *)GetTagData( MPMG_Menus, NULL, ops->ops_AttrList );
      inst->Font        = (struct TextFont *)GetTagData( MPMG_TextFont, NULL, ops->ops_AttrList);
      inst->MinWidth    = (UWORD)GetTagData( MPMG_MinWidth, 0, ops->ops_AttrList);
      inst->GadgetText  = (STRPTR)GetTagData( MPMG_GadgetText, NULL, ops->ops_AttrList);
      inst->SelectPath  = (UWORD *)GetTagData( MPMG_SelectPath, NULL, ops->ops_AttrList);
      inst->SelectPathSize= (UWORD)GetTagData( MPMG_SelectPathSize, NULL, ops->ops_AttrList);
      inst->MenuDelay   = 1+(UWORD)GetTagData( MPMG_MenuDelay, 5, ops->ops_AttrList);
      inst->MenuOverlap = (UWORD)GetTagData( MPMG_MenuOverLap, 75, ops->ops_AttrList);
      if (1==GetTagData(MPMG_Top, 0, ops->ops_AttrList)) inst->Flags |= MPMGF_DROP;
      switch (GetTagData(MPMG_Look, MPMG_LOOK3D, ops->ops_AttrList)) {
	case MPMG_LOOKNEW:
	  inst->Flags|=MPMG_LOOKNEW;
	  break;
	case MPMG_LOOKX:
	  inst->Flags|=MPMG_LOOKX;
	  break;
	case MPMG_LOOK3D:
	default:
	  inst->Flags|=MPMG_LOOK3D;
	  break;
      } // switch
      NewList(&(inst->ActiveMenus));
    } else {
      DisposeObject(image);
    }
  } // if image

  return (ULONG)object;
} // ULONG MPMG_NEW


ULONG MPMG_DISPOSE( Class *cl, Object *o, Msg msg ) {
  MPMGData *inst = INST_DATA( cl, o );

  inst->MainMenu=NULL;
  if (inst->FrameImage) DisposeObject(inst->FrameImage);

  return (ULONG)(DoSuperMethodA(cl, o, msg));
} // ULONG MPMG_DISPOSE


ULONG MPMG_SET( Class *cl, Object *o, struct opSet *ops ) {
  MPMGData *inst = INST_DATA( cl, o );
  ULONG rc=0;
  struct TagItem *tistate;
  struct TagItem *ti;
  struct RastPort *rp;

  ti=ops->ops_AttrList;
  tistate=ti;

  if (!IsListEmpty(&(inst->ActiveMenus))) {
    BOOL foundMenu=FALSE;
    BOOL foundKey=FALSE;
    APTR Key=NULL;
    MPMMData *mm;
    MPMMData *nm;
    MPMMItem *mi;

    while (ti=NextTagItem(&tistate)) {
      switch (ti->ti_Tag) {
	case MPMG_PromiseFullfill:
	  foundMenu=TRUE;
	  nm=(MPMMData *)(ti->ti_Data);
	  break;
	case MPMG_PromiseKey:
	  foundKey=TRUE;
	  Key=(APTR)(ti->ti_Data);
	  break;
	default:
	  break;
      } // switch

    } // while

    if (foundKey && foundMenu) {
      Forbid();
	mm=(MPMMData *)(inst->ActiveMenus.lh_TailPred);
	if (mm->Active!=NOACTIVE) {
	  mi=mm->ActiveNode;
	  if (ITEM_IS_PROMR(mi)) {
	    if (mi->UserData==Key) {
	      mi->SubMenu=nm;
	      rc=1;
	    } // if has same key
	  } // if is prom request
	} // if is an active thing
      Permit();
    } // if all items present

    return rc;
  } // if is running

  DoSuperMethodA(cl,o,(Msg)ops);

  while (ti=NextTagItem(&tistate)) {
    switch (ti->ti_Tag) {
      case MPMG_TextFont:
	inst->Font=(struct TextFont *)(ti->ti_Data);
	rc=2;
	break;
      case MPMG_Menus:
	inst->MainMenu=(MPMMData *)(ti->ti_Data);
	rc=1;
	break;
      case MPMG_Look:
	inst->Flags&= ~(MPMG_LOOKNEW | MPMG_LOOKX | MPMG_LOOK3D);
	switch (ti->ti_Data) {
	  case MPMG_LOOKNEW:
	    inst->Flags|=MPMG_LOOKNEW;
	    break;
	  case MPMG_LOOKX:
	    inst->Flags|=MPMG_LOOKX;
	    break;
	  case MPMG_LOOK3D:
	  default:
	    inst->Flags|=MPMG_LOOK3D;
	    break;
	}
	rc=1;
	break;
      case MPMG_Top:
	if (1==ti->ti_Data) {
	  inst->Flags |= MPMGF_DROP;
	} else {
	  inst->Flags &=~MPMGF_DROP;
	}
	rc=1;
	break;
      case MPMG_GadgetText:
	inst->GadgetText=(STRPTR)(ti->ti_Data);
	rc=2;
	break;
      case MPMG_MinWidth:
	inst->MinWidth=(UWORD)(ti->ti_Data);
	rc=1;
	break;
      case MPMG_MenuOverLap:
	inst->MenuOverlap=(UWORD)(ti->ti_Data);
	rc=1;
	break;
      case MPMG_MenuDelay:
	inst->MenuDelay=1+(UWORD)(ti->ti_Data);
	rc=1;
	break;
      case MPMG_SelectPathSize:
	inst->SelectPathSize=(UWORD)(ti->ti_Data);
	rc=1;
	break;
      case MPMG_SelectPath:
	inst->SelectPath=(UWORD *)(ti->ti_Data);
	rc=1;
	break;
      default:
	break;
    } // switch
  } // while

  if (2==rc) {
    if (rp=ObtainGIRPort( ops->ops_GInfo)) {
      DoMethod(o,GM_RENDER,ops->ops_GInfo,rp,GREDRAW_REDRAW);
      rc=1;
      ReleaseGIRPort(rp);
    }
  }
  return rc;
} // ULONG MPMG_SET


ULONG MPMG_GET( Class *cl, Object *o, struct opGet *opg ) {
  MPMGData *inst = INST_DATA( cl, o );
  ULONG rc=1;

  switch (opg->opg_AttrID) {
    case MPMG_TextFont:
      *(opg->opg_Storage)=(ULONG)inst->Font;
      break;
    case MPMG_Menus:
      *(opg->opg_Storage)=(ULONG)inst->MainMenu;
      break;
    case MPMG_Look:
      *(opg->opg_Storage)=(ULONG)(inst->Flags & ( MPMG_LOOKNEW | MPMG_LOOK3D | MPMG_LOOKX ) );
      break;
    case MPMG_Top:
      *(opg->opg_Storage)= (inst->Flags & MPMGF_DROP)?1:0;
      break;
    case MPMG_GadgetText:
      *(opg->opg_Storage)=(ULONG)inst->GadgetText;
      break;
    case MPMG_MenuOverLap:
      *(opg->opg_Storage)=(ULONG)inst->MenuOverlap;
      break;
    case MPMG_MenuDelay:
      *(opg->opg_Storage)=(ULONG)inst->MenuDelay-1;
      break;
    case MPMG_MinWidth:
      *(opg->opg_Storage)=(ULONG)inst->MinWidth;
      break;
    case MPMG_SelectLabel:
      *(opg->opg_Storage)=(ULONG)inst->SelectLabel;
      break;
    case MPMG_SelectFlags:
      *(opg->opg_Storage)=(ULONG)inst->SelectFlags;
      break;
    case MPMG_SelectUserData:
      *(opg->opg_Storage)=(ULONG)inst->SelectUserData;
      break;
    case MPMG_SelectDepth:
      *(opg->opg_Storage)=(ULONG)inst->SelectDepth;
      break;
    case MPMG_SelectCode:
      *(opg->opg_Storage)=(ULONG)inst->SelectCode;
      break;
    case MPMG_SelectPath:
      *(opg->opg_Storage)=(ULONG)inst->SelectPath;
      break;
    case MPMG_SelectPathSize:
      *(opg->opg_Storage)=(ULONG)inst->SelectPathSize;
      break;
    case MPMG_FitsItems:
      *(opg->opg_Storage)=(ULONG)inst->FitsItems;
      break;
    default:
      rc=DoSuperMethodA(cl,o,(Msg)opg);
  } // switch

  return rc;
} // ULONG MPMG_GET


ULONG MPMG_UPDATE( Class *cl, Object *o, struct opUpdate *opu ) {
  return DoSuperMethodA(cl,o,(Msg)opu);
} // ULONG MPMG_UPDATE


ULONG MPMG_NOTIFY( Class *cl, Object *o, struct opUpdate *opu ) {
//  MPMGData *inst = INST_DATA( cl, o );
  struct TagItem tags[2];

  MPMG_SetTagArg(tags[0], GA_ID, ((struct Gadget *)o)->GadgetID);

  if (NULL==opu->opu_AttrList) {
    MPMG_SetTagArg(tags[1], TAG_END, NULL);
  } else {
    MPMG_SetTagArg(tags[1], TAG_MORE, opu->opu_AttrList );
  }

  return (DoSuperMethod(cl, o, OM_NOTIFY, tags, opu->opu_GInfo, opu->opu_Flags) );
} // MPMG_NOTIFY


ULONG MPMG_RENDER( Class *cl, struct Gadget *g, struct gpRender *msg ) {
  MPMGData *inst = INST_DATA(cl, (Object *)g);
  struct RastPort *rp;
  LONG L,T,R,B,W,H;
  ULONG State,Len;
  ULONG rc = FALSE;
  struct GadgetInfo *gi=msg->gpr_GInfo;
  struct DrawInfo *dri= gi->gi_DrInfo;
  STRPTR GText=ONGOVERS;
  ULONG numch;

  L = g->LeftEdge;
  T = g->TopEdge;
  W = g->Width;
  H = g->Height;

  if (gi) {
    if (g->Flags & GFLG_RELRIGHT ) L += gi->gi_Domain.Width  - 1;
    if (g->Flags & GFLG_RELBOTTOM) T += gi->gi_Domain.Height - 1;
    if (g->Flags & GFLG_RELWIDTH ) W += gi->gi_Domain.Width;
    if (g->Flags & GFLG_RELHEIGHT) H += gi->gi_Domain.Height;
  }

  R = L + W - (W > 0);
  B = T + H - (H > 0);

  inst->GadgetBox.Left=L;
  inst->GadgetBox.Top=T;
  inst->GadgetBox.Width=W;
  inst->GadgetBox.Height=H;

  if (GM_RENDER == msg->MethodID) rp = msg->gpr_RPort;
  else                            rp = ObtainGIRPort(msg->gpr_GInfo);

  if (rp) {
    if (g->Flags & GFLG_DISABLED)      State = IDS_DISABLED;
    else if (g->Flags & GFLG_SELECTED) State = IDS_SELECTED;
    else                               State = IDS_NORMAL;

    SetAttrs( inst->FrameImage,
      IA_Left,    L,           IA_Top,     T,
      IA_Width,   W,           IA_Height,  H,
      TAG_END);

    DrawImageState( rp, inst->FrameImage, 0, 0, State, dri);
    SetAPen(rp,(dri?dri->dri_Pens[TEXTPEN]:1));
    if (inst->GadgetText) GText=inst->GadgetText;
    numch=strlen(GText);
    Len=TextLength(rp,GText,numch);
    Move(rp,L+(W-Len)/2,T+(H-rp->Font->tf_YSize)/2+rp->Font->tf_Baseline);
    Text(rp,GText,numch);

    if (msg->MethodID != GM_RENDER) ReleaseGIRPort(rp);
    rc=TRUE;
  } // if rp

  return(rc);
} // ULONG MPMG_RENDER


ULONG MPMG_GOACTIVE( Class *cl, Object *o, struct gpInput *gpi ) {
  MPMGData *inst = INST_DATA( cl, o );
  struct GadgetInfo *gi = gpi->gpi_GInfo;
  struct RastPort *rp;
  struct Gadget *gad=(struct Gadget *)o;
  ULONG rc=GMR_NOREUSE,FWid;

  if (inst->MainMenu==NULL) return GMR_NOREUSE;
  if (gad->Flags & GFLG_DISABLED) return GMR_NOREUSE;

  (void)DoSuperMethodA(cl, o, gpi); // Call superclass first
  inst->FollowMouse = (gpi->gpi_IEvent != NULL);    // Active from Mouse?
  inst->SelectDepth = 0;
  inst->Tick=0;

  gad->Flags |= GFLG_SELECTED;      // Select this gadget.

  rp = ObtainGIRPort( gi );
  if (rp) {
    DoMethod( o, GM_RENDER, gi, rp, GREDRAW_UPDATE );

    if (NULL==inst->Font) {
      inst->Font = rp->Font;
    } else SetFont(rp, inst->Font);

    inst->ItemHeight=rp->Font->tf_YSize+(inst->Flags&MPMG_LOOKX?5:1);
    inst->FitsItems = (gi->gi_Screen->Height - 4) / inst->ItemHeight;
    FWid=MPMG_EvalWidth(inst->MainMenu,rp);
    ReleaseGIRPort( rp );

    if (gi->gi_Window) {
      inst->GadgetBox.Left += gi->gi_Window->LeftEdge;
      inst->GadgetBox.Top  += gi->gi_Window->TopEdge;
    }

    if (TRUE==MPMG_MenuOpen(inst,inst->MainMenu,&(inst->GadgetBox),gi,FWid))
      rc=GMR_MEACTIVE;
  }

  return rc;
} // ULONG MPMG_GOACTIVE


ULONG MPMG_HANDLEINPUT( Class *cl, Object *o, struct gpInput *gpi ) {
  ULONG rc = GMR_MEACTIVE;
  struct InputEvent *ie = gpi->gpi_IEvent;
  MPMGData *inst = INST_DATA(cl, o);
  struct GadgetInfo *gi = gpi->gpi_GInfo;
  struct DrawInfo *dri= gi->gi_DrInfo;
  MPMMData *amenu;
  UWORD aitem;
  ULONG FWid;
  struct IBox ib;
  struct TagItem tags[2];

  if (gi->gi_Window) {
    if (NULL==(gi->gi_Window->Flags & WFLG_WINDOWACTIVE)) {
      DisplayBeep(NULL);
      return( GMR_NOREUSE );
    }
  } // if

  if (inst->FollowMouse) {
    amenu=(MPMMData *)inst->ActiveMenus.lh_TailPred;
    if ((amenu->Active!=NOACTIVE) && (ITEM_IS_PROMR(amenu->ActiveNode))) {
      aitem=amenu->Active;
    } else
    amenu=MPMG_DetermineActiveMenu(inst,&aitem);

    //** if pointing over a different menu, then close
    if (amenu!=(MPMMData *)inst->ActiveMenus.lh_TailPred) {
      MPMMData *omenu;
      inst->Tick=0;
      omenu=(MPMMData *)amenu->Node.ln_Succ;
      if (omenu->Node.ln_Succ->ln_Succ)
	MPMG_MenuClose(o,gi,inst,(MPMMData *)omenu->Node.ln_Succ);
      MPMG_MenuRenderItem(inst, omenu, dri, FALSE);
      omenu->Active=NOACTIVE;
    } // if

    //** If item is different
    if (aitem!=amenu->Active) {
      inst->Tick=0;
      if (NOACTIVE!=amenu->Active) {
	if (amenu->Node.ln_Succ->ln_Succ) {
	  MPMG_MenuClose(o,gi,inst,(MPMMData *)(amenu->Node.ln_Succ));
	} else if (ITEM_IS_PROMR(amenu->ActiveNode) || ITEM_IS_PROMH(amenu->ActiveNode)) {
	  CancelPromise(o,gi,amenu->ActiveNode);
	}
	MPMG_MenuRenderItem(inst, amenu, dri, FALSE);
      } // if
      amenu->Active=aitem;
      if (NOACTIVE!=aitem) {
	MPMG_MenuRenderItem(inst, amenu, dri, TRUE);
	if (ITEM_IS_MENU(amenu->ActiveNode))
	  inst->Tick=inst->MenuDelay+CALCTIME(gpi);
	else if (ITEM_IS_PROM(amenu->ActiveNode))
//          CallPromise(o,gi,amenu->ActiveNode);
	  inst->Tick=inst->MenuDelay+CALCTIME(gpi);
      } // if !NOACTIVE
    } // if aitem != amenu->active

    //** Check for promise fulfilled
    if ((amenu->Active!=NOACTIVE) && (ITEM_IS_PROMR(amenu->ActiveNode)) && (amenu->ActiveNode->SubMenu)) {
      inst->Tick=CALCTIME(gpi);
      amenu->ActiveNode->Type=MIT_PROMH;
    }

    //** If necessary, open a window
    if (inst->Tick>0) {
      if (inst->Tick<=CALCTIME(gpi)) {
	if (ITEM_IS_PROM(amenu->ActiveNode)) {
	  CallPromise(o,gi,inst,amenu->ActiveNode);
	} else {
	  ib.Left=amenu->mwin->LeftEdge;
	  ib.Top=amenu->mwin->TopEdge+2+amenu->Active*amenu->ItemHeight;
	  ib.Width=amenu->mwin->Width;
	  ib.Height=amenu->ItemHeight;
	  FWid=MPMG_EvalWidth(amenu->ActiveNode->SubMenu,amenu->mwin->RPort);
	  MPMG_MenuOpen(inst,amenu->ActiveNode->SubMenu,&ib,gi,FWid);
	}
	inst->Tick=0;
      } // if Tick<=CALCTIME
    } // if about to open...

    //** Hanlde each input event
    while (ie && (rc == GMR_MEACTIVE) ) {
      if (IECLASS_RAWMOUSE==ie->ie_Class) {
	switch (ie->ie_Code) {
	  case SELECTUP:
	    if ( (NOACTIVE!=aitem) && (ITEM_IS_ITEM(amenu->ActiveNode)) ) {
	      MPMG_SetTagArg(tags[0], MPMG_GrabItQuick, aitem);
	      MPMG_SetTagArg(tags[1], TAG_END, NULL);
	      (void)DoMethod( o, OM_NOTIFY, &tags, gi, 0);
	      *gpi->gpi_Termination = (ULONG)amenu->ActiveNode->Code;
	      rc = GMR_NOREUSE | GMR_VERIFY;
	      inst->SelectLabel=amenu->ActiveNode->Node.ln_Name;
	      inst->SelectCode =amenu->ActiveNode->Code;
	      inst->SelectFlags=amenu->ActiveNode->Flags;
	      inst->SelectUserData=amenu->ActiveNode->UserData;
	    } else {
	      rc = GMR_NOREUSE;
	    }
	    break;
	  case MENUDOWN:
	    rc= GMR_REUSE;
	    break;
	  default:
	    break;
	} // switch ie_Code
      } // if IECLASS_RAWMOUSE

      ie = ie->ie_NextEvent;
    } // while ie & MEACTIVE

  } else {  // if !FollowMouse

    while (ie && (GMR_MEACTIVE == rc) ) {
      amenu=(MPMMData *)inst->ActiveMenus.lh_TailPred;
      if ((!MENU_HAS_ACTIVE(amenu)) && (amenu->Count)) {
	amenu->Active=0;
	MPMG_MenuRenderItem(inst, amenu, dri, TRUE);
      }
      switch (ie->ie_Class) {
	case IECLASS_RAWMOUSE:
	  if (ie->ie_Code!=IECODE_NOBUTTON) rc = GMR_REUSE;
	  break;
	case IECLASS_RAWKEY:
	  if ( (amenu->Active!=NOACTIVE) && (!ITEM_IS_PROMR(amenu->ActiveNode)) )
	  switch (ie->ie_Code) {
	    case 0x45: // esc
	    case CURSORLEFT: // cursorleft
	      if (amenu==inst->MainMenu) {
		rc = GMR_NOREUSE;
	      } else {
		MPMG_MenuClose(o,gi,inst,amenu);
	      }
	      break;
	    case CURSORUP:
	      if ( (amenu->Active>0) && (MENU_HAS_ACTIVE(amenu)) ) {
		MPMG_MenuRenderItem(inst, amenu, dri, FALSE);
		if (ie->ie_Qualifier & (IEQUALIFIER_LSHIFT |IEQUALIFIER_RSHIFT ) ) {
		  amenu->Active=0;
		} else {
		  amenu->Active--;
		}
		MPMG_MenuRenderItem(inst, amenu, dri, TRUE);
	      }
	      break;
	    case CURSORDOWN:
	      aitem=MIN(inst->FitsItems,amenu->Count)-1;
	      if ( (amenu->Active<aitem) && (MENU_HAS_ACTIVE(amenu)) ) {
		MPMG_MenuRenderItem(inst, amenu, dri, FALSE);
		if (ie->ie_Qualifier & (IEQUALIFIER_LSHIFT |IEQUALIFIER_RSHIFT ) ) {
		  amenu->Active=aitem;
		} else {
		  amenu->Active++;
		}
		MPMG_MenuRenderItem(inst, amenu, dri, TRUE);
	      }
	      break;
	    case 0x44: // return
	    case 0x40: // space
	    case CURSORRIGHT:
	      if (!MENU_HAS_ACTIVE(amenu)) break;
	      if (ITEM_IS_MENU(amenu->ActiveNode)) {
		ib.Left=amenu->mwin->LeftEdge;
		ib.Top=amenu->mwin->TopEdge+2+amenu->Active*amenu->ItemHeight;
		ib.Width=amenu->mwin->Width;
		ib.Height=amenu->ItemHeight;
		FWid=MPMG_EvalWidth(amenu->ActiveNode->SubMenu,amenu->mwin->RPort);
		MPMG_MenuOpen(inst,amenu->ActiveNode->SubMenu,&ib,gi,FWid);
	      } else if (ITEM_IS_PROM(amenu->ActiveNode)) {
		CallPromise(o,gi,inst,amenu->ActiveNode);
	      } else {
		MPMG_SetTagArg(tags[0], MPMG_GrabItQuick, amenu->Active);
		MPMG_SetTagArg(tags[1], TAG_END, NULL);
		(void)DoMethod( o, OM_NOTIFY, &tags, gi, 0);
		*gpi->gpi_Termination = (ULONG)amenu->ActiveNode->Code;
		rc = GMR_NOREUSE | GMR_VERIFY;
		inst->SelectLabel=amenu->ActiveNode->Node.ln_Name;
		inst->SelectCode =amenu->ActiveNode->Code;
		inst->SelectFlags=amenu->ActiveNode->Flags;
		inst->SelectUserData=amenu->ActiveNode->UserData;
	      }
	      break;
	    default:
	      break;
	  } // switch
	  break;
	case IECLASS_TIMER:
	  if ( (amenu->Active!=NOACTIVE) && (ITEM_IS_PROMR(amenu->ActiveNode)) && (amenu->ActiveNode->SubMenu) ) {
	    amenu->ActiveNode->Type=MIT_PROMH;
	    ib.Left=amenu->mwin->LeftEdge;
	    ib.Top=amenu->mwin->TopEdge+2+amenu->Active*amenu->ItemHeight;
	    ib.Width=amenu->mwin->Width;
	    ib.Height=amenu->ItemHeight;
	    FWid=MPMG_EvalWidth(amenu->ActiveNode->SubMenu,amenu->mwin->RPort);
	    MPMG_MenuOpen(inst,amenu->ActiveNode->SubMenu,&ib,gi,FWid);
	  }
	  break;
	default:
	  break;
      } // switch
      ie = ie->ie_NextEvent;
    } // while
  } // if !followmouse

  return rc;
} // ULONG MPMG_HANDLEINPUT


ULONG MPMG_GOINACTIVE( Class *cl, Object *o, struct gpGoInactive *gpgi ) {
  MPMGData *inst = INST_DATA( cl, o );
  ULONG rc=0;
  struct RastPort *rp;
  UWORD Depth;

  if (inst->MainMenu) {
    rc = DoSuperMethodA(cl, o, gpgi);

    ((struct Gadget *)o)->Flags &= ~GFLG_SELECTED;

    rp = ObtainGIRPort( gpgi->gpgi_GInfo );
    if (rp) {
      DoMethod( o, GM_RENDER, gpgi->gpgi_GInfo, rp, GREDRAW_UPDATE );
      ReleaseGIRPort( rp );
    }

    Depth=inst->SelectDepth-1;

    if (inst->MainMenu->mwin) {
      MPMG_MenuClose(o,gpgi->gpgi_GInfo,inst,inst->MainMenu);
    }
    inst->SelectDepth=Depth;
  } // if inst->MainMenu

  return(rc);
} // ULONG MPMG_GOINACTIVE
 
//******** End of file