#ifndef __INC_POSA_CLIB_INTUITION_PROTOS_C
#define __INC_POSA_CLIB_INTUITION_PROTOS_C
/*******************************************************************
 Includes Release 24
 (C) Copyright 1995-1997 proDAD
     All Rights Reserved

 $AUT Holger Burkarth
 $DAT >>intuition_protos.c<<   31 Jan 1997    17:21:44 - (C) ProDAD
*******************************************************************/
#define NOMYDEBUG
#pragma -

#include <exec/Types.h>
#include <intuition/screens.h>
#include <clib/intuition_protos.h>
#include "p:pProto/pIntui2.h"
#include "p:pProto/pUtil2.h"
#include "p:pIntui/IntuMsg.h"
#include "p:pIntui/IClass.h"
#include "p:pScreen/Screen.h"
#include "p:pScreen/Window.h"
#include "p:pGFX/GfxTags.h"
#include "p:pGFX/Text.h"


/* mcpp:cppc -c ci:_Projekte/pOSxA/clib/intuition_protos.c -pc */



UWORD AddGadget(struct Window *window,struct Gadget *gadget,ULONG position)
  {  pOS_AddGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget);  return(1); }

void ClearMenuStrip( struct Window *window )
  { pOS_SetMenuStrip((struct pOS_Window*)window,NULL);}


BOOL CloseScreen( struct Screen *screen )
  {
/*    kprintf("CloseScreen %lx\n",screen); */
    pOS_UnlockPubScreen((APTR)screen); return(1);
  }
/*  { return(pOS_CloseScreen((pOS_Screen*)screen));} */


void CloseWindow( struct Window *window )
  { pOS_CloseWindow((struct pOS_Window*)window);}


void CurrentTime( ULONG *seconds, ULONG *micros )
  { pOS_CurrentTime(seconds,micros); }

void DisplayBeep( struct Screen *screen )
  { pOS_DisplayBeep((APTR)screen,0); }

BOOL DoubleClick( unsigned long sSeconds, unsigned long sMicros,
        unsigned long cSeconds, unsigned long cMicros )
  {
    struct pOS_DoubleClick Just={0,0};
    struct pOS_DoubleClick Old={0,0};
    Just.dk_Seconds=cSeconds;  Just.dk_Micros=cMicros;
    Old.dk_Seconds=sSeconds;   Old.dk_Micros=sMicros;

    return( pOS_CmpDoubleClick(&Just,&Old) );
  }

void DrawBorder(struct RastPort *rp,struct Border *bor,long leftOffset,long topOffset)
  {
    for(; bor; bor=bor->NextBorder) {
      const struct pOS_WPoint* WP=(struct pOS_WPoint*)bor->XY;
      SWORD X=bor->LeftEdge, Y=bor->TopEdge;
      UWORD Cnt;
      pOS_SetABPenDrMd((struct pOS_RastPort*)rp,bor->FrontPen,bor->BackPen,bor->DrawMode);
      pOS_SetPosition((struct pOS_RastPort*)rp,X,Y);
      for(Cnt=bor->Count; Cnt>0; --Cnt,++WP)
            pOS_DrawLine((struct pOS_RastPort*)rp,WP->X+X,WP->Y+Y);
    }
  }

void DrawImage(struct RastPort *rp,struct Image *im,long leftOffset,long topOffset)
  {
    pOS_StdPlanarGfxMap GM;
    ULONG Size,Offset;
    UWORD d;

    memset(&GM,0,sizeof(GM)); /* *** Zur Sicherheit */
    GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;

    for(; im; im=im->NextImage) {
      GM.plgm_Gfx.gm_Width =im->Width;
      GM.plgm_Gfx.gm_Height=im->Height;
      GM.plgm_BytesPerRow=((im->Width+15)>>4)<<1;
      GM.plgm_Depth=im->Depth;
      Offset=0;
      Size=GM.plgm_BytesPerRow*GM.plgm_Gfx.gm_Height/sizeof(UWORD);
      for(d=0; d<im->Depth; ++d, Offset+=Size) {
        GM.plgm_Planes[d]=(UBYTE*) &im->ImageData[Offset];
      }
      pOS_WriteStdGfxMapRastPort(&GM.plgm_Gfx,0,0,
         (struct pOS_RastPort*)rp,leftOffset+im->LeftEdge,topOffset+im->TopEdge,
         GM.plgm_Gfx.gm_Width,GM.plgm_Gfx.gm_Height,
         0);
    }
  }


