*/ REBSER *Gob_To_Block(REBGOB *gob)
/*
** Used by MOLD to create a block.
**
***********************************************************************/
{
REBSER *ser = Make_Block(10);
REBVAL *val;
REBINT words[6] = {SYM_OFFSET, SYM_SIZE, SYM_ALPHA, 0};
REBVAL *vals[6];
REBINT n = 0;
REBVAL *val1;
REBCNT sym;
for (n = 0; words[n]; n++) {
val = Append_Value(ser);
Init_Word(val, words[n]);
VAL_SET(val, REB_SET_WORD);
vals[n] = Append_Value(ser);
}
SET_PAIR(vals[0], GOB_X(gob), GOB_Y(gob));
SET_PAIR(vals[1], GOB_W(gob), GOB_H(gob));
SET_INTEGER(vals[2], GOB_ALPHA(gob));
if (!GOB_TYPE(gob)) return ser;
if (GOB_CONTENT(gob)) {
val1 = Append_Value(ser);
val = Append_Value(ser);
switch (GOB_TYPE(gob)) {
case GOBT_COLOR:
sym = SYM_COLOR;
break;
case GOBT_IMAGE:
sym = SYM_IMAGE;
break;
case GOBT_STRING:
case GOBT_TEXT:
sym = SYM_TEXT;
break;
case GOBT_DRAW:
sym = SYM_DRAW;
break;
case GOBT_EFFECT:
sym = SYM_EFFECT;
break;
}
Init_Word(val1, sym);
VAL_SET(val1, REB_SET_WORD);
Get_GOB_Var(gob, val1, val);
}
return ser;
}
extern "C" void rt_size_text(void* rt, REBGOB* gob, REBXYF* size)
{
REBINT result = 0;
((rich_text*)rt)->rt_reset();
((rich_text*)rt)->rt_set_clip(0,0, GOB_W(gob),GOB_H(gob));
if (GOB_TYPE(gob) == GOBT_TEXT){
result = Text_Gob(rt, (REBSER *)GOB_CONTENT(gob));
} else if (GOB_TYPE(gob) == GOBT_STRING) {
((rich_text*)rt)->rt_set_text((REBCHR*)GOB_STRING(gob), TRUE);
((rich_text*)rt)->rt_push(1);
} else {
size->x = 0;
size->y = 0;
return;
}
if (result < 0) return;
((rich_text*)rt)->rt_size_text(size);
}
extern "C" REBINT rt_caret_to_offset(void* rt, REBGOB *gob, REBXYF* xy, REBINT element, REBINT position)
{
REBINT result = 0;
((rich_text*)rt)->rt_reset();
((rich_text*)rt)->rt_set_clip(0,0, GOB_W(gob),GOB_H(gob));
if (GOB_TYPE(gob) == GOBT_TEXT){
result = Text_Gob(rt, (REBSER *)GOB_CONTENT(gob));
} else if (GOB_TYPE(gob) == GOBT_STRING) {
((rich_text*)rt)->rt_set_text((REBCHR*)GOB_STRING(gob), TRUE);
((rich_text*)rt)->rt_push(1);
} else {
xy->x = 0;
xy->y = 0;
return result;
}
if (result < 0) return result;
((rich_text*)rt)->rt_caret_to_offset(xy, element, position);
return result;
}
*/ static REBFLG Get_GOB_Var(REBGOB *gob, REBVAL *word, REBVAL *val)
/*
***********************************************************************/
{
switch (VAL_WORD_CANON(word)) {
case SYM_OFFSET:
SET_PAIR(val, GOB_X(gob), GOB_Y(gob));
break;
case SYM_SIZE:
SET_PAIR(val, GOB_W(gob), GOB_H(gob));
break;
case SYM_IMAGE:
if (GOB_TYPE(gob) == GOBT_IMAGE) {
// image
}
else goto is_none;
break;
case SYM_DRAW:
if (GOB_TYPE(gob) == GOBT_DRAW) {
Set_Block(val, GOB_CONTENT(gob)); // Note: compiler optimizes SET_BLOCKs below
}
else goto is_none;
break;
case SYM_TEXT:
if (GOB_TYPE(gob) == GOBT_TEXT) {
Set_Block(val, GOB_CONTENT(gob));
}
else if (GOB_TYPE(gob) == GOBT_STRING) {
Set_String(val, GOB_CONTENT(gob));
}
else goto is_none;
break;
case SYM_EFFECT:
if (GOB_TYPE(gob) == GOBT_EFFECT) {
Set_Block(val, GOB_CONTENT(gob));
}
else goto is_none;
break;
case SYM_COLOR:
if (GOB_TYPE(gob) == GOBT_COLOR) {
Set_Tuple_Pixel((REBYTE*)&GOB_CONTENT(gob), val);
}
else goto is_none;
break;
case SYM_ALPHA:
SET_INTEGER(val, GOB_ALPHA(gob));
break;
case SYM_PANE:
if (GOB_PANE(gob))
Set_Block(val, Pane_To_Block(gob, 0, -1));
else
Set_Block(val, Make_Block(0));
break;
case SYM_PARENT:
if (GOB_PARENT(gob)) {
SET_GOB(val, GOB_PARENT(gob));
}
else
is_none:
SET_NONE(val);
break;
case SYM_DATA:
if (GOB_DTYPE(gob) == GOBD_OBJECT) {
SET_OBJECT(val, GOB_DATA(gob));
}
else if (GOB_DTYPE(gob) == GOBD_BLOCK) {
Set_Block(val, GOB_DATA(gob));
}
else if (GOB_DTYPE(gob) == GOBD_STRING) {
Set_String(val, GOB_DATA(gob));
}
else if (GOB_DTYPE(gob) == GOBD_BINARY) {
SET_BINARY(val, GOB_DATA(gob));
}
else if (GOB_DTYPE(gob) == GOBD_INTEGER) {
SET_INTEGER(val, (REBIPT)GOB_DATA(gob));
}
else goto is_none;
break;
case SYM_FLAGS:
Set_Block(val, Flags_To_Block(gob));
break;
default:
return FALSE;
}
return TRUE;
}
*/ static void process_gobs(REBCMP_CTX* ctx, REBGOB* gob)
/*
** Recursively process and compose gob and its children.
**
** NOTE: this function is used internally by rebcmp_compose() call only.
**
***********************************************************************/
{
//RL_Print("process_gobs: %x\n", gob);
REBINT x = ROUND_TO_INT(ctx->absOffset.x);
REBINT y = ROUND_TO_INT(ctx->absOffset.y);
REBYTE* color;
Region saved_win_region = XCreateRegion();
if (GET_GOB_STATE(gob, GOBS_NEW)){
//reset old-offset and old-size if newly added
GOB_XO(gob) = GOB_LOG_X(gob);
GOB_YO(gob) = GOB_LOG_Y(gob);
GOB_WO(gob) = GOB_LOG_W(gob);
GOB_HO(gob) = GOB_LOG_H(gob);
CLR_GOB_STATE(gob, GOBS_NEW);
}
//intersect gob dimensions with actual window clip region
REBOOL valid_intersection = 1;
//------------------------------
//Put backend specific code here
//------------------------------
XRectangle rect;
rect.x = x;
rect.y = y;
rect.width = GOB_LOG_W(gob);
rect.height = GOB_LOG_H(gob);
/*
RL_Print("gob , left: %d,\ttop: %d,\tright: %d,\tbottom: %d\n",
rect.x,
rect.y,
rect.x + rect.width,
rect.y + rect.height);
*/
Region reg = XCreateRegion();
XUnionRectWithRegion(&rect, reg, reg);
/*
XClipBox(ctx->Win_Region, &rect);
RL_Print("Win Region , left: %d,\ttop: %d,\tright: %d,\tbottom: %d\n",
rect.x,
rect.y,
rect.x + rect.width,
rect.y + rect.height);
*/
XUnionRegion(saved_win_region, ctx->Win_Region, saved_win_region);
XIntersectRegion(reg, ctx->Win_Region, ctx->Win_Region);
XClipBox(ctx->Win_Region, &rect);
/*
RL_Print("Win and Gob, left: %d,\ttop: %d,\tright: %d,\tbottom: %d\n",
rect.x,
rect.y,
rect.x + rect.width,
rect.y + rect.height);
*/
//get the current Window clip box
REBRECT gob_clip = {
rect.x, //left
rect.y, //top
rect.width + rect.x, //right
rect.height + rect.y //bottom
/*
GOB_LOG_X(gob), //left
GOB_LOG_Y(gob), //top
GOB_LOG_W(gob) + GOB_LOG_X(gob), //right
GOB_LOG_H(gob) + GOB_LOG_Y(gob), //bottom
*/
};
//RL_Print("Window_Buffer: 0x%x\n", ctx->Window_Buffer);
/*
RL_Print("gob clip , left: %d,\ttop: %d,\tright: %d,\tbottom: %d\n",
gob_clip.left,
gob_clip.top,
gob_clip.right,
gob_clip.bottom);
*/
if (!XEmptyRegion(ctx->Win_Region))
//if (valid_intersection)
{
//render GOB content
switch (GOB_TYPE(gob)) {
case GOBT_COLOR:
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
//RL_Print("Draw Color at: %d, %d\n", x, y);
rebdrw_gob_color(gob, ctx->Window_Buffer, ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
break;
case GOBT_IMAGE:
{
//RL_Print("Draw Image\n");
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
rebdrw_gob_image(gob, ctx->Window_Buffer, ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
}
break;
case GOBT_DRAW:
{
//RL_Print("Draw Draw at: %d, %d\n", x, y);
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
rebdrw_gob_draw(gob, ctx->Window_Buffer ,ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
}
break;
case GOBT_TEXT:
case GOBT_STRING:
//RL_Print("Draw Text at: %d, %d\n", x, y);
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
rt_gob_text(gob, ctx->Window_Buffer ,ctx->winBufSize,ctx->absOffset, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
break;
case GOBT_EFFECT:
//RL_Print("Draw Effect\n");
//not yet implemented
break;
}
//recursively process sub GOBs
if (GOB_PANE(gob)) {
REBINT n;
REBINT len = GOB_TAIL(gob);
REBGOB **gp = GOB_HEAD(gob);
for (n = 0; n < len; n++, gp++) {
REBINT g_x = GOB_LOG_X(*gp);
REBINT g_y = GOB_LOG_Y(*gp);
//restore the "parent gob" clip region
//------------------------------
//Put backend specific code here
//------------------------------
ctx->absOffset.x += g_x;
ctx->absOffset.y += g_y;
process_gobs(ctx, *gp);
ctx->absOffset.x -= g_x;
ctx->absOffset.y -= g_y;
}
}
}
XDestroyRegion(reg);
XDestroyRegion(ctx->Win_Region);
ctx->Win_Region = saved_win_region;
}
*/ REBSER *Gob_To_Block(REBGOB *gob)
/*
** Used by MOLD to create a block.
**
***********************************************************************/
{
REBSER *ser = Make_Block(10);
REBVAL *val;
REBVAL *val1;
REBCNT sym;
val = Append_Value(ser);
Init_Word(val, SYM_OFFSET);
VAL_SET(val, REB_SET_WORD);
val = Append_Value(ser);
SET_PAIR(val, GOB_X(gob), GOB_Y(gob));
val = Append_Value(ser);
Init_Word(val, SYM_SIZE);
VAL_SET(val, REB_SET_WORD);
val = Append_Value(ser);
SET_PAIR(val, GOB_W(gob), GOB_H(gob));
if (!GET_GOB_FLAG(gob, GOBF_OPAQUE) && GOB_ALPHA(gob) < 255) {
val = Append_Value(ser);
Init_Word(val, SYM_ALPHA);
VAL_SET(val, REB_SET_WORD);
val = Append_Value(ser);
SET_INTEGER(val, 255 - GOB_ALPHA(gob));
}
if (!GOB_TYPE(gob)) return ser;
if (GOB_CONTENT(gob)) {
val1 = Append_Value(ser);
val = Append_Value(ser);
switch (GOB_TYPE(gob)) {
case GOBT_COLOR:
sym = SYM_COLOR;
break;
case GOBT_IMAGE:
sym = SYM_IMAGE;
break;
#ifdef HAS_WIDGET_GOB
case GOBT_WIDGET:
sym = SYM_WIDGET;
break;
#endif
case GOBT_STRING:
case GOBT_TEXT:
sym = SYM_TEXT;
break;
case GOBT_DRAW:
sym = SYM_DRAW;
break;
case GOBT_EFFECT:
sym = SYM_EFFECT;
break;
}
Init_Word(val1, sym);
VAL_SET(val1, REB_SET_WORD);
Get_GOB_Var(gob, val1, val);
}
return ser;
}
*/ static REBFLG Get_GOB_Var(REBGOB *gob, REBVAL *word, REBVAL *val)
/*
***********************************************************************/
{
REBSER *data;
switch (VAL_WORD_CANON(word)) {
case SYM_OFFSET:
SET_PAIR(val, GOB_X(gob), GOB_Y(gob));
break;
case SYM_SIZE:
SET_PAIR(val, GOB_W(gob), GOB_H(gob));
break;
case SYM_IMAGE:
if (GOB_TYPE(gob) == GOBT_IMAGE) {
// image
}
else goto is_none;
break;
#ifdef HAS_WIDGET_GOB
case SYM_WIDGET:
data = VAL_SERIES(GOB_WIDGET_SPEC(gob));
Init_Word(val, VAL_WORD_CANON(BLK_HEAD(data)));
VAL_SET(val, REB_LIT_WORD);
break;
#endif
case SYM_DRAW:
if (GOB_TYPE(gob) == GOBT_DRAW) {
Set_Block(val, GOB_CONTENT(gob)); // Note: compiler optimizes SET_BLOCKs below
}
else goto is_none;
break;
case SYM_TEXT:
if (GOB_TYPE(gob) == GOBT_TEXT) {
Set_Block(val, GOB_CONTENT(gob));
}
else if (GOB_TYPE(gob) == GOBT_STRING) {
Set_String(val, GOB_CONTENT(gob));
}
else goto is_none;
break;
case SYM_EFFECT:
if (GOB_TYPE(gob) == GOBT_EFFECT) {
Set_Block(val, GOB_CONTENT(gob));
}
else goto is_none;
break;
case SYM_COLOR:
if (GOB_TYPE(gob) == GOBT_COLOR) {
Set_Tuple_Pixel((REBYTE*)&GOB_CONTENT(gob), val);
}
else goto is_none;
break;
case SYM_ALPHA:
SET_INTEGER(val, GOB_ALPHA(gob));
break;
case SYM_PANE:
if (GOB_PANE(gob))
Set_Block(val, Pane_To_Block(gob, 0, -1));
else
Set_Block(val, Make_Block(0));
break;
case SYM_PARENT:
if (GOB_PARENT(gob)) {
SET_GOB(val, GOB_PARENT(gob));
}
else
is_none:
SET_NONE(val);
break;
case SYM_DATA:
#ifdef HAS_WIDGET_GOB
if (GOB_TYPE(gob) == GOBT_WIDGET) {
return OS_GET_WIDGET_DATA(gob, val);
}
#endif
data = GOB_DATA(gob);
if (GOB_DTYPE(gob) == GOBD_OBJECT) {
SET_OBJECT(val, data);
}
else if (GOB_DTYPE(gob) == GOBD_BLOCK) {
Set_Block(val, data);
}
else if (GOB_DTYPE(gob) == GOBD_STRING) {
Set_String(val, data);
}
else if (GOB_DTYPE(gob) == GOBD_BINARY) {
SET_BINARY(val, data);
}
else if (GOB_DTYPE(gob) == GOBD_INTEGER) {
SET_INTEGER(val, (REBIPT)data);
}
else goto is_none;
break;
case SYM_FLAGS:
Set_Block(val, Flags_To_Block(gob));
break;
default:
return FALSE;
}
return TRUE;
}
*/ static REBFLG Set_GOB_Var(REBGOB *gob, REBVAL *word, REBVAL *val)
/*
***********************************************************************/
{
REBVAL *spec;
REBVAL *hndl;
switch (VAL_WORD_CANON(word)) {
case SYM_OFFSET:
return Set_Pair(&(gob->offset), val);
case SYM_SIZE:
return Set_Pair(&gob->size, val);
case SYM_IMAGE:
CLR_GOB_OPAQUE(gob);
if (IS_IMAGE(val)) {
SET_GOB_TYPE(gob, GOBT_IMAGE);
GOB_W(gob) = (REBD32)VAL_IMAGE_WIDE(val);
GOB_H(gob) = (REBD32)VAL_IMAGE_HIGH(val);
GOB_CONTENT(gob) = VAL_SERIES(val);
// if (!VAL_IMAGE_TRANSP(val)) SET_GOB_OPAQUE(gob);
}
else if (IS_NONE(val)) SET_GOB_TYPE(gob, GOBT_NONE);
else return FALSE;
break;
#ifdef HAS_WIDGET_GOB
case SYM_WIDGET:
//printf("WIDGET GOB\n");
SET_GOB_TYPE(gob, GOBT_WIDGET);
SET_GOB_OPAQUE(gob);
GOB_CONTENT(gob) = Make_Block(4); // [handle type spec data]
hndl = Append_Value(GOB_CONTENT(gob));
Append_Value(GOB_CONTENT(gob)); // used to cache type on host's side
spec = Append_Value(GOB_CONTENT(gob));
Append_Value(GOB_CONTENT(gob)); // used to cache result data
SET_HANDLE(hndl, 0, SYM_WIDGET, 0);
if (IS_WORD(val) || IS_LIT_WORD(val)) {
Set_Block(spec, Make_Block(1));
Append_Val(VAL_SERIES(spec), val);
}
else if (IS_BLOCK(val)) {
Set_Block(spec, VAL_SERIES(val));
}
else return FALSE;
break;
#endif // HAS_WIDGET_GOB
case SYM_DRAW:
CLR_GOB_OPAQUE(gob);
if (IS_BLOCK(val)) {
SET_GOB_TYPE(gob, GOBT_DRAW);
GOB_CONTENT(gob) = VAL_SERIES(val);
}
else if (IS_NONE(val)) SET_GOB_TYPE(gob, GOBT_NONE);
else return FALSE;
break;
case SYM_TEXT:
CLR_GOB_OPAQUE(gob);
if (IS_BLOCK(val)) {
SET_GOB_TYPE(gob, GOBT_TEXT);
GOB_CONTENT(gob) = VAL_SERIES(val);
}
else if (IS_STRING(val)) {
SET_GOB_TYPE(gob, GOBT_STRING);
GOB_CONTENT(gob) = VAL_SERIES(val);
}
else if (IS_NONE(val)) SET_GOB_TYPE(gob, GOBT_NONE);
else return FALSE;
break;
case SYM_EFFECT:
CLR_GOB_OPAQUE(gob);
if (IS_BLOCK(val)) {
SET_GOB_TYPE(gob, GOBT_EFFECT);
GOB_CONTENT(gob) = VAL_SERIES(val);
}
else if (IS_NONE(val)) SET_GOB_TYPE(gob, GOBT_NONE);
else return FALSE;
break;
case SYM_COLOR:
CLR_GOB_OPAQUE(gob);
if (IS_TUPLE(val)) {
SET_GOB_TYPE(gob, GOBT_COLOR);
Set_Pixel_Tuple((REBYTE*)&GOB_CONTENT(gob), val);
if (VAL_TUPLE_LEN(val) < 4 || VAL_TUPLE(val)[3] == 255)
SET_GOB_OPAQUE(gob);
}
else if (IS_NONE(val)) SET_GOB_TYPE(gob, GOBT_NONE);
break;
case SYM_PANE:
if (GOB_PANE(gob)) Clear_Series(GOB_PANE(gob));
if (IS_BLOCK(val))
Insert_Gobs(gob, VAL_BLK_DATA(val), 0, VAL_BLK_LEN(val), 0);
else if (IS_GOB(val))
Insert_Gobs(gob, val, 0, 1, 0);
else if (IS_NONE(val))
gob->pane = 0;
else
return FALSE;
break;
case SYM_ALPHA:
GOB_ALPHA(gob) = Clip_Int(Int32(val), 0, 255);
break;
case SYM_DATA:
#ifdef HAS_WIDGET_GOB
if (GOB_TYPE(gob) == GOBT_WIDGET) {
OS_SET_WIDGET_DATA(gob, val);
} else {
#endif
SET_GOB_DTYPE(gob, GOBD_NONE);
if (IS_OBJECT(val)) {
SET_GOB_DTYPE(gob, GOBD_OBJECT);
SET_GOB_DATA(gob, VAL_OBJ_FRAME(val));
}
else if (IS_BLOCK(val)) {
SET_GOB_DTYPE(gob, GOBD_BLOCK);
SET_GOB_DATA(gob, VAL_SERIES(val));
}
else if (IS_STRING(val)) {
SET_GOB_DTYPE(gob, GOBD_STRING);
SET_GOB_DATA(gob, VAL_SERIES(val));
}
else if (IS_BINARY(val)) {
SET_GOB_DTYPE(gob, GOBD_BINARY);
SET_GOB_DATA(gob, VAL_SERIES(val));
}
else if (IS_INTEGER(val)) {
SET_GOB_DTYPE(gob, GOBD_INTEGER);
SET_GOB_DATA(gob, (void*)(REBIPT)VAL_INT64(val));
}
else if (IS_NONE(val))
SET_GOB_TYPE(gob, GOBT_NONE);
else return FALSE;
#ifdef HAS_WIDGET_GOB
}
#endif
break;
case SYM_FLAGS:
if (IS_WORD(val)) Set_Gob_Flag(gob, val);
else if (IS_BLOCK(val)) {
gob->flags = 0;
for (val = VAL_BLK(val); NOT_END(val); val++) {
if (IS_WORD(val)) Set_Gob_Flag(gob, val);
}
}
break;
case SYM_OWNER:
if (IS_GOB(val))
GOB_TMP_OWNER(gob) = VAL_GOB(val);
else
return FALSE;
break;
default:
return FALSE;
}
return TRUE;
}
*/ static void process_gobs(REBCMP_CTX* ctx, REBGOB* gob)
/*
** Recursively process and compose gob and its children.
**
** NOTE: this function is used internally by rebcmp_compose() call only.
**
***********************************************************************/
{
REBINT x = ROUND_TO_INT(ctx->absOffset.x);
REBINT y = ROUND_TO_INT(ctx->absOffset.y);
if (GET_GOB_STATE(gob, GOBS_NEW)){
//reset old-offset and old-size if newly added
GOB_XO(gob) = GOB_LOG_X(gob);
GOB_YO(gob) = GOB_LOG_Y(gob);
GOB_WO(gob) = GOB_LOG_W(gob);
GOB_HO(gob) = GOB_LOG_H(gob);
CLR_GOB_STATE(gob, GOBS_NEW);
}
//intersect gob dimensions with actual window clip region
REBOOL valid_intersection;
//------------------------------
//Put backend specific code here
//------------------------------
//get the current Window clip box
REBRECT gob_clip;
//------------------------------
//Put backend specific code here
//------------------------------
if (valid_intersection)
{
//render GOB content
switch (GOB_TYPE(gob)) {
case GOBT_COLOR:
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
// rebdrw_gob_color(gob, ctx->Window_Buffer, ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
break;
case GOBT_IMAGE:
{
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
// rebdrw_gob_image(gob, ctx->Window_Buffer, ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
}
break;
case GOBT_DRAW:
{
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
// rebdrw_gob_draw(gob, ctx->Window_Buffer ,ctx->winBufSize, (REBXYI){x,y}, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
}
break;
case GOBT_TEXT:
case GOBT_STRING:
//------------------------------
//Put backend specific code here
//------------------------------
// or use the similar draw api call:
// rt_gob_text(gob, ctx->Window_Buffer ,ctx->winBufSize,ctx->absOffset, (REBXYI){gob_clip.left, gob_clip.top}, (REBXYI){gob_clip.right, gob_clip.bottom});
break;
case GOBT_EFFECT:
//not yet implemented
break;
}
//recursively process sub GOBs
if (GOB_PANE(gob)) {
REBINT n;
REBINT len = GOB_TAIL(gob);
REBGOB **gp = GOB_HEAD(gob);
for (n = 0; n < len; n++, gp++) {
REBINT g_x = GOB_LOG_X(*gp);
REBINT g_y = GOB_LOG_Y(*gp);
//restore the "parent gob" clip region
//------------------------------
//Put backend specific code here
//------------------------------
ctx->absOffset.x += g_x;
ctx->absOffset.y += g_y;
process_gobs(ctx, *gp);
ctx->absOffset.x -= g_x;
ctx->absOffset.y -= g_y;
}
}
}
}
