/* xtwraps - Drawing context wraps.

   Copyright (C) 1995 Free Software Foundation, Inc.

   Written by:  Adam Fedor <fedor@boulder.colorado.edu>
   Date: Nov 1995
   
   This file is part of the GNU Objective C User : (int *)erface library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   
   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   */

#include "wraps.h"
#include "DrawContext.h"
#include "DrawContextWraps.h"

void
PShidecursor( void )
{
  [currentContext DPShidecursor];
}


void
PSshowcursor( void )
{
  [currentContext DPSshowcursor];
}


void
PSobscurecursor( void )
{
  [currentContext DPSobscurecursor];
}


void
PSrevealcursor( void )
{
  [currentContext DPSrevealcursor];
}


void
PSsetcursor(float x, float y, float hotx, float hoty)
{
  [currentContext DPSsetcursor: x : y : hotx : hoty];
}


void
PSadjustcursor(float dx, float dy)
{
  [currentContext DPSadjustcursor: dx : dy];
}


void
PScurrentmouse(int winNum, float *x, float *y)
{
  [currentContext DPScurrentmouse: winNum : x : y];
}


void
PSsetmouse(float x, float y)
{
  [currentContext DPSsetmouse: x : y];
}


void
PSbuttondown(int *truth)
{
  [currentContext DPSbuttondown: truth];
}


void
PSrightbuttondown(int *truth)
{
  [currentContext DPSrightbuttondown: truth];
}


void
PSstilldown(int eNum, int *truth)
{
  [currentContext DPSstilldown: eNum : truth];
}


void
PSrightstilldown(int eNum, int *truth)
{
  [currentContext DPSrightstilldown: eNum : truth];
}


void
PSprinteventtimes( void )
{
  [currentContext DPSprinteventtimes];
}


void
PSiniteventtimes( void )
{
  [currentContext DPSiniteventtimes];
}


void
PSposteventbycontext(int type, float x, float y, int time, int flags, int win, int subtype, int data1, int data2, int context, int *success)
{
  [currentContext DPSposteventbycontext: type : x : y : time : flags : win
   : subtype : data1 : data2 : context : success];
}


void
PSsetflushexposures(int flag)
{
  [currentContext DPSsetflushexposures: flag];
}


void
PSsetwaitcursorenabled(int flag)
{
  [currentContext DPSsetwaitcursorenabled: flag];
}


void
PScurrentwaitcursorenabled(int *flag)
{
  [currentContext DPScurrentwaitcursorenabled: flag];
}


void
PSsetactiveapp(int cntxt)
{
  [currentContext DPSsetactiveapp: cntxt];
}


void
PScurrentactiveapp(int *cntxt)
{
  [currentContext DPScurrentactiveapp: cntxt];
}


void
PSosname(int size, char str[])
{
  [currentContext DPSosname: size : str];
}


void
PSostype(int *result)
{
  [currentContext DPSostype: result];
}


void
PSnextrelease(int size, char result[])
{
  [currentContext DPSnextrelease: size : result];
}


void
PScurrentrusage(float *now, float *uTime, float *sTime, int *msgSend, int *msgRcv, int *nSignals, int *nVCSw, int *nIvCSw)
{
  [currentContext DPScurrentrusage: now : uTime : sTime : msgSend : msgRcv
   : nSignals : nVCSw : nIvCSw];
}


void
PSplaysound(const char *name, int priority)
{
  [currentContext DPSplaysound: name : priority];
}


void
PScleardictstack( void )
{
  [currentContext DPScleardictstack];
}


void
PScurrentuser(int *uid, int *gid)
{
  [currentContext DPScurrentuser: uid : gid];
}


void
PSsetwriteblock(int flag)
{
  [currentContext DPSsetwriteblock: flag];
}


void
PScurrentwriteblock(int *flag)
{
  [currentContext DPScurrentwriteblock: flag];
}


void
PSmachportdevice(int w, int h, const int bbox[], int bboxSize, const float matrix[], const char *host, const char *port, const char *pixelDict)
{
  [currentContext DPSmachportdevice: w : h : bbox : bboxSize : matrix : host
   : port : pixelDict];
}


void
PScountframebuffers(int *count)
{
  [currentContext DPScountframebuffers: count];
}


void
PSframebuffer(int index, int nameLen, char name[], int *slot, int *unit, int *ROMid, int *x, int *y, int *w, int *h, int *depth)
{
  [currentContext DPSframebuffer: index : nameLen : name : slot : unit 
   : ROMid : x : y : w : h : depth];
}


void
PSsetframebuffertransfer( void )
{
  [currentContext DPSsetframebuffertransfer];
}


void
PScurrentframebuffertransfer( void )
{
  [currentContext DPScurrentframebuffertransfer];
}

void
PSwindow(float x, float y, float w, float h, int type, int *num)
{
  [currentContext DPSwindow: x : y : w : h : type : num];
}


void
PStermwindow(int num)
{
  [currentContext DPStermwindow: num];
}


void
PSwindowdevice(int num)
{
  [currentContext DPSwindowdevice: num];
}


void
PSwindowdeviceround(int num)
{
  [currentContext DPSwindowdeviceround: num];
}


void
PScurrentwindow(int *num)
{
  [currentContext DPScurrentwindow: num];
}


void
PSflushgraphics( void )
{
  [currentContext DPSflushgraphics];
}


void
PSorderwindow(int op, int otherWin, int winNum)
{
  [currentContext DPSorderwindow: op : otherWin : winNum];
}


void
PSmovewindow(float x, float y, int num)
{
  [currentContext DPSmovewindow: x : y: num];
}


void
PSplacewindow(float x, float y, float w, float h, int win)
{
  [currentContext DPSplacewindow: x : y : w : h : win];
}


void
PSfrontwindow(int *num)
{
  [currentContext DPSfrontwindow: num];
}


void
PSfindwindow(float x, float y, int op, int otherWin, float *lx, float *ly, int *winFound, int *didFind)
{
  [currentContext DPSfindwindow: x : y : op : otherWin : lx : ly : winFound
   : didFind];
}


void
PScurrentwindowbounds(int num, float *x, float *y, float *w, float *h)
{
  [currentContext DPScurrentwindowbounds: num : x : y : w : h];
}


void
PSseteventmask(int mask, int num)
{
  [currentContext DPSseteventmask: mask : num];
}


void
PScurrenteventmask(int num, int *mask)
{
  [currentContext DPScurrenteventmask: num : mask];
}


void
PSsetexposurecolor( void )
{
  [currentContext DPSsetexposurecolor];
}


void
PSsetsendexposed(int truth, int num)
{
  [currentContext DPSsetsendexposed: truth : num];
}


void
PSsetautofill(int truth, int num)
{
  [currentContext DPSsetautofill: truth : num];
}


void
PSsetwindowdict(int num)
{
  [currentContext DPSsetwindowdict: num];
}


void
PScurrentwindowdict(int num)
{
  [currentContext DPScurrentwindowdict: num];
}


void
PScurrentwindowalpha(int win, int *alpha)
{
  [currentContext DPScurrentwindowalpha: win : alpha];
}


void
PScountscreenlist(int context, int *count)
{
  [currentContext DPScountscreenlist: context : count];
}


void
PSscreenlist(int context, int count, int windows[])
{
  [currentContext DPSscreenlist: context : count : windows];
}


void
PScurrentdeviceinfo(int win, int *minbps, int *maxbps, int *color)
{
  [currentContext DPScurrentdeviceinfo: win : minbps : maxbps : color];
}


void
PSsetowner(int owner, int win)
{
  [currentContext DPSsetowner: owner : win];
}


void
PScurrentowner(int win, int *owner)
{
  [currentContext DPScurrentowner: win : owner];
}


void
PSbasetoscreen(float x, float y, float *xp, float *yp)
{
  [currentContext DPSbasetoscreen: x : y : xp : yp];
}


void
PSbasetocurrent(float x, float y, float *xp, float *yp)
{
  [currentContext DPSbasetocurrent: x : y : xp : yp];
}


void
PSscreentocurrent(float x, float y, float *xp, float *yp)
{
  [currentContext DPSscreentocurrent: x : y : xp : yp];
}


void
PSscreentobase(float x, float y, float *xp, float *yp)
{
  [currentContext DPSscreentobase: x : y : xp : yp];
}


void
PScurrenttoscreen(float x, float y, float *xp, float *yp)
{
  [currentContext DPScurrenttoscreen: x : y : xp : yp];
}


void
PScurrenttobase(float x, float y, float *xp, float *yp)
{
  [currentContext DPScurrenttobase: x : y : xp : yp];
}


void
PSdumpwindow(int level, int win)
{
  [currentContext DPSdumpwindow: level : win];
}


void
PSdumpwindows(int level, int context)
{
  [currentContext DPSdumpwindows: level : context];
}


void
PSsetwindowtype(int type, int win)
{
  [currentContext DPSsetwindowtype: type : win];
}


void
PSsetwindowlevel(int level, int win)
{
  [currentContext DPSsetwindowlevel: level : win];
}


void
PScurrentwindowlevel(int win, int *level)
{
  [currentContext DPScurrentwindowlevel: win : level];
}


void
PScountwindowlist(int context, int *count)
{
  [currentContext DPScountwindowlist: context : count];
}


void
PSwindowlist(int context, int count, int windows[])
{
  [currentContext DPSwindowlist: context : count : windows];
}


void
PSsetwindowdepthlimit(int limit, int win)
{
  [currentContext DPSsetwindowdepthlimit: limit : win];
}


void
PScurrentwindowdepthlimit(int win, int *limit)
{
  [currentContext DPScurrentwindowdepthlimit: win : limit];
}


void
PScurrentwindowdepth(int win, int *depth)
{
  [currentContext DPScurrentwindowdepth: win : depth];
}


void
PSsetdefaultdepthlimit(int limit)
{
  [currentContext DPSsetdefaultdepthlimit: limit];
}


void
PScurrentdefaultdepthlimit(int *limit)
{
  [currentContext DPScurrentdefaultdepthlimit: limit];
}


void
PSsetshowpageprocedure(int win)
{
  [currentContext DPSsetshowpageprocedure: win];
}


void
PScurrentshowpageprocedure( void )
{
  [currentContext DPScurrentshowpageprocedure];
}


void
PSsettrackingrect(float x, float y, float w, float h, int leftreqd, int rightreqd, int in, int userData, int tNum, int gstateNum)
{
  [currentContext DPSsettrackingrect: x : y : w : h : leftreqd : rightreqd
   : in : userData : tNum : gstateNum];
}


void
PScleartrackingrect(int nrectnum, int gstateNum)
{
  [currentContext DPScleartrackingrect: nrectnum : gstateNum];
}


void
PSnewinstance( void )
{
  [currentContext DPSnewinstance];
}


void
PShideinstance(float x, float y, float w, float h)
{
  [currentContext DPShideinstance: x : y : w : h];
}


void
PSsetinstance(int truth)
{
  [currentContext DPSsetinstance: truth];
}


void
PScomposite(float x, float y, float w, float h, int gstateNum, float dx, float dy, int op)
{
  [currentContext DPScomposite: x : y : w : h : gstateNum : dx : dy : op];
}


void
PScompositerect(float x, float y, float w, float h, int op)
{
  [currentContext DPScompositerect: x : y : w : h : op];
}


void
PSdissolve(float x, float y, float w, float h, int gstateNum, float dx, float dy, float delta)
{
  [currentContext DPSdissolve: x : y : w : h : gstateNum : dx : dy : delta];
}


void
PSsizeimage(float x, float y, float w, float h, int *dw, int *dh, int *depth, float m[], int *multiproc, int *numColors)
{
  [currentContext DPSsizeimage: x : y : w : h : dw : dh : depth : m
   : multiproc : numColors];
}


void
PSreadimage( void )
{
  [currentContext DPSreadimage];
}


void
PSalphaimage( void )
{
  [currentContext DPSalphaimage];
}


void
PSsetalpha(float a)
{
  [currentContext DPSsetalpha: a];
}


void
PScurrentalpha(float *alpha)
{
  [currentContext DPScurrentalpha: alpha];
}