struct MenuItem *ItemAddress(struct Menu *menuStrip,ULONG menuNumber )
  {
    return( (struct MenuItem*)
              pOS_GetMenuItemFromNum(&((struct pOS_MenuList*)menuStrip)->ml_List ,
                                      (struct pOS_MenuNum*)&menuNumber) );
  }

BOOL ModifyIDCMP( struct Window *window, unsigned long flags )
  { return(pOS_ModifyIDCMP((struct pOS_Window*)window,flags));}


void MoveWindow( struct Window *window, long dx, long dy )
  { pOS_ChangeWindowBox((struct pOS_Window*)window,dx,dy,0,0); }

void OffGadget(struct Gadget *gadget,struct Window *window,struct Requester* req)
  { pOS_EnableGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget,FALSE); }

void OffMenu(struct Window *window,ULONG menuNumber)
  {
    struct pOS_MenuNum MN;
    MN.men_U.men_Num=menuNumber;
    pOS_EnableWindowMenu((APTR)window,&MN,FALSE);
  }

void OnGadget(struct Gadget *gadget,struct Window *window,struct Requester* req)
  { pOS_EnableGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget,TRUE); }

void OnMenu(struct Window *window,ULONG menuNumber)
  {
    struct pOS_MenuNum MN;
    MN.men_U.men_Num=menuNumber;
    pOS_EnableWindowMenu((APTR)window,&MN,TRUE);
  }

struct Window *OpenWindow(struct NewWindow *nw)
  { return( OpenWindowTagList(nw,NULL) );}


void RefreshGadgets(struct Gadget *gadgets,struct Window *window,struct Requester* req)
  { pOS_RefreshGadgets((struct pOS_Window*)window,(struct pOS_Gadget*)gadgets,-1); }

UWORD RemoveGadget(struct Window *window,struct Gadget *gadget)
  {  pOS_RemGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget);  return(1);}

BOOL SetMenuStrip( struct Window *window, struct Menu *menu )
  {
    pOS_SetMenuStrip((struct pOS_Window*)window,(struct pOS_MenuList*)menu);
    return(TRUE);
  }

void SetWindowTitles(struct Window *window,UBYTE *windowTitle,UBYTE *screenTitle)
  { pOS_SetWindowTitles((struct pOS_Window*)window,(CHAR*)windowTitle,(CHAR*)screenTitle); }


void SizeWindow( struct Window *window, long dx, long dy )
  { pOS_ChangeWindowBox((struct pOS_Window*)window,0,0,dx,dy); }


struct ViewPort *ViewPortAddress( struct Window *window )
  { return((struct ViewPort*) ((struct pOS_Window*)window)->win_Screen->scr_ViewPort  );}

void WindowToBack( struct Window *window )
  { pOS_WindowToBack((struct pOS_Window*)window); }

void WindowToFront( struct Window *window )
  { pOS_WindowToFront((struct pOS_Window*)window); }

BOOL WindowLimits(struct Window *window,long widthMin,long heightMin,ULONG widthMax,ULONG heightMax )
  { return(pOS_SetWindowLimits((struct pOS_Window*)window,widthMin,heightMin,widthMax,heightMax));}

void BeginRefresh( struct Window *window )
  { pOS_BeginRefresh((struct pOS_Window*)window,NULL); }

void EndRefresh( struct Window *window, long complete )
  { pOS_EndRefresh((struct pOS_Window*)window,complete); }

void FreeSysRequest( struct Window *window )
  { pOS_DeleteRequestWin((struct pOS_Window*)window); }


