/* called from rui.c, only */
menu getGraphMenu(const char* menuname)
{
int devnum;
pGEDevDesc gdd;
gadesc *xd;
menuname = menuname + 6;
devnum = atoi(menuname);
if(devnum < 1 || devnum > R_MaxDevices)
error(_("invalid graphical device number"));
while (('0' <= *menuname) && (*menuname <= '9')) menuname++;
gdd = GEgetDevice(devnum - 1);
if(!gdd) error(_("invalid device"));
xd = (gadesc *) gdd->dev->deviceSpecific;
if(!xd || xd->kind != SCREEN) error(_("bad device"));
if (strcmp(menuname, "Main") == 0) return(xd->mbar);
else if (strcmp(menuname, "Popup") == 0) return(xd->grpopup);
else return(NULL);
}
static void
GrDev_dealloc(PyGrDevObject *self)
{
#ifdef RPY_DEBUG_GRDEV
printf("FIXME: Deallocating GrDev (device number %i).\n", RPY_DEV_NUM(self));
#endif
pGEDevDesc dd = GEgetDevice(RPY_DEV_NUM(self)-1);
/* Caution: GEkillDevice will call the method "close()" for the the device. */
/* (See GrDev_close for details) */
if (dd) GEkillDevice(dd);
#ifdef RPY_DEBUG_GRDEV
printf("GrDevDealloc: PyMem_Free()\n");
#endif
printf("--> skipping PyMem_Free(((PyGrDevObject *)self)->grdev) \n");
//PyMem_Free(((PyGrDevObject *)self)->grdev);
#if (PY_VERSION_HEX < 0x03010000)
self->ob_type->tp_free((PyObject*)self);
#else
Py_TYPE(self)->tp_free((PyObject*)self);
#endif
#ifdef RPY_DEBUG_GRDEV
printf(" done.\n");
#endif
}
/* grDevices::msgWindow */
SEXP msgwindow(SEXP sdev, SEXP stype)
{
int dev, type;
pGEDevDesc gdd;
gadesc *xd;
dev = asInteger(sdev);
type = asInteger(stype);
if(dev == -1) { /* console */
if(CharacterMode == RGui) GA_msgWindow(RConsole, type);
} else {
if(dev < 1 || dev > R_MaxDevices || dev == NA_INTEGER)
error(_("invalid '%s' argument"), "which");
gdd = GEgetDevice(dev - 1);
if(!gdd) error(_("invalid device"));
xd = (gadesc *) gdd->dev->deviceSpecific;
if(!xd) error(_("invalid device"));
if(type == 5) {
xd->recording = TRUE;
check(xd->mrec);
} else if(type == 6) {
xd-> recording = FALSE;
uncheck(xd->mrec);
} else
GA_msgWindow(xd->gawin, type);
}
return R_NilValue;
}
void reloadJavaGD(int *dn) {
GEDevDesc *gd= GEgetDevice(*dn);
if (gd) {
NewDevDesc *dd=gd->dev;
#ifdef JGD_DEBUG
printf("reloadJavaGD: dn=%d, dd=%lx\n", *dn, (unsigned long)dd);
#endif
if (dd) resizedJavaGD(dd);
}
}
void resizedJavaGD(NewDevDesc *dd) {
int devNum;
/* newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific; */
#ifdef JGD_DEBUG
printf("dd->size=%lx\n", (unsigned long)dd->size);
#endif
dd->size(&(dd->left), &(dd->right), &(dd->bottom), &(dd->top), dd);
devNum = ndevNumber(dd);
if (devNum > 0)
GEplayDisplayList(GEgetDevice(devNum));
}
static void *getDeviceHandle(int dev)
{
pGEDevDesc gdd;
gadesc *xd;
if (dev == -1) return(getHandle(RConsole));
if (dev < 1 || dev > R_MaxDevices || dev == NA_INTEGER) return(0);
gdd = GEgetDevice(dev - 1);
if (!gdd) return(NULL);
xd = (gadesc *) gdd->dev->deviceSpecific;
if (!xd) return(NULL);
return getHandle(xd->gawin);
}
void ide_device::output_and_kill_file_device() {
rhost::util::errors_to_exceptions([&] {
// The device number is not constant, so get the current number
int file_device_num = Rf_ndevNumber(_file_device);
// Killing the device will call close, which will save the file to disk
pGEDevDesc ge_dev_desc = GEgetDevice(file_device_num);
GEkillDevice(ge_dev_desc);
});
// Blank our state, next call to graphics primitive (if any) will create
// a new file device on demand
_file_device = nullptr;
_file_device_filename = std::tr2::sys::path();
}
SEXP attribute_hidden
do_getGraphicsEventEnv(SEXP call, SEXP op, SEXP args, SEXP env)
{
int devnum;
pGEDevDesc gdd;
checkArity(op, args);
devnum = INTEGER(CAR(args))[0] - 1;
if(devnum < 1 || devnum > R_MaxDevices)
error(_("invalid graphical device number"));
gdd = GEgetDevice(devnum);
if(!gdd) errorcall(call, _("invalid device"));
return gdd->dev->eventEnv;
}
Rboolean haveListeningDev()
{
Rboolean ret = FALSE;
pDevDesc dd;
pGEDevDesc gd;
if(!NoDevices())
{
for(int i = 1; i < NumDevices(); i++)
{
if ((gd = GEgetDevice(i)) && (dd = gd->dev)
&& dd->gettingEvent){
ret = TRUE;
break;
}
}
}
return ret;
}
SEXP javaGDobjectCall(SEXP dev) {
int ds=NumDevices();
int dn;
GEDevDesc *gd;
void *ptr=0;
if (!isInteger(dev) || LENGTH(dev)<1) return R_NilValue;
dn = INTEGER(dev)[0];
if (dn<0 || dn>=ds) return R_NilValue;
gd=GEgetDevice(dn);
if (gd) {
NewDevDesc *dd=gd->dev;
if (dd) {
newJavaGDDesc *xd=(newJavaGDDesc*) dd->deviceSpecific;
if (xd) ptr = xd->talk;
}
}
if (!ptr) return R_NilValue;
return R_MakeExternalPtr(ptr, R_NilValue, R_NilValue);
}
pDevDesc ide_device::create_file_device(const std::string& device_type, const std::tr2::sys::path& filename, double width, double height) {
auto expr = boost::format("%1%(filename='%2%', width=%3%, height=%4%)") % device_type % filename.generic_string() % width % height;
// Create the file device via the public R API
ParseStatus ps;
auto result = rhost::eval::r_try_eval_str(expr.str(), R_GlobalEnv, ps);
if (result.has_error) {
throw rhost::util::r_error(result.error.c_str());
}
pDevDesc dev_desc = nullptr;
// Retrieve the device descriptor of the current device (the one created above)
rhost::util::errors_to_exceptions([&] {
int device_num = Rf_curDevice();
pGEDevDesc ge_dev_desc = GEgetDevice(device_num);
dev_desc = ge_dev_desc->dev;
});
return dev_desc;
}
void javaGDresize(int dev) {
int ds=NumDevices();
int i=0;
if (dev>=0 && dev<ds) { i=dev; ds=dev+1; }
while (i<ds) {
GEDevDesc *gd=GEgetDevice(i);
if (gd) {
NewDevDesc *dd=gd->dev;
#ifdef JGD_DEBUG
printf("javaGDresize: device=%d, dd=%lx\n", i, (unsigned long)dd);
#endif
if (dd) {
#ifdef JGD_DEBUG
printf("dd->size=%lx\n", (unsigned long)dd->size);
#endif
dd->size(&(dd->left), &(dd->right), &(dd->bottom), &(dd->top), dd);
GEplayDisplayList(gd);
}
}
i++;
}
}
SEXP attribute_hidden
do_setGraphicsEventEnv(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP eventEnv;
int devnum;
pGEDevDesc gdd;
pDevDesc dd;
checkArity(op, args);
devnum = INTEGER(CAR(args))[0] - 1;
if(devnum < 1 || devnum > R_MaxDevices)
error(_("invalid graphical device number"));
gdd = GEgetDevice(devnum);
if(!gdd) errorcall(call, _("invalid device"));
dd = gdd->dev;
args=CDR(args);
eventEnv = CAR(args);
if (TYPEOF(eventEnv) != ENVSXP)
error(_("internal error"));
if (!dd->canGenMouseDown &&
!dd->canGenMouseUp &&
!dd->canGenMouseMove &&
!dd->canGenKeybd)
error(_("this graphics device does not support event handling"));
if (!dd->canGenMouseDown) checkHandler(mouseHandlers[0], eventEnv);
if (!dd->canGenMouseUp) checkHandler(mouseHandlers[1], eventEnv);
if (!dd->canGenMouseMove) checkHandler(mouseHandlers[1], eventEnv);
if (!dd->canGenKeybd) checkHandler(keybdHandler, eventEnv);
dd->eventEnv = eventEnv;
return(R_NilValue);
}
/* grDevices::bringToTop */
SEXP bringtotop(SEXP sdev, SEXP sstay)
{
int dev, stay;
pGEDevDesc gdd;
gadesc *xd;
dev = asInteger(sdev);
stay = asInteger(sstay);
if(dev == -1) { /* console */
if(CharacterMode == RGui) BringToTop(RConsole, stay);
} else {
if(dev < 1 || dev > R_MaxDevices || dev == NA_INTEGER)
error(_("invalid '%s' argument"), "which");
gdd = GEgetDevice(dev - 1);
if(!gdd) error(_("invalid device"));
xd = (gadesc *) gdd->dev->deviceSpecific;
if(!xd) error(_("invalid device"));
if(stay && ismdi()) error(_("requires SDI mode"));
BringToTop(xd->gawin, stay);
}
return R_NilValue;
}
SEXP attribute_hidden
do_getGraphicsEvent(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP result = R_NilValue, prompt;
pDevDesc dd;
pGEDevDesc gd;
int i, count=0, devNum;
checkArity(op, args);
prompt = CAR(args);
if (!isString(prompt) || !length(prompt)) error(_("invalid prompt"));
/* NB: cleanup of event handlers must be done by driver in onExit handler */
if (!NoDevices()) {
/* Initialize all devices */
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
gd = GEgetDevice(devNum);
dd = gd->dev;
if (dd->gettingEvent)
error(_("recursive use of getGraphicsEvent not supported"));
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 1);
dd->gettingEvent = TRUE;
defineVar(install("result"), R_NilValue, dd->eventEnv);
count++;
}
devNum = nextDevice(devNum);
}
if (!count)
error(_("no graphics event handlers set"));
Rprintf("%s\n", CHAR(asChar(prompt)));
R_FlushConsole();
/* Poll them */
while (result == R_NilValue) {
R_ProcessEvents();
R_CheckUserInterrupt();
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
gd = GEgetDevice(devNum);
dd = gd->dev;
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 2);
result = findVar(install("result"), dd->eventEnv);
if (result != R_NilValue && result != R_UnboundValue) {
break;
}
}
devNum = nextDevice(devNum);
}
}
/* clean up */
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
gd = GEgetDevice(devNum);
dd = gd->dev;
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 0);
dd->gettingEvent = FALSE;
}
devNum = nextDevice(devNum);
}
}
return(result);
}