/**
* Plot an image at the given coordinates using tinct
*
* \param area The sprite area containing the sprite
* \param x Left edge of sprite
* \param y Top edge of sprite
* \param req_width The requested width of the sprite
* \param req_height The requested height of the sprite
* \param width The actual width of the sprite
* \param height The actual height of the sprite
* \param background_colour The background colour to blend to
* \param repeatx Repeat the image in the x direction
* \param repeaty Repeat the image in the y direction
* \param alpha Use the alpha channel
* \param tinct_options The base option set to use
* \return true on success, false otherwise
*/
bool image_redraw_tinct(osspriteop_id header, int x, int y,
int req_width, int req_height, int width, int height,
colour background_colour, bool repeatx, bool repeaty,
bool alpha, unsigned int tinct_options)
{
_kernel_oserror *error;
/* Set up our flagword
*/
tinct_options |= background_colour << tinct_BACKGROUND_SHIFT;
if (print_active)
tinct_options |= tinct_USE_OS_SPRITE_OP;
if (repeatx)
tinct_options |= tinct_FILL_HORIZONTALLY;
if (repeaty)
tinct_options |= tinct_FILL_VERTICALLY;
if (alpha) {
error = _swix(Tinct_PlotScaledAlpha, _INR(2,7),
header, x, y - req_height,
req_width, req_height, tinct_options);
} else {
error = _swix(Tinct_PlotScaled, _INR(2,7),
header, x, y - req_height,
req_width, req_height, tinct_options);
}
if (error) {
LOG(("xtinct_plotscaled%s: 0x%x: %s", (alpha ? "alpha" : ""),
error->errnum, error->errmess));
return false;
}
return true;
}
char *heap_claim(char *base, size_t required_size)
{
_kernel_oserror *e;
int largest;
unsigned int actual_change;
void *block;
heapcb *cb;
if (required_size == 0)
return NULL;
cb = getcb(base);
if (cb == NULL)
return NULL; /* unknown heap */
/* Repeatedly attempt to claim a block of the required size */
while ((e = _swix(OS_Heap, _INR(0,1)|_IN(3)|_OUT(2), 2, base,
required_size, &block)) != NULL)
{
int errnum;
/* MemCheck_RegisterMiscBlock(e, sizeof(e->errnum)); */
errnum = e->errnum;
/* MemCheck_UnRegisterMiscBlock(e); */
if (errnum != 0x184 /* Heap Full */)
{
#ifndef NDEBUG
EC(e);
#endif
return NULL; /* unknown error */
}
/* Read largest free space */
_swi(OS_Heap, _INR(0,1)|_OUT(2), 1, base, &largest);
/* Increase the dynamic area by at least the difference between what we
* want and what we have spare */
if (EC(_swix(OS_ChangeDynamicArea, _INR(0,1)|_OUT(1), cb->area,
required_size - largest, &actual_change)) != NULL)
return NULL; /* (most likely) out of memory */
/* Resize the heap itself */
_swi(OS_Heap, _INR(0,1)|_IN(3), 5, base, actual_change);
}
/* MemCheck_RegisterMiscBlock(block, required_size); */
return block;
}
char *heap_create(const char *description, size_t size_limit)
{
heapcb *cb;
int page_size;
/* Get a new heapcb and link it into the start of the chain */
cb = malloc(sizeof(heapcb));
if (cb == NULL)
return NULL; /* failed - unable to allocate space for control block */
cb->next = first_cb;
first_cb = cb;
/* Create a dynamic area at least one page in size and set it up as a heap
*/
_swi(OS_ReadMemMapInfo, _OUT(0), &page_size);
if (EC(_swix(OS_DynamicArea, _INR(0,8)|_OUT(1)|_OUT(3), 0, -1, page_size,
-1, 0x80, size_limit, NULL, -1, description, &cb->area,
&cb->base)))
{
free(cb);
return NULL;
}
/* page_size must be enough to hold the default heap structure */
_swi(OS_Heap, _INR(0,1)|_IN(3), 0, cb->base, page_size);
return cb->base;
}
_kernel_oserror *SWI_OS_File_5(const char *filename, int *objtype,
unsigned int *loadaddr,
unsigned int *execaddr,
int *length, int *attrib)
{ /* read file info */
int _objtype,_length,_attrib;
unsigned int _loadaddr,_execaddr;
_kernel_oserror *err = _swix(OS_File,_INR(0,1)|_OUT(0)|_OUTR(2,5),5,
filename,
&_objtype,&_loadaddr,&_execaddr,&_length,
&_attrib);
if (err)
return err;
if (objtype)
*objtype = _objtype;
if (loadaddr)
*loadaddr = _loadaddr;
if (execaddr)
*execaddr = _execaddr;
if (length)
*length = _length;
if (attrib)
*attrib = _attrib;
return NULL;
}
void heap_delete(char *base)
{
heapcb *cb;
heapcb *thiscb;
cb = getcb(base);
if (cb == NULL)
return; /* unknown heap */
/* Delete the dynamic area */
EC(_swix(OS_DynamicArea, _INR(0,1), 1, cb->area));
/* remove its heapcb from the chain */
if (cb == first_cb)
{
/* start of chain */
first_cb = first_cb->next;
}
else
{
/* elsewhere in chain */
for (thiscb = first_cb; thiscb->next != cb; thiscb = thiscb->next)
;
thiscb->next = cb->next;
}
free(cb);
}
void ro_gui_options_image_redraw(wimp_draw *redraw)
{
osbool more;
os_error *error;
wimp_icon_state icon_state;
osspriteop_header *bg = NULL, *fg = NULL;
unsigned int bg_tinct = 0, fg_tinct = 0;
/* get the icon location */
icon_state.w = redraw->w;
icon_state.i = IMAGE_CURRENT_DISPLAY;
error = xwimp_get_icon_state(&icon_state);
if (error) {
LOG("xwimp_get_icon_state: 0x%x: %s",
error->errnum, error->errmess);
ro_warn_user("MenuError", error->errmess);
return;
}
/* find the sprites */
if (example_images) {
ro_gui_options_image_read(redraw->w, &bg_tinct, &fg_tinct);
fg_tinct |= 0xeeeeee00;
xosspriteop_select_sprite(osspriteop_USER_AREA,
example_images, (osspriteop_id)"img_bg", &bg);
xosspriteop_select_sprite(osspriteop_USER_AREA,
example_images, (osspriteop_id)"img_fg", &fg);
}
/* perform the redraw */
more = wimp_redraw_window(redraw);
while (more) {
int origin_x, origin_y;
origin_x = redraw->box.x0 - redraw->xscroll +
icon_state.icon.extent.x0 + 2;
origin_y = redraw->box.y1 - redraw->yscroll +
icon_state.icon.extent.y0 + 2;
if (bg)
_swix(Tinct_Plot, _INR(2,4) | _IN(7),
bg, origin_x, origin_y, bg_tinct);
if (fg)
_swix(Tinct_PlotAlpha, _INR(2,4) | _IN(7),
fg, origin_x, origin_y, fg_tinct);
more = wimp_get_rectangle(redraw);
}
}
int SWI_Read_Timezone(void)
{ /* returns the timezone offset (centiseconds) */
int ofs;
_kernel_oserror *err = _swix(Territory_ReadCurrentTimeZone,_OUT(0),&ofs);
if (err)
return 0;
return ofs;
}
_kernel_oserror *SWI_OS_ReadVarVal(const char *var, char *buf, int len,
int *bytesused)
{ /* reads an OS varibale */
int _bytesused;
_kernel_oserror *err = _swix(OS_ReadVarVal,_INR(0,4)|_OUT(2),var,buf,len,
0,0,&_bytesused);
if (err)
return err;
if (bytesused)
*bytesused = _bytesused;
return NULL;
}
bool OSystem_RISCOS::openUrl(const Common::String &url) {
int flags;
if (_swix(URI_Dispatch, _INR(0,2)|_OUT(0), 0, url.c_str(), 0, &flags) != NULL) {
warning("openUrl() (RISCOS) failed to open URL");
return false;
}
if ((flags & 1) == 1) {
warning("openUrl() (RISCOS) failed to open URL");
return false;
}
return true;
}
FILE *piechart_init(char *filename) {
FILE *pieoutf;
int xsize, ysize, b1, b2;
if ((pieoutf = FOPENWB(filename)) == NULL) {
warn('F', TRUE, "Failed to open pie chart file %s for writing: "
"ignoring it", filename);
return(pieoutf);
}
debug('F', "Opening %s as pie chart file", filename);
#ifdef RISCOS
_swix(OS_File, _INR(0,2), 18, filename, 0xb60); /* set PNG filetype */
#endif
xsize = normalchart?XSIZE:SHORTXSIZE;
ysize = normalchart?YSIZE:SHORTYSIZE;
im = gdImageCreate(xsize, ysize);
/* The first colour allocated in a new image is the background colour. */
white = gdImageColorAllocate(im, 255, 255, 255); /* white */
black = gdImageColorAllocate(im, 0, 0, 0); /* black */
grey = gdImageColorAllocate(im, 128, 128, 128); /* grey */
lightgrey = gdImageColorAllocate(im, 217, 217, 217); /* light grey */
col = 0;
/* Wedge colours. If these change, so must images/sq*. */
colours[col++] = gdImageColorAllocate(im, 255, 0, 0); /* red */
colours[col++] = gdImageColorAllocate(im, 0, 0, 255); /* mid blue */
colours[col++] = gdImageColorAllocate(im, 0, 128, 0); /* green */
colours[col++] = gdImageColorAllocate(im, 255, 128, 0); /* orange */
colours[col++] = gdImageColorAllocate(im, 0, 0, 128); /* navy blue */
colours[col++] = gdImageColorAllocate(im, 0, 255, 0); /* pale green */
colours[col++] = gdImageColorAllocate(im, 255, 128, 128); /* pink */
colours[col++] = gdImageColorAllocate(im, 0, 255, 255); /* cyan */
colours[col++] = gdImageColorAllocate(im, 128, 0, 128); /* purple */
colours[col++] = gdImageColorAllocate(im, 255, 255, 0); /* yellow */
col = 0;
totangle = 0.75; /* starting at the top */
boxesy = BOXESTOP;
b1 = xsize - 1 - BORDER;
b2 = ysize - 1 - BORDER;
/* Plot outline of pie, and border of image */
gdImageArc(im, XCENTRE, YCENTRE, DIAMETER + 2, DIAMETER + 2, 0, 360, black);
gdImageRectangle(im, BORDER, BORDER, b1, b2, black);
gdImageLine(im, xsize - 1, 0, b1, BORDER, black);
gdImageLine(im, 0, ysize - 1, BORDER, b2, black);
gdImageFill(im, 0, 0, lightgrey);
gdImageFill(im, xsize - 1, ysize - 1, grey);
gdImageLine(im, 0, 0, BORDER, BORDER, black);
gdImageLine(im, xsize - 1, ysize - 1, b1, b2, black);
return(pieoutf);
}
const char *mime_fromfiletype(int filetype)
{
static char buffer[256];
if (EC(_swix(0x50b00 /* MimeMap_Translate */,
_INR(0,3),
0,
filetype,
2,
buffer)) != NULL)
return "application/octet-stream";
return buffer;
}
_kernel_oserror *SWI_OS_FSControl_37(const char *pathname, char *buffer,
int *size)
{ /* canonicalise path */
return _swix(OS_FSControl,_INR(0,5)|_OUT(5),37,pathname,buffer,0,0,*size,
size);
}
_kernel_oserror *SWI_OS_FSControl_26(const char *source, const char *dest,
int actionmask)
{ /* copy */
return _swix(OS_FSControl,_INR(0,3),26,source,dest,actionmask);
}
_kernel_oserror *SWI_OS_FSControl_27(const char *filename, int actionmask)
{ /* wipe */
return _swix(OS_FSControl,_INR(0,1)|_IN(3),27,filename,actionmask);
}
_kernel_oserror *SWI_OS_GBPB_9(const char *dirname, void *buf, int *number,
int *offset, int size, const char *match)
{ /* read dir */
return _swix(OS_GBPB,_INR(0,6)|_OUTR(3,4),9,dirname,buf,
*number,*offset,size,match,number,offset);
}
/*
* close_output
*
* close output file, if it not stdout
*/
BOOL write_output(HSCPRC * hp)
{
#define MAX_ERRORLEN 500
STRPTR outfilenm = NULL;
BOOL written = FALSE;
if (outfilename)
outfilenm = estr2str(outfilename);
if ((return_code == RC_OK)
|| (return_code == RC_WARN)
|| hp->debug) {
FILE *outfile = NULL; /* output file */
char buf[MAX_ERRORLEN + 2]; /* buffer for error string */
/*
* try to open output file
*/
if (outfilenm) {
errno = 0;
outfile = fopen(outfilenm, "w");
if (!outfile) {
strncpy(buf, "unable to open `", MAX_ERRORLEN);
strncat(buf, estr2str(outfilename),
MAX_ERRORLEN - strlen(buf));
strncat(buf, "' for output: ", MAX_ERRORLEN - strlen(buf));
strncat(buf, strerror(errno), MAX_ERRORLEN - strlen(buf));
status_error(buf);
}
} else {
outfile = stdout;
outfilenm = STDOUT_NAME;
}
/*
* write output
*/
if (outfile) {
DLNODE *nd = dll_first(outlist);
status_msg("writing output...");
errno = 0;
/* write whole list of output-strings */
while (nd && !errno) {
EXPSTR *outstring = (EXPSTR *) dln_data(nd);
nd = dln_next(nd);
fwrite(estr2str(outstring), sizeof(char),
estrlen(outstring), outfile);
}
/* handle write-error, display message */
if (errno) {
strncpy(buf, "error writing `", MAX_ERRORLEN);
strncat(buf, outfilenm, MAX_ERRORLEN - strlen(buf));
strncat(buf, "': ", MAX_ERRORLEN - strlen(buf));
strncat(buf, strerror(errno), MAX_ERRORLEN - strlen(buf));
status_error(buf);
} else
written = TRUE;
status_clear();
/* close output file */
if (outfile != stdout)
{
fclose(outfile);
#ifdef RISCOS
{
/* set the filetype to HTML (&FAF) */
char *riscos_filename=unixname_to_riscos(outfilenm);
_swix(OS_File,_IN(0)|_IN(1)|_IN(2),18,riscos_filename,0xFAF);
free(riscos_filename);
}
#endif
}
}
} else {
status_msg("no output written");
status_lf();
}
return (written);
}
_kernel_oserror *SWI_OS_File_1(const char *filename, unsigned int loadaddr,
unsigned int execaddr, int attrib)
{ /* write file attributes */
return _swix(OS_File,_INR(0,3)|_IN(5),1,filename,loadaddr,execaddr,attrib);
}
bool artworks_redraw(struct content *c, struct content_redraw_data *data,
const struct rect *clip, const struct redraw_context *ctx)
{
static const ns_os_vdu_var_list vars = {
os_MODEVAR_XEIG_FACTOR,
{
os_MODEVAR_YEIG_FACTOR,
os_MODEVAR_LOG2_BPP,
os_VDUVAR_END_LIST
}
};
artworks_content *aw = (artworks_content *) c;
struct awinfo_block info;
const char *source_data;
unsigned long source_size;
os_error *error;
os_trfm matrix;
int vals[24];
int clip_x0 = clip->x0;
int clip_y0 = clip->y0;
int clip_x1 = clip->x1;
int clip_y1 = clip->y1;
if (ctx->plot->flush && !ctx->plot->flush())
return false;
/* pick up render addresses again in case they've changed
(eg. newer AWRender module loaded since we first loaded this file) */
(void)_swix(AWRender_RenderAddress, _OUT(0) | _OUT(1),
&aw->render_routine,
&aw->render_workspace);
/* Scaled image. Transform units (65536*OS units) */
matrix.entries[0][0] = data->width * 65536 / c->width;
matrix.entries[0][1] = 0;
matrix.entries[1][0] = 0;
matrix.entries[1][1] = data->height * 65536 / c->height;
/* Draw units. (x,y) = bottom left */
matrix.entries[2][0] = ro_plot_origin_x * 256 + data->x * 512 -
aw->x0 * data->width / c->width;
matrix.entries[2][1] = ro_plot_origin_y * 256 -
(data->y + data->height) * 512 -
aw->y0 * data->height / c->height;
info.ditherx = ro_plot_origin_x;
info.dithery = ro_plot_origin_y;
clip_x0 -= data->x;
clip_y0 -= data->y;
clip_x1 -= data->x;
clip_y1 -= data->y;
if (data->scale == 1.0) {
info.clip_x0 = (clip_x0 * 512) + aw->x0 - 511;
info.clip_y0 = ((c->height - clip_y1) * 512) + aw->y0 - 511;
info.clip_x1 = (clip_x1 * 512) + aw->x0 + 511;
info.clip_y1 = ((c->height - clip_y0) * 512) + aw->y0 + 511;
}
else {
info.clip_x0 = (clip_x0 * 512 / data->scale) + aw->x0 - 511;
info.clip_y0 = ((c->height - (clip_y1 / data->scale)) * 512) +
aw->y0 - 511;
info.clip_x1 = (clip_x1 * 512 / data->scale) + aw->x0 + 511;
info.clip_y1 = ((c->height - (clip_y0 / data->scale)) * 512) +
aw->y0 + 511;
}
info.print_lowx = 0;
info.print_lowy = 0;
info.print_handle = 0;
info.bgcolour = 0x20000000 | data->background_colour;
error = xos_read_vdu_variables(PTR_OS_VDU_VAR_LIST(&vars), vals);
if (error) {
LOG("xos_read_vdu_variables: 0x%x: %s", error->errnum, error->errmess);
return false;
}
error = xwimp_read_palette((os_palette*)&vals[3]);
if (error) {
LOG("xwimp_read_palette: 0x%x: %s", error->errnum, error->errmess);
return false;
}
source_data = content__get_source_data(c, &source_size);
error = awrender_render(source_data,
&info,
&matrix,
vals,
&aw->block,
&aw->size,
110, /* fully anti-aliased */
0,
source_size,
aw->render_routine,
aw->render_workspace);
if (error) {
LOG("awrender_render: 0x%x: %s", error->errnum, error->errmess);
return false;
}
return true;
}
bool artworks_convert(struct content *c)
{
artworks_content *aw = (artworks_content *) c;
union content_msg_data msg_data;
const char *source_data;
unsigned long source_size;
void *init_workspace;
void *init_routine;
os_error *error;
int used = -1; /* slightly better with older OSLib versions */
char *title;
/* check whether AWViewer has been seen and we can therefore
locate the ArtWorks rendering modules */
xos_read_var_val_size("Alias$LoadArtWorksModules", 0, os_VARTYPE_STRING,
&used, NULL, NULL);
if (used >= 0) {
LOG("Alias$LoadArtWorksModules not defined");
msg_data.error = messages_get("AWNotSeen");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
/* load the modules, or do nothing if they're already loaded */
error = xos_cli("LoadArtWorksModules");
if (error) {
LOG("xos_cli: 0x%x: %s", error->errnum, error->errmess);
msg_data.error = error->errmess;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
/* lookup the addresses of the init and render routines */
error = (os_error*)_swix(AWRender_FileInitAddress, _OUT(0) | _OUT(1),
&init_routine, &init_workspace);
if (error) {
LOG("AWRender_FileInitAddress: 0x%x: %s", error->errnum, error->errmess);
msg_data.error = error->errmess;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
error = (os_error*)_swix(AWRender_RenderAddress, _OUT(0) | _OUT(1),
&aw->render_routine,
&aw->render_workspace);
if (error) {
LOG("AWRender_RenderAddress: 0x%x: %s", error->errnum, error->errmess);
msg_data.error = error->errmess;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
source_data = content__get_source_data(c, &source_size);
/* initialise (convert file to new format if required) */
error = awrender_init(&source_data, &source_size,
init_routine, init_workspace);
if (error) {
LOG("awrender_init: 0x%x : %s", error->errnum, error->errmess);
msg_data.error = error->errmess;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
error = (os_error*)_swix(AWRender_DocBounds,
_IN(0) | _OUT(2) | _OUT(3) | _OUT(4) | _OUT(5),
source_data,
&aw->x0,
&aw->y0,
&aw->x1,
&aw->y1);
if (error) {
LOG("AWRender_DocBounds: 0x%x: %s", error->errnum, error->errmess);
msg_data.error = error->errmess;
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
LOG("bounding box: %d,%d,%d,%d", aw->x0, aw->y0, aw->x1, aw->y1);
/* create the resizable workspace required by the
ArtWorksRenderer rendering routine */
aw->size = INITIAL_BLOCK_SIZE;
aw->block = malloc(INITIAL_BLOCK_SIZE);
if (!aw->block) {
LOG("failed to create block for ArtworksRenderer");
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
c->width = (aw->x1 - aw->x0) / 512;
c->height = (aw->y1 - aw->y0) / 512;
title = messages_get_buff("ArtWorksTitle",
nsurl_access_leaf(llcache_handle_get_url(c->llcache)),
c->width, c->height);
if (title != NULL) {
content__set_title(c, title);
free(title);
}
content_set_ready(c);
content_set_done(c);
/* Done: update status bar */
content_set_status(c, "");
return true;
}
_kernel_oserror *SWI_DDEUtils_Prefix(const char *dir)
{ /* sets the 'prefix' directory */
return _swix(DDEUtils_Prefix,_IN(0),dir);
}
int SWI_OS_ReadC(void)
{ /* get a key from the keyboard buffer */
int key;
_swix(OS_ReadC,_OUT(0),&key);
return key;
}
_kernel_oserror *SWI_OS_CLI(const char *cmd)
{ /* execute a command */
return _swix(OS_CLI,_IN(0),cmd);
}
_kernel_oserror *SWI_OS_File_7(const char *filename, int loadaddr,
int execaddr, int size)
{ /* create an empty file */
return _swix(OS_File,_INR(0,5),7,filename,loadaddr,execaddr,0,size);
}
_kernel_oserror *SWI_OS_File_6(const char *filename)
{ /* delete */
return _swix(OS_File,_INR(0,1),6,filename);
}