void RefreshGList(struct Gadget *gadgets,struct Window *window,struct Requester* req,long numGad)
  { pOS_RefreshGadgets((struct pOS_Window*)window,(struct pOS_Gadget*)gadgets,numGad); }

UWORD AddGList(struct Window *window,struct Gadget *gadget,ULONG pos,ULONG numGad,struct Requester* req)
  {
    struct Gadget *Next;
    for(; gadget!=NULL && numGad>0; gadget=Next,--numGad) {
      Next=gadget->U.NextGadget;
      gadget->U.gad_Node.mln_Succ=0;
      gadget->U.gad_Node.mln_Pred=0;
      pOS_AddGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget);
    }
    return(1);
  }

UWORD RemoveGList(struct Window *window,struct Gadget *gadget,ULONG numGad)
  {
    struct Gadget *Next,*Pred;

    Pred=NULL;
    for(Next=(struct Gadget*)gadget;
        Next->U.gad_Node.mln_Succ && numGad>0;
        gadget=Next, --numGad)
    {
      Next=(struct Gadget*)gadget->U.gad_Node.mln_Succ;
      pOS_RemGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadget);

      if(Pred) Pred->U.NextGadget=gadget;
      Pred=gadget;
      gadget->U.NextGadget=NULL;
    }
    return(1);
  }

void ActivateWindow( struct Window *window )
  { pOS_ActivateWindow((struct pOS_Window*)window); }

void RefreshWindowFrame( struct Window *window )
  { pOS_RefreshWindowFrame((struct pOS_Window*)window); }

BOOL ActivateGadget(struct Gadget *gadgets,struct Window *window,struct Requester* req)
  { return(pOS_ActivateGadget((struct pOS_Window*)window,(struct pOS_Gadget*)gadgets)); }


LONG QueryOverscan(unsigned long displayID,struct Rectangle *rect,long oScanType)
  {
/*OSCAN_TEXT */
/*OSCAN_STANDARD */
/*OSCAN_MAX */
/*OSCAN_VIDEO */
    switch(oScanType) {
       case OSCAN_STANDARD:
    }
    rect->MinX=0;     rect->MinY=0;
    rect->MaxX=639;   rect->MaxY=254;
    return(TRUE);
  }


void ChangeWindowBox(struct Window *window,long left,long top,long width,long height)
  { pOS_ChangeWindowBox((struct pOS_Window*)window,left,top,width,height); }


LONG SetMouseQueue(struct Window *window,ULONG queueLength)
  { return( pOS_SetMouseQueue((struct pOS_Window*)window,queueLength) );}

void ZipWindow( struct Window *window )
  { pOS_ZipWindow((struct pOS_Window*)window); }

struct Screen *LockPubScreen( UBYTE *name )
  {
    return((struct Screen*)pOS_LockPubScreen((CHAR*)name));
  }

void UnlockPubScreen( UBYTE *name, struct Screen *screen )
  {
    pOS_UnlockPubScreen((struct pOS_Screen*)screen);
  }

UWORD PubScreenStatus(struct Screen *screen,ULONG statusFlags )
  {
    return( statusFlags);
/*    return(pOS_PubScreenStatus((struct pOS_Screen*)screen,statusFlags)); */
  }


LONG EasyRequestArgs(struct Window *window,struct EasyStruct *easyStruct,ULONG *idcmpPtr,APTR args)
  {
    struct pOS_EasyStruct *ES=(struct pOS_EasyStruct*)easyStruct;
    ES->es_HelpID=0; ES->es_HelpFile=0; ES->es_Tags=0;
    return(pOS_EasyRequestArgs((struct pOS_Window*)window,ES,idcmpPtr,(APTR)args));
  }

LONG EasyRequest( struct Window *window, struct EasyStruct *easyStruct,ULONG *idcmpPtr, ... )
  {
    struct pOS_EasyStruct *ES=(struct pOS_EasyStruct*)easyStruct;
    ES->es_HelpID=0; ES->es_HelpFile=0; ES->es_Tags=0;
    return(pOS_EasyRequestArgs((struct pOS_Window*)window,ES,idcmpPtr,(APTR) ((&idcmpPtr)+1) ));
  }

