int check_ui_object_clipped (ui_object *obj)
{
int
flag;
ui_object
*parent;
float
x1,
x2,
y1,
y2,
x_min,
y_min,
x_max,
y_max,
old_vp_x1,
old_vp_y1,
old_vp_x2,
old_vp_y2;
old_vp_x1 = active_viewport.x_min;
old_vp_y1 = active_viewport.y_min;
old_vp_x2 = active_viewport.x_max;
old_vp_y2 = active_viewport.y_max;
parent = get_ui_object_parent (obj);
ASSERT (parent);
x1 = get_ui_object_x (parent);
y1 = get_ui_object_y (parent);
x2 = x1 + get_ui_object_x_size (parent);
y2 = y1 + get_ui_object_y_size (parent);
x_min = get_ui_object_x (obj);
y_min = get_ui_object_y (obj);
x_max = x_min + get_ui_object_x_size (obj);
y_max = y_min + get_ui_object_y_size (obj);
set_viewport (x1, y1, x2, y2);
flag = ui_clip_area (&x_min, &y_min, &x_max, &y_max);
set_viewport (old_vp_x1, old_vp_y1, old_vp_x2, old_vp_y2);
return flag;
}
static float get_area_ui_object_virtual_x (ui_object *obj)
{
area_ui_object
*area;
float
px = 0;
ui_object
*parent;
if (get_ui_object_virtual_coords (obj))
{
// is this right ? check
parent = get_ui_object_parent (obj);
if (parent)
{
//px = get_ui_object_virtual_x (parent);
}
area = (area_ui_object *) obj->data;
return area->x_start + px;
}
else
{
float
x;
ui_object
*parent;
parent = get_ui_object_parent (obj);
if (parent)
{
x = (get_ui_object_x (obj) - get_ui_object_x (parent)) / get_ui_object_x_size (parent);
}
else
{
x = get_ui_object_x (obj) / get_screen_width (video_screen);
}
return x;
}
}
static float get_area_ui_object_x (ui_object *obj)
{
area_ui_object
*area;
float
x,
px = 0;
ui_object
*parent;
parent = get_ui_object_parent (obj);
if (parent)
{
px = get_ui_object_x (parent);
}
area = (area_ui_object *) obj->data;
x = area->x_start + ( get_ui_object_bounded_t_value (obj) * ( area->x_end - area->x_start ) );
if (area->virtual_coords)
{
if (parent)
{
x *= get_ui_object_x_size (parent);
}
else
{
x *= get_screen_width (video_screen);
}
}
return x + px;
}
static void draw_weapon_loading_gauge (ui_object *obj, float level)
{
real_colour
colour;
float
sx1, sx2,
sy1, sy2,
xmin, xmax,
ymin, ymax;
ASSERT (obj);
xmin = get_ui_object_x (obj);
ymin = get_ui_object_y (obj);
xmax = xmin + get_ui_object_x_size (obj);
ymax = ymin + get_ui_object_y_size (obj);
//
// Always have to render to the video screen
//
ASSERT ( active_screen == video_screen );
colour.red = 255;
colour.green = 255;
colour.blue = 255;
colour.alpha = 255;
sx1 = xmin;
sx2 = xmax;
sy1 = ymin;
sy2 = ymax;
sx2 = (xmin + (level * (xmax - xmin)));
ui_draw_texture_graphic (sx1, sy1, sx2, sy2, bar_graphic, colour);
}
static void update_vslider_ui_object (ui_object *obj)
{
float
parent_x1,
parent_y1,
parent_x2,
parent_y2,
parent_x_origin,
parent_y_origin;
float
x1,
y1,
x2,
y2;
ui_object
*parent;
area_ui_object
*area;
float
old_viewport_x1,
old_viewport_y1,
old_viewport_x2,
old_viewport_y2;
// store parents viewport data
old_viewport_x1 = active_viewport.x_min;
old_viewport_y1 = active_viewport.y_min;
old_viewport_x2 = active_viewport.x_max;
old_viewport_y2 = active_viewport.y_max;
area = (area_ui_object *) obj->data;
// store parents viewport data
parent = get_ui_object_parent (obj);
parent_x_origin = get_ui_object_x_origin (parent);
parent_y_origin = get_ui_object_y_origin (parent);
parent_x1 = get_ui_object_x (parent);
parent_y1 = get_ui_object_y (parent);
parent_x2 = parent_x1 + get_ui_object_x_size (parent);
parent_y2 = parent_y1 + get_ui_object_y_size (parent);
recalculate_slider_size (obj);
if (area->drawable)
{
ui_set_origin (0, 0);
draw_ui_object (obj);
if (area->child)
{
x1 = get_ui_object_x (obj);
y1 = get_ui_object_y (obj);
x2 = x1 + get_ui_object_x_size (obj);
y2 = y1 + get_ui_object_y_size (obj);
ui_clip_area (&x1, &y1, &x2, &y2);
set_viewport (x1, y1, x2, y2);
ui_set_origin (0, 0);
update_ui_object (area->child);
}
}
set_viewport (old_viewport_x1, old_viewport_y1, old_viewport_x2, old_viewport_y2);
if (area->next)
{
parent = get_ui_object_parent (obj);
if (parent)
{
set_viewport (parent_x1, parent_y1, parent_x2, parent_y2);
ui_set_origin (parent_x_origin, parent_y_origin);
}
update_ui_object (area->next);
}
}
static void set_text_ui_object_text (ui_object *obj, char *text)
{
font_types
old_font;
int
length;
float
pixel_length;
area_ui_object
*area;
ui_object
*parent;
area = obj->data;
if (area->text)
{
safe_free (area->text);
}
area->text = NULL;
old_font = get_ui_font_type ();
if (area->font_type != -1)
{
set_ui_font_type (area->font_type);
}
parent = get_ui_object_parent (obj);
if (text)
{
length = strlen (text);
pixel_length = ui_get_string_length (text);
area->x_size_start = pixel_length + 5;
area->y_size_start = ui_get_font_height () + LIST_ITEM_SPACING;
if ((area->virtual_coords) && (parent))
{
area->x_size_start /= get_ui_object_x_size (parent);
area->y_size_start /= get_ui_object_y_size (parent);
}
area->text = (char *) safe_malloc ((sizeof (char) * length) + 1);
strcpy (area->text, text);
}
if (parent)
{
set_ui_object_redraw (parent, TRUE);
while ((parent) && (get_ui_object_clear (parent)))
{
parent = get_ui_object_parent (parent);
if (parent)
{
set_ui_object_redraw (parent, TRUE);
}
}
}
else
{
set_ui_object_redraw (obj, TRUE);
}
set_ui_font_type (old_font);
}
static void create_close_ui_object (ui_object *obj, ui_object_types type, va_list pargs)
{
float
px_size,
py_size;
close_ui_object
*new_close;
increase_ui_object_counter ();
////////////////////////////////////////
//
// MALLOC ENTITY DATA
//
////////////////////////////////////////
obj->type = type;
new_close = safe_malloc (sizeof (close_ui_object));
obj->data = new_close;
////////////////////////////////////////
//
// INITIALISE ALL ENTITY DATA TO 'WORKING' DEFAULT VALUES
//
// DO NOT USE ACCESS FUNCTIONS
//
// DO NOT USE RANDOM VALUES
//
////////////////////////////////////////
memset (new_close, 0, sizeof (close_ui_object));
//new_close->area.x = 0.0;
//new_close->area.y = 0.0;
//new_close->area.x_size = 20.0;
//new_close->area.y_size = 20.0;
new_close->area.x_origin = 0.0;
new_close->area.y_origin = 0.0;
new_close->area.drawable = 1;
new_close->area.redraw = 1;
new_close->area.item_number = -1;
new_close->area.moveable = 0;
new_close->area.resizeable = 0;
new_close->area.notify_on = NOTIFY_TYPE_BUTTON_UP;
new_close->area.parent = NULL;
new_close->area.child = NULL;
new_close->area.next = NULL;
new_close->area.prev = NULL;
new_close->area.state = 0;
////////////////////////////////////////
//
// OVERWRITE DEFAULTS WITH GIVEN ATTRIBUTES
//
////////////////////////////////////////
set_ui_object_attributes (obj, pargs);
if (!new_close->area.parent)
{
debug_fatal ("ERROR: Close_box MUST have a parent");
}
// set close box position relative to parent
px_size = get_ui_object_x_size (new_close->area.parent);
py_size = get_ui_object_y_size (new_close->area.parent);
new_close->area.x_start = px_size - new_close->area.x_size_start - 1;
new_close->area.y_start = 1;
////////////////////////////////////////
//
// INTEGRATE INTO SYSTEM
//
////////////////////////////////////////
}
ui_object *add_to_pop_up_list_with_word_wrap (char *text, ui_object *obj, ui_object *next_item, int list_id, int font_type, rgb_colour font_colour)
{
font_types
old_font,
font;
ui_object
*item;
char
temp_text [256],
word [128],
*word_ptr,
*text_ptr;
int
new_line_flag,
max_string_length;
old_font = get_ui_font_type ();
font = get_ui_object_font_type (obj);
set_ui_font_type (font);
memset (temp_text, 0, sizeof (temp_text));
memset (word, 0, sizeof (word));
max_string_length = get_ui_object_x_size (obj);
text_ptr = text;
while ((*text_ptr != '\0'))
{
new_line_flag = FALSE;
// get next word
word_ptr = word;
while (*text_ptr != '\0')
{
*word_ptr = *text_ptr;
text_ptr ++;
if (*word_ptr == ' ')
{
break;
}
word_ptr ++;
if (*text_ptr == '\n')
{
text_ptr ++;
new_line_flag = TRUE;
break;
}
}
// check word isn't longer than allowed space (causes an error if so...)
debug_assert (ui_get_string_length (word) < max_string_length);
// check that current string + word fits on line
if ((ui_get_string_length (temp_text) + ui_get_string_length (word)) > max_string_length)
{
// if not display string
add_to_pop_up_list (temp_text, obj, NULL, 0, -1, font_colour);
// clear string
memset (temp_text, 0, sizeof (temp_text));
}
// add word to string
strcat (temp_text, word);
memset (word, 0, sizeof (word));
if (new_line_flag)
{
// if not display string
add_to_pop_up_list (temp_text, obj, NULL, 0, -1, font_colour);
// clear string
memset (temp_text, 0, sizeof (temp_text));
}
}
if (strlen (temp_text) > 0)
{
item = add_to_pop_up_list (temp_text, obj, NULL, 0, -1, font_colour);
}
set_ui_font_type (old_font);
return item;
}
ui_object *add_to_pop_up_list (char *text, ui_object *obj, ui_object *next_item, int list_id, int font_type, rgb_colour font_colour)
{
notify_types
notify_on,
highlighted_notify_on;
ui_object
*text_obj;
int
highlighted_font_type;
float
x_pos,
list_x_size,
list_y_size,
new_position;
rgb_colour
highlighted_font_colour;
//
ASSERT (obj);
//
/*
if (!obj)
{
return NULL;
}
*/
//
//
//
list_x_size = 1.0; //get_ui_object_x_size (obj) - 5;
list_y_size = ui_get_font_height () / get_ui_object_y_size (obj);
new_position = get_next_list_virtual_position (obj);
//
// If invalid font type specified, use the list box font type
//
if ((font_type < 0) || (font_type >= NUM_FONT_TYPES))
{
font_type = get_ui_object_font_type (obj);
}
highlighted_font_type = get_ui_object_highlighted_font_type (obj);
//
// If invalid font colour specified, use the list box font colour
//
notify_on = get_ui_object_notify_on (obj);
highlighted_notify_on = get_ui_object_highlighted_notify_on (obj);
highlighted_font_colour = get_ui_object_highlighted_font_colour (obj);
x_pos = 5.0 / get_ui_object_x_size (obj);
text_obj = create_ui_object
(
UI_TYPE_TEXT,
UI_ATTR_NEXT (next_item),
UI_ATTR_PARENT (obj),
UI_ATTR_LIST_ITEM,
UI_ATTR_VIRTUAL_SIZE (list_x_size, list_y_size),
UI_ATTR_VIRTUAL_POSITION (x_pos, new_position),
UI_ATTR_FONT_TYPE (font_type),
UI_ATTR_FONT_COLOUR (font_colour.r, font_colour.g, font_colour.b, font_colour.a),
UI_ATTR_HIGHLIGHTED_FONT_TYPE (highlighted_font_type),
UI_ATTR_HIGHLIGHTED_FONT_COLOUR (highlighted_font_colour.r, highlighted_font_colour.g, highlighted_font_colour.b, highlighted_font_colour.a),
UI_ATTR_TEXT (text),
UI_ATTR_ITEM_NUMBER (list_id),
UI_ATTR_ITEM_NUMBER2 (UI_LIST_NO_SELECTION),
UI_ATTR_FUNCTION (ui_object_list_item_function),
UI_ATTR_RIGHT_FUNCTION (ui_object_list_item_right_function),
UI_ATTR_NOTIFY_ON (notify_on),
UI_ATTR_HIGHLIGHTED_NOTIFY_ON (highlighted_notify_on),
UI_ATTR_END
);
//
// Set list box to redraw, and parents if its clear.
//
set_ui_object_redraw (obj, TRUE);
while ((obj) && (get_ui_object_clear (obj)))
{
obj = get_ui_object_parent (obj);
if (obj)
{
set_ui_object_redraw (obj, TRUE);
}
}
return text_obj;
}
static void update_mslider_ui_object (ui_object *obj)
{
float
parent_x1,
parent_y1,
parent_x2,
parent_y2,
parent_x_origin,
parent_y_origin;
float
min,
max,
x1,
y1,
x2,
y2;
ui_object
*object_to_slide,
*parent;
area_ui_object
*area;
float
old_viewport_x1,
old_viewport_y1,
old_viewport_x2,
old_viewport_y2;
// store parents viewport data
old_viewport_x1 = active_viewport.x_min;
old_viewport_y1 = active_viewport.y_min;
old_viewport_x2 = active_viewport.x_max;
old_viewport_y2 = active_viewport.y_max;
area = obj->data;
// Scroll if required
if (scroll)
{
min = get_ui_object_slider_min (obj);
max = get_ui_object_slider_max (obj);
object_to_slide = get_ui_object_next (obj);
scroll_slider (object_to_slide, min, max, scroll);
}
// store parents viewport data
parent = get_ui_object_parent (obj);
parent_x_origin = get_ui_object_x_origin (parent);
parent_y_origin = get_ui_object_y_origin (parent);
parent_x1 = get_ui_object_x (parent);
parent_y1 = get_ui_object_y (parent);
parent_x2 = parent_x1 + get_ui_object_x_size (parent);
parent_y2 = parent_y1 + get_ui_object_y_size (parent);
if (area->drawable)
{
ui_set_origin (0, 0);
draw_ui_object (obj);
if (area->child)
{
x1 = get_ui_object_x (obj);
y1 = get_ui_object_y (obj);
x2 = x1 + get_ui_object_x_size (obj);
y2 = y1 + get_ui_object_y_size (obj);
ui_clip_area (&x1, &y1, &x2, &y2);
set_viewport (x1, y1, x2, y2);
ui_set_origin (0, 0);
update_ui_object (area->child);
}
}
if (area->next)
{
parent = get_ui_object_parent (obj);
if (parent)
{
set_viewport (parent_x1, parent_y1, parent_x2, parent_y2);
ui_set_origin (parent_x_origin, parent_y_origin);
}
update_ui_object (area->next);
}
set_viewport (old_viewport_x1, old_viewport_y1, old_viewport_x2, old_viewport_y2);
}
static void draw_button_ui_object (ui_object *obj)
{
float
// px1,
// py1,
x,
//y,
//vp_x1,
//vp_y1,
//vp_x2,
//vp_y2,
x_size,
y_size,
x_origin,
y_origin,
x1,
y1,
x2,
y2;
//nx1,
//ny1,
//nx2,
//ny2;
int
redraw_flag = FALSE;
// width,
// height,
// pitch;
struct SCREEN
*old_active_screen;
// *memory_graphic;
// unsigned short
// *graphic;
// unsigned char
// *data;
// ui_object
// *parent;
button_ui_object
*button;
button = obj->button;
if (get_ui_object_redraw (obj))
{
if (get_ui_object_autosize (obj))
{
ui_object_autosize (obj);
}
//debug_log ("BU_DRAW: drawing button %f, %f %f, %f", button->area.x, button->area.y, button->area.x_size, button->area.y_size);
//x1 = get_ui_object_x (obj);
//y1 = get_ui_object_y (obj);
x_size = get_ui_object_x_size (obj);
y_size = get_ui_object_y_size (obj);
x_origin = get_ui_object_x_origin (obj);
y_origin = get_ui_object_y_origin (obj);
ui_set_origin (x_origin, y_origin);
//x2 = x1 + x_size;// - 1;
//y2 = y1 + y_size;// - 1;
x1 = get_ui_object_x (obj);
y1 = get_ui_object_y (obj);
x1 += x_origin;
y1 += y_origin;
x2 = x1 + get_ui_object_x_size (obj);
y2 = y1 + get_ui_object_y_size (obj);
old_active_screen = get_active_screen ();
if (get_ui_object_active_screen (obj))
{
set_active_screen (get_ui_object_active_screen (obj));
}
else
{
set_active_screen (video_screen);
}
// debug
set_active_screen (video_screen);
// debug
// if (lock_screen (active_screen))
{
// memory_graphic = get_ui_object_memory_graphic (obj);
if (!get_ui_object_clear (obj))
{
switch (get_ui_object_graphic_type (obj))
{
case UI_OBJECT_TEXTURE_GRAPHIC:
{
texture_graphic
*graphic;
if ((get_ui_object_state (obj) == UI_OBJECT_STATE_ON) && (get_ui_object_selected_texture_graphic (obj)))
{
graphic = get_ui_object_selected_texture_graphic (obj);
}
else if ((get_ui_object_highlighted (obj)) && (get_ui_object_highlighted_texture_graphic (obj)))
{
graphic = get_ui_object_highlighted_texture_graphic (obj);
}
else
{
graphic = get_ui_object_texture_graphic (obj);
}
if (graphic)
{
rgb_colour
colour;
real_colour
text_colour;
colour = get_ui_object_colour ( obj );
text_colour.red = colour.r;
text_colour.green = colour.g;
text_colour.blue = colour.b;
text_colour.alpha = colour.a;
ui_draw_texture_graphic (x1, y1, x2, y2, graphic, text_colour);
}
else
{
ui_draw_area (0, 0, x2 - x1, y2 - y1, obj);
}
break;
}
/*
case UI_OBJECT_GRAPHIC:
{
if (get_ui_object_state (obj) == UI_OBJECT_STATE_ON)
{
graphic = get_ui_object_graphic (obj);
ui_draw_graphic (x1, y1, x2, y2, graphic);
redraw_flag = TRUE;
}
else
{
parent = get_ui_object_parent (obj);
if (parent)
{
graphic = get_ui_object_graphic (parent);
px1 = get_ui_object_x (parent);
py1 = get_ui_object_y (parent);
x1 -= px1;
x2 -= px1;
y1 -= py1;
y2 -= py1;
ui_draw_part_graphic (x1, y1, x2, y2, x1, y1, graphic);
redraw_flag = TRUE;
}
}
break;
}
case UI_OBJECT_MEMORY_GRAPHIC:
{
memory_graphic = get_ui_object_memory_graphic (obj);
if (lock_screen (memory_graphic))
{
width = get_screen_width (memory_graphic);
height = get_screen_height (memory_graphic);
data = get_screen_data (memory_graphic);
pitch = get_screen_pitch (memory_graphic);
ui_draw_memory_graphic (obj, x1, y1, x2, y2, width, height, pitch, FALSE);
unlock_screen (memory_graphic);
}
redraw_flag = TRUE;
break;
}
case UI_OBJECT_ALPHA_GRAPHIC:
{
if (!get_ui_object_clear (obj))
{
graphic = get_ui_object_graphic (obj);
ui_draw_alpha_graphic (x1, y1, x2, y2, graphic);
redraw_flag = TRUE;
}
else
{
parent = get_ui_object_parent (obj);
if (parent)
{
graphic = get_ui_object_graphic (parent);
ui_draw_part_alpha_graphic (x1, y1, x2, y2, x1, y1, graphic);
redraw_flag = TRUE;
}
}
break;
}
*/
case UI_OBJECT_NO_GRAPHIC:
default:
{
int
state;
state = get_ui_object_state (obj);
if ((state == UI_OBJECT_STATE_OFF) && (get_ui_object_highlighted (obj)))
{
state = UI_OBJECT_STATE_HIGHLIGHTED;
}
ui_draw_button (x1, y1, x2, y2, state);
redraw_flag = TRUE;
}
}
}
if (get_ui_object_text (obj))
{
const char
*text_ptr;
int
count;
float
y3;
ui_save_current_font ();
ui_set_object_font (obj);
// count number of lines spanned
text_ptr = get_ui_object_text (obj);
count = 0;
while (text_ptr)
{
count ++;
text_ptr = strchr (text_ptr, '\n');
// if found, step over it and display the next part of string
if (text_ptr)
{
text_ptr ++;
}
}
// now draw text
text_ptr = get_ui_object_text (obj);
get_text_y_position (&y3, y1, y2, text_ptr, get_ui_object_text_justify (obj), count);
while (text_ptr)
{
get_text_x_position (&x, x1, x2, text_ptr, get_ui_object_text_justify (obj));
ui_display_text (text_ptr, x, y3);
y3 += ui_get_font_height ();
// check for carriage return
text_ptr = strchr (text_ptr, '\n');
// if found, step over it and display the next part of string
if (text_ptr)
{
text_ptr ++;
}
}
ui_restore_current_font ();
redraw_flag = TRUE;
}
if (redraw_flag)
{
set_ui_repaint_area (x1 - 1, y1 - 1, x2 + 1, y2 + 1);
}
// unlock_screen (active_screen);
}
set_active_screen (old_active_screen);
button->area.redraw --;
call_ui_object_draw_function (obj, NULL);
}
}
static void update_menu_ui_object (ui_object *obj)
{
float
x1,
y1,
x2,
y2,
parent_x1,
parent_y1,
parent_x2,
parent_y2,
grand_parent_x_origin = 0.0,
grand_parent_y_origin = 0.0;
ui_object
*stack_head,
*grand_parent,
*parent;
area_ui_object
*area;
area = obj->data;
// store parents viewport data
parent = get_ui_object_parent (obj);
grand_parent = get_ui_object_parent (parent);
if (parent)
{
if (grand_parent)
{
grand_parent_x_origin = get_ui_object_x_origin (grand_parent);
grand_parent_y_origin = get_ui_object_y_origin (grand_parent);
}
ui_set_origin (grand_parent_x_origin, grand_parent_y_origin);
parent_x1 = get_ui_object_x (parent);
parent_y1 = get_ui_object_y (parent);
parent_x2 = parent_x1 + get_ui_object_x_size (parent);
parent_y2 = parent_y1 + get_ui_object_y_size (parent);
x1 = parent_x1;
y1 = parent_y1;
x2 = parent_x2;
y2 = parent_y2;
ui_clip_area (&x1, &y1, &x2, &y2);
x1 += grand_parent_x_origin;
y1 += grand_parent_y_origin;
x2 += grand_parent_x_origin;
y2 += grand_parent_y_origin;
set_viewport (x1, y1, x2, y2);
}
if (area->drawable)
{
draw_ui_object (obj);
}
// and its list head
stack_head = obj->stack_head;
if (stack_head)
{
parent = get_ui_object_parent (stack_head);
grand_parent = get_ui_object_parent (parent);
if (parent)
{
if (grand_parent)
{
grand_parent_x_origin = get_ui_object_x_origin (grand_parent);
grand_parent_y_origin = get_ui_object_y_origin (grand_parent);
}
ui_set_origin (grand_parent_x_origin, grand_parent_y_origin);
parent_x1 = get_ui_object_x (parent);
parent_y1 = get_ui_object_y (parent);
parent_x2 = parent_x1 + get_ui_object_x_size (parent);
parent_y2 = parent_y1 + get_ui_object_y_size (parent);
x1 = parent_x1;
y1 = parent_y1;
x2 = parent_x2;
y2 = parent_y2;
ui_clip_area (&x1, &y1, &x2, &y2);
x1 += grand_parent_x_origin;
y1 += grand_parent_y_origin;
x2 += grand_parent_x_origin;
y2 += grand_parent_y_origin;
set_viewport (x1, y1, x2, y2);
}
if (area->drawable)
{
draw_ui_object (stack_head);
}
}
// list head end
if (area->next)
{
parent = get_ui_object_parent (obj);
grand_parent = get_ui_object_parent (parent);
if (parent)
{
if (grand_parent)
{
grand_parent_x_origin = get_ui_object_x_origin (grand_parent);
grand_parent_y_origin = get_ui_object_y_origin (grand_parent);
}
ui_set_origin (grand_parent_x_origin, grand_parent_y_origin);
parent_x1 = get_ui_object_x (parent);
parent_y1 = get_ui_object_y (parent);
parent_x2 = parent_x1 + get_ui_object_x_size (parent);
parent_y2 = parent_y1 + get_ui_object_y_size (parent);
x1 = parent_x1;
y1 = parent_y1;
x2 = parent_x2;
y2 = parent_y2;
x1 += grand_parent_x_origin;
y1 += grand_parent_y_origin;
x2 += grand_parent_x_origin;
y2 += grand_parent_y_origin;
set_viewport (x1, y1, x2, y2);
parent_x1 += get_ui_object_x_origin (parent);
parent_y1 += get_ui_object_y_origin (parent);
ui_set_origin (parent_x1, parent_y1);
}
update_ui_object (area->next);
}
}