LONG SysReqHandler( struct Window *window, ULONG *idcmpPtr, long waitInput )
  { return(pOS_RequestWinHandler((struct pOS_Window*)window,idcmpPtr,waitInput)); }

struct Window *OpenWindowTagList(struct NewWindow *nw,struct TagItem *tagList)
  {
    struct Window *Win;
    struct pOS_TagItem Tags[8];
    struct pOS_TagItem *TIGad;

    TIGad=pOS_FindTagItem(SCRTAG_Gadget,(struct pOS_TagItem*)tagList);
    if(TIGad) TIGad->ti_Tag=TAG_IGNORE;

    if(nw) {
      Tags[0].ti_Tag=SCRTAG_LeftEdge;     Tags[0].ti_Data=nw->LeftEdge;
      Tags[1].ti_Tag=SCRTAG_TopEdge;      Tags[1].ti_Data=nw->TopEdge;
      Tags[2].ti_Tag=SCRTAG_Width;        Tags[2].ti_Data=nw->Width;
      Tags[3].ti_Tag=SCRTAG_Height;       Tags[3].ti_Data=nw->Height;
      Tags[4].ti_Tag=SCRTAG_Screen;       Tags[4].ti_Data=(ULONG)nw->Screen;
      Tags[5].ti_Tag=SCRTAG_Flags;        Tags[5].ti_Data=(ULONG)nw->Flags;
      Tags[6].ti_Tag=SCRTAG_IDCMP;        Tags[6].ti_Data=(ULONG)nw->IDCMPFlags;
      Tags[7].ti_Tag=TAG_MORE;            Tags[7].ti_Data=(ULONG)tagList;
      tagList=(APTR)Tags;
    }

    Win=(struct Window*)pOS_OpenWindowA((struct pOS_TagItem*)tagList);

    if(TIGad && TIGad->ti_Data) {
      TIGad->ti_Tag=SCRTAG_Gadget;
      if(Win) AddGList(Win,(struct Gadget*)TIGad->ti_Data,~0,~0,NULL);
    }

    return(Win);
  }

struct Window *OpenWindowTags( struct NewWindow *newWindow,
        unsigned long tag1Type, ... )
  { return( OpenWindowTagList(newWindow,(struct TagItem*)&tag1Type) );}

struct Screen *OpenScreenTagList(struct NewScreen *newScreen,struct TagItem *tagList)
  {
    return((APTR)pOS_LockPubScreen(NULL) );
  }
/*  { return((struct Screen*)pOS_OpenScreenA((pOS_TagItem*)tagList));} */


struct Screen *OpenScreenTags( struct NewScreen *newScreen,
        unsigned long tag1Type, ... )
  { return( OpenScreenTagList(newScreen,(struct TagItem*)&tag1Type) );}


APTR NewObjectA(struct IClass *classPtr,UBYTE *classID,struct TagItem *tagList)
  { return(pOS_NewIObjectA((struct pOS_NClass*)classPtr,(CHAR*)classID,0,(struct pOS_TagItem*)tagList));}

APTR NewObject(struct IClass *classPtr,UBYTE *classID,ULONG tag1,...)
  { return( NewObjectA(classPtr,classID,(struct TagItem*)&tag1) );}


void DisposeObject( APTR object )
  { if(object) pOS_DisposeIObject(object); }

ULONG SetAttrsA( APTR object, struct TagItem *tagList )
{
  struct pOS_IntuiMethod Mth;

  Mth.imth_Method=ICLMTH_Set;
  Mth.imth_U.imth_Set.imst_Info=NULL;
  Mth.imth_U.imth_Set.imst_Tags=(struct pOS_TagItem*)tagList;
  return( pOS_DoIMethodA(object,(struct pOS_Method*)&Mth) );
}

ULONG SetAttrs( APTR object, unsigned long tag1, ... )
  { return( SetAttrsA(object,(struct TagItem*)&tag1 ) );}


ULONG GetAttr( unsigned long attrID, APTR object, ULONG *storagePtr )
{
  struct pOS_IntuiMethod Mth;

  Mth.imth_Method=ICLMTH_Get;
  Mth.imth_U.imth_Get.imgt_ID=attrID;
  Mth.imth_U.imth_Get.imgt_Variable=storagePtr;
  return( pOS_DoIMethodA(object,(struct pOS_Method*)&Mth) );
}


ULONG SetGadgetAttrsA(struct Gadget *gadget,struct Window *window,struct Requester* req,struct TagItem *tagList)
  { return(pOS_SetGadgetAttrsA((struct pOS_Window*)window,(struct pOS_Gadget*)gadget,(struct pOS_TagItem*)tagList));}

ULONG SetGadgetAttrs(struct Gadget *gadget,struct Window *window,struct Requester* req,ULONG tag, ...)
  { return(pOS_SetGadgetAttrsA((struct pOS_Window*)window,(struct pOS_Gadget*)gadget,(struct pOS_TagItem*)&tag));}

struct DrawInfo *GetScreenDrawInfo( struct Screen *screen )
  { return((struct DrawInfo*) ((struct pOS_Screen*)screen)->scr_DrawInfo);}

void FreeScreenDrawInfo( struct Screen *screen, struct DrawInfo *drawInfo )
  {}

void ScrollWindowRaster(struct Window *win,long dx,long dy,long xMin,long yMin,long xMax,long yMax)
  {  pOS_ScrollRaster((struct pOS_RastPort*) ((struct pOS_Window*)win)->win_RastPort, dx,dy,xMin,yMin,xMax,yMax,0); }


void ReportMouse( long flag, struct Window *win )
  {
    pOS_ModifyIDCMP((struct pOS_Window*)win,
        flag ? (IDCMP_MouseMove | win->IDCMPFlags) : (win->IDCMPFlags & ~IDCMP_MouseMove) );
  }

void ReportMouse1( struct Window *win, long flag )
  {
    pOS_ModifyIDCMP((struct pOS_Window*)win,
        flag ? (IDCMP_MouseMove | win->IDCMPFlags) : (win->IDCMPFlags & ~IDCMP_MouseMove) );
  }

APTR AllocRemember( struct Remember **rememberKey,ULONG size,ULONG flags )
  {
    struct Remember *RB;

    RB=(struct Remember*)pOS_AllocMem(size+sizeof(struct Remember),flags);
    if(RB) {
      RB->NextRemember=*rememberKey;
      RB->RememberSize=size;
      RB->Memory=(UBYTE*)(RB+1);
      *rememberKey=RB;

      return((APTR) (RB+1));
    }
    return(NULL);
  }

void FreeRemember( struct Remember **rememberKey, long reallyForget )
  {
    struct Remember *RB,*RM;

    for(RB=*rememberKey; RB; RB=RM) {
      RM=RB->NextRemember;
      RB--;
      pOS_FreeMem(RB,sizeof(struct Remember)+RB->RememberSize);
    }
    *rememberKey=NULL;
  }

void MoveScreen( struct Screen *screen, long dx, long dy )
  {
    struct pOS_Screen* Scr=(struct pOS_Screen*)screen;
    pOS_SetScreenPosition(Scr,dx-Scr->scr_LeftEdge,dy-Scr->scr_TopEdge);
  }

void ScreenToBack( struct Screen *screen )
  { pOS_ScreenToBack((struct pOS_Screen*)screen); }

void ScreenToFront( struct Screen *screen )
  { pOS_ScreenToFront((struct pOS_Screen*)screen); }

/*MIC*/ void PrintIText(struct RastPort *rp, struct IntuiText *intuitext, LONG dx, LONG dy)
  {
    struct pOS_RastPort *RastPort;
    struct IntuiText    *Txt;

      if(RastPort=(struct pOS_RastPort *)pOS_AllocRastPort(((struct pOS_RastPort *)rp)->rp_Base,GFXTAG_MasterRastPort,rp,TAG_DONE))
      {
        for(Txt=intuitext; Txt; Txt=Txt->NextText)
        {
          struct pOS_TextFont *TxtFont=NULL;

          SetFont(RastPort,NULL);   /* default-Font setzen */

          if(Txt->ITextFont)
          {
            if((TxtFont=(struct pOS_TextFont *)pOS_OpenFont((struct pOS_TextAttr*)Txt->ITextFont)))
            {
              pOS_SetFont(RastPort,TxtFont);
            }
          }

          pOS_SetABPenDrMd(RastPort,Txt->FrontPen,Txt->BackPen,Txt->DrawMode);
          pOS_SetPosition(RastPort,Txt->LeftEdge+dx,Txt->TopEdge+dy+TxtFont->tf_Baseline);
          pOS_DrawText(RastPort,Txt->IText,strlen(Txt->IText));

          if(TxtFont)
          {
            pOS_CloseFont(TxtFont);
          }
        }

        pOS_FreeRastPort(RastPort);
      }
  }

/*MIC*/ LONG IntuiTextLength( struct IntuiText *intuitext )
  {
    struct pOS_Screen   *Screen;
    struct pOS_RastPort *RastPort;
    struct pOS_TextFont *TxtFont=NULL;
    struct pOS_TextDim TextDim;
    TextDim.td_MaxWidth=32000;

    if(Screen=pOS_LockPubScreen(NULL))
    {
      if(RastPort=(struct pOS_RastPort *)pOS_AllocRastPort(Screen->scr_RastPort->rp_Base,GFXTAG_RastPort,Screen->scr_RastPort,TAG_DONE))
      {
        if(intuitext->ITextFont)
        {
          if((TxtFont=(struct pOS_TextFont *)pOS_OpenFont((struct pOS_TextAttr*)intuitext->ITextFont)))
          {
            pOS_SetFont(RastPort,TxtFont);
          }
        }

        pOS_CalcTextDim(RastPort,intuitext->IText,strlen(intuitext->IText),&TextDim,0);

        if(TxtFont)
        {
          pOS_CloseFont(TxtFont);
        }

        pOS_FreeRastPort(RastPort);
      }
      pOS_UnlockPubScreen(Screen);
    }

    return( TextDim.td_UsedWidth );
  }








#ifdef __IGNORE_NOT_SUPPORTED__




BOOL ClearDMRequest( struct Window *window )
{return(0);}
void ClearPointer( struct Window *window )
{}
LONG CloseWorkBench( void )
{return(0);}
BOOL DisplayAlert( unsigned long alertNumber, UBYTE *string,ULONG height )
{return(0);}
void EndRequest( struct Requester *requester, struct Window *window )
{}
struct Preferences *GetDefPrefs( struct Preferences *preferences, long size )
{return(0);}
struct Preferences *GetPrefs( struct Preferences *preferences, long size )
{return(0);}
void InitRequester( struct Requester *requester )
{}
void ModifyProp(struct Gadget*,struct Window*,struct Requester*,ULONG,ULONG,ULONG,ULONG,ULONG)
{}
struct Screen *OpenScreen( struct NewScreen *newScreen )
{return(0);}
ULONG OpenWorkBench( void )
{return(0);}
BOOL Request( struct Requester *requester, struct Window *window )
{return(0);}
BOOL SetDMRequest( struct Window *window, struct Requester *requester )
{return(0);}
void SetPointer(struct Window*,UWORD*,long,long,long,long)
{}
void ShowTitle( struct Screen *screen, long showIt )
{}
struct View *ViewAddress( void )
{return(0);}
struct Preferences *SetPrefs(struct Preferences*,long,long)
{return(0);}
BOOL WBenchToBack( void )
{return(0);}
BOOL WBenchToFront( void )
{return(0);}
BOOL AutoRequest(struct Window*,struct IntuiText*,struct IntuiText*,struct IntuiText*,ULONG,ULONG,ULONG,ULONG)
{return(0);}
struct Window *BuildSysRequest(struct Window*,struct IntuiText*,struct IntuiText*,struct IntuiText*,ULONG,ULONG,ULONG)
{return(0);}
LONG MakeScreen( struct Screen *screen )
{return(0);}
LONG RemakeDisplay( void )
{return(0);}
LONG RethinkDisplay( void )
{return(0);}
ULONG LockIBase( unsigned long dontknow )
{return(0);}
void UnlockIBase( unsigned long ibLock )
{}
LONG GetScreenData(APTR,ULONG,ULONG,struct Screen*)
{return(0);}
void NewModifyProp(struct Gadget*,struct Window*,struct Requester*,ULONG,ULONG,ULONG,ULONG,ULONG,SLONG)
{}
void MoveWindowInFrontOf( struct Window*,struct Window*)
{}
struct Hook *SetEditHook(struct Hook*)
{return(0);}
struct List *LockPubScreenList( void )
{return(0);}
void UnlockPubScreenList( void )
{}
UBYTE *NextPubScreen( struct Screen *screen, UBYTE *namebuf )
{return(0);}
void SetDefaultPubScreen( UBYTE *name )
{}
UWORD SetPubScreenModes( unsigned long modes )
{return(0);}
struct RastPort *ObtainGIRPort( struct GadgetInfo *gInfo )
{return(0);}
void ReleaseGIRPort( struct RastPort *rp )
{}
void GadgetMouse(struct Gadget*,struct GadgetInfo*,WORD*)
{}
void GetDefaultPubScreen( UBYTE *nameBuffer )
{}
struct Window *BuildEasyRequestArgs(struct Window*,struct EasyStruct*,ULONG,APTR)
{return(0);}
struct Window *BuildEasyRequest(struct Window*,struct EasyStruct*,ULONG, ... )
{return(0);}
void DrawImageState(struct RastPort*,struct Image*,long,long,ULONG,struct DrawInfo*)
{}
BOOL PointInImage( unsigned long point, struct Image *image )
{return(0);}
void EraseImage(struct RastPort*,struct Image*,long,long)
{}
APTR NextObject( APTR objectPtrPtr )
{return(0);}
struct IClass *MakeClass(UBYTE*,UBYTE*,struct IClass*,ULONG,ULONG)
{return(0);}
void AddClass( struct IClass *classPtr )
{}
BOOL ResetMenuStrip( struct Window *window, struct Menu *menu )
{return(0);}
void RemoveClass( struct IClass *classPtr )
{}
BOOL FreeClass( struct IClass *classPtr )
{return(0);}
struct ScreenBuffer *AllocScreenBuffer(struct Screen*,struct BitMap*,ULONG)
{return(0);}
void FreeScreenBuffer( struct Screen *sc, struct ScreenBuffer *sb )
{}
ULONG ChangeScreenBuffer( struct Screen *sc, struct ScreenBuffer *sb )
{return(0);}
void ScreenDepth( struct Screen *screen, unsigned long flags, APTR reserved )
{}
void ScreenPosition(struct Screen*,ULONG,long,long,long,long)
{}
void LendMenus( struct Window *fromwindow, struct Window *towindow )
{}
ULONG DoGadgetMethodA(struct Gadget*,struct Window*,struct Requester*,APTR)
{return(0);}
ULONG DoGadgetMethod(struct Gadget*,struct Window*,struct Requester*,ULONG, ... )
{return(0);}
void SetWindowPointerA( struct Window *win, struct TagItem *taglist )
{}
void SetWindowPointer( struct Window *win, unsigned long tag1, ... )
{}
BOOL TimedDisplayAlert(ULONG,UBYTE*,ULONG,ULONG)
{return(0);}
void HelpControl( struct Window *win, unsigned long flags )
{}

#endif  /** __IGNORE_NOT_SUPPORTED__ **/



#endif