static int _save_page_state(GRAPHICS_CONTROLLER *gc)
{
if (!gc->bog_data) {
GC_ERROR("_save_page_state(): no bog data !\n");
return -1;
}
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
unsigned page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
unsigned ii;
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_save_page_state(): unknown page #%d (have %d pages)\n",
page_id, s->ics->interactive_composition.num_pages);
return -1;
}
/* copy enabled button state, clear draw state */
X_FREE(gc->saved_bog_data);
gc->saved_bog_data = calloc(page->num_bogs, sizeof(*gc->saved_bog_data));
for (ii = 0; ii < page->num_bogs; ii++) {
gc->saved_bog_data[ii].enabled_button = gc->bog_data[ii].enabled_button;
gc->saved_bog_data[ii].animate_indx = gc->bog_data[ii].animate_indx >= 0 ? 0 : -1;
}
return 1;
}
static void _reset_page_state(GRAPHICS_CONTROLLER *gc)
{
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
unsigned page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
unsigned ii;
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_reset_page_state(): unknown page #%d (have %d pages)\n",
page_id, s->ics->interactive_composition.num_pages);
return;
}
size_t size = page->num_bogs * sizeof(*gc->bog_data);
gc->bog_data = realloc(gc->bog_data, size);
memset(gc->bog_data, 0, size);
for (ii = 0; ii < page->num_bogs; ii++) {
gc->bog_data[ii].enabled_button = page->bog[ii].default_valid_button_id_ref;
gc->bog_data[ii].animate_indx = 0;
gc->bog_data[ii].visible_object_id = -1;
}
}
static int _restore_page_state(GRAPHICS_CONTROLLER *gc)
{
if (gc->saved_bog_data) {
if (gc->bog_data) {
GC_ERROR("_restore_page_state(): bog data already exists !\n");
X_FREE(gc->bog_data);
}
gc->bog_data = gc->saved_bog_data;
gc->saved_bog_data = NULL;
return 1;
}
return -1;
}
void Agc_check_heap(const char *phase)
{
SIZE b_free = 0, b_grabbed = 0, s_grabbed = 0;
ELPTR elp;
PTR elend;
SEGCTLPTR segctlp;
for ( segctlp = Agc_segctl_list; segctlp != NIL; segctlp = segctlp->next )
{
s_grabbed++;
b_grabbed += SEGSIZE( segctlp );
ASSERT( SEGELSIZE( segctlp ) > 0 && (char *)SEGEND( segctlp ) > (char *)SEGSTART( segctlp ),Agc_collect,HEAP segments corrupt at start of gc);
for ( elp = DECODEPTR(segctlp->free) , elend = (char *)SEGSTART( segctlp ) - 1; elp != NIL; elp = DECODEPTR(elp->next) )
{
ASSERT((PTR)elp >= (PTR)SEGSTART(segctlp) && (PTR)elp < (PTR)SEGEND(segctlp)
,phase,elp not within segment);
ASSERT((PTR)ELEND(elp,segctlp) <= (PTR)SEGEND(segctlp)
,phase,elp end not within segment);
ASSERT(((char *)(PTR)elp-(char *)(PTR)SEGSTART(segctlp)) % SEGELSIZE(segctlp) == 0
,phase,elp not properly aligned);
ASSERT( elp->next == CODEDNIL || DECODEPTR(elp->next) > ELEND(elp,segctlp)
,phase,old free list elements overlap);
#ifdef A_GC_WORD_ALIGNED
ASSERT( WORDALIGNED(elp)
,phase,elp not word aligned);
#endif
if ( ! ( elp->elements > 0 && (PTR)elp > elend && (elend = (PTR)ELEND( elp, segctlp )) <= (PTR)SEGEND( segctlp ) ) )
{
/* Free list has been corrupted. */
/* Most likely this is because of a user scope/bound error, or CTRANS bug; though possibly a collector bug. */
GC_ERROR(HEAP free list corrupt);
}
b_free += ELBYTESIZE( elp, segctlp );
}
}
ASSERT(Agc_s_grabbed == s_grabbed,phase,count of grabbed segments incorrect);
ASSERT(Agc_b_grabbed == b_grabbed,phase,count of bytes grabbed incorrect);
ASSERT(Agc_b_allocated == b_grabbed - b_free,phase,count of bytes allocated incorrect);
}
void Agc_trace(
SEGCTLPTR *heap_segments
)
{
AREA heap;
AREA area; /* The current area being traced */
TRACINGSTACK tstack; /* Stack of areas to be traced */
SEGCTLPTR segctlp;
SEGCTLPTR *segctlpp;
SIZE temp;
#ifndef A_FUNNY_STEPAREAPTR /* cop-out for weird architectures */
{
/* Check that STEPAREAPTR works correctly on this machine for this nastily aligned structure */
/* If C compiler does tight packing, this could be a problem for the garbage collector */
ASSERT_DECL( struct { PTR p1; char c; PTR p2; } *ass_struct = NIL )
ASSERT_INIT( ( area.addr = (PTR)&ass_struct->c , area.size = sizeof(*ass_struct) ) );
ASSERT_INIT( STEPAREA( area ) );
ASSERT(area.addr == (PTR)&ass_struct->p2,Agc_collect,STEPAREA misbehaving);
}
#endif
heap.addr = SEGSTART( *heap_segments ); heap.size = 0 ;/* inital values to be improved in loop*/
REPORT1(3, "%s\n", "Started trace... setting up bitmaps...");
for ( segctlp = *heap_segments; segctlp != NIL; segctlp = segctlp->next )
{
REPORT6(6,"Agc_collect{mark}: segctlp=0x%p, elsize=%d, start=0x%p, end=0x%p, size=%d,els=%d\n",
(void *)segctlp,SEGELSIZE(segctlp),(void *)SEGSTART(segctlp),(void *)SEGEND(segctlp),SEGSIZE(segctlp),SEGELS(segctlp));
if ( ! ( SEGELSIZE( segctlp ) > 0 && (char *)SEGEND( segctlp ) > (char *)SEGSTART( segctlp ) ) )
{
/* Segment control information has been corrupted. */
/* Most likely this is because of a user scope/bound error, or CTRANS bug; though possibly a collector bug. */
GC_ERROR(HEAP segments corrupt);
}
if ( (char *)SEGSTART( segctlp ) < (char *)(heap.addr) )
{
heap.size += (SIZE)((char *)(heap.addr) - (char *)SEGSTART( segctlp ));
heap.addr = SEGSTART( segctlp );
}
if ( SEGEND( segctlp ) > (PTR)((char *)(heap.addr)+heap.size) )
heap.size = (SIZE)((char *)SEGEND( segctlp ) - (char*)(heap.addr));
GRAB_BITMAP( segctlp->bitmap, SEGELS( segctlp ) + 3 );
SETMARK( segctlp->bitmap, SEGELS( segctlp ) + 0 );
ASSERT(!TSTMARK(segctlp->bitmap,SEGELS(segctlp)+1),Agc_collect,bitmap trailer set at grab);
SETMARK( segctlp->bitmap, SEGELS( segctlp ) + 2 );
/* create an artificial endpoint which can be scanned to */
REPORT2(6,"Agc_collect:\t\tbitmap, ptr=0x%p, size=%d\n", (void *)(segctlp->bitmap), SEGELS( segctlp ));
}
REPORT2(5,"Agc_collect: heap address=0x%p, heap size=%d\n",(void *)heap.addr,heap.size);
INIT_STACK(tstack);
ASSERT_INIT(PUSH(tstack,(PTR)Agc_collect,-42)); /* Assertion mark */
PUSH(tstack, NIL, 0); /* identifies exhausted stack */
REPORT1(3, "%s\n", "Initialising stack scan...");
INIT_AREA(area); /* set area to first area to search - could also PUSH
any additional areas (or use NEXT_AREA) */
do
{
for ( ; !NILAREA(area); /* POP() at end of loop as it may contain statements */ )
{
REPORT3(6,"Agc_collect: AREA scan, ptr=0x%p -> 0x%p, size=%d\n",
(void *)area.addr,(void *)((char *)area.addr+area.size),area.size);
ASSERT(area.size >= 0 && area.size < 100*1024*1024 /* 100Mb */,Agc_collect,area size not sensible);
for ( ; area.size >= sizeof(PTR); STEPAREA(area) )
{
SIZE els, el_in_seg;
PTR p = * (PTR *) area.addr; /* View word as a pointer */
REPORT3(9,"Agc_collect: AREA scan step, ptr=0x%p, size=%d, p=0x%p\n",
(void *)area.addr,area.size,(void *)p);
/* Continue loop if 'p' is unlikely to be a heap pointer. */
/* Keeping the loop small may help some machines with small instruction caches. */
if ( !VALIDPTR( p ) || !PTRINAREA(p,heap) ) continue;
/* p is very likely to be a heap pointer */
for ( segctlpp = heap_segments; (segctlp = *segctlpp) != NIL; segctlpp = &((segctlp)->next ))
{
if ( (char *)p >= (char *)SEGSTART(segctlp) && (char *)p < (char *)SEGEND(segctlp) )
{
/* Segment for heap pointer */
goto found_segment;
}
}
/* Not a valid heap pointer */
continue; /* back to STEPAREA loop */
found_segment:
REPORT3(6,"Agc_collect, found_segment: ptr=0x%p, segctlp=0x%p, elsize=%d\n",
(void *)p,(void *)segctlp,SEGELSIZE(segctlp));
/*
** Move segment to front of segment list, to effect a 'cacheing' as in allocation.
** We believe that there is locality in types of heap pointers,
** (consider lists and trees) so it is likely that next
** lookup will immediately succeed.
** However a fast search startegy might be better ???
**
** Note that typical programs only have a small number of segs,
** many of which are infrequently used.
** Multics Algol68 compiler uses 12 segs;
** ELLA uses ??? segs.
*/
*segctlpp = segctlp->next;
segctlp->next = *heap_segments;
*heap_segments = segctlp;
#ifdef MUST_POINT_TO_WORD
/*
* Ignore pointers that are not word aligned,
* unless in a segment of objects of size that is not a multiple of word.
*/
if ( (SEGELSIZE(segctlp) & (WORDSIZE-1)) == 0 && (((CODEDPTR)(p) & (WORDSIZE-1)) != 0) )
continue; /* p not to word aligned object, forget it */
#endif
#ifdef MUST_POINT_TO_LWORD
/*
* Ignore pointers that are not long word aligned,
* unless in a segment of objects of size that is not a multiple of long word.
*/
if ( (SEGELSIZE(segctlp) & (sizeof(long)-1)) == 0 && (((CODEDPTR)(p) & (sizeof(long)-1)) != 0) )
continue; /* p not to long aligned object, forget it */
#endif
IDENTIFY_ALIGN_EL( p, el_in_seg, segctlp );
#ifdef MUST_POINT_TO_START
/* Ignore pointers that point within objects */
/* This could be implemented more efficiently */
if ( p != * (PTR *) area.addr )
continue; /* p not to start of element, forget it */
#endif
#ifdef NO_GCMARK
els = 1;
#else
ANAL_DESC( els, p, area );
#endif
REPORT3(6,"Agc_collect, aligned and analysed ptr: ptr=0x%p, element in seg=%d, elements=%d\n",
(void *)p,el_in_seg,els);
#ifdef A_GC_HALFWORD_ALIGNED
/* Interpret this as half word aligned (2byte) DJS 8/12/94 */
/* +++ !!! ???
** Crappy quick fix to keep elements word aligned for the Apollo
** (also done for Sun/68000, though it has not been proved that this is necessary).
** Apollo does not permit word objects to be aligned at any byte boundry,
** even though 68020/68030 does. This must be because C compiler generates
** strange code, or page faults for words that straddle page boundries are
** handled badly.
*/
if ( SEGELSIZE(segctlp) == 1 )
{
if ( (long)p & 1 )
{
p--;
el_in_seg--;
els++;
}
if ( els & 1 )
{
els++;
}
if ( els <= 1 || els > SEGELS(segctlp) || p+(els*SEGELSIZE(segctlp)) > SEGEND(segctlp) )
{
els = 2;
}
REPORT3(6,"Agc_collect, adjusted to: ptr=0x%x, element in seg=%d, elements=%d\n",
p,el_in_seg,els);
goto els_sensible;
}
#endif
#ifdef A_GC_WORD_ALIGNED
/* +++ !!! ???
** Crappy quick fix to keep elements word aligned.
*/
if ( SEGELSIZE(segctlp) == 1 )
{
if ( !WORDALIGNED(p) )
{
int offset = (int)((CODEDPTR)p & (WORDSIZE-1));
p = (char *)p - offset;
el_in_seg -= offset;
els += offset;
}
if ( !WORDALIGNED(els) )
{
els = (SIZE)ALIGN_NEXT(els,WORDSIZE);
}
if ( (els < WORDSIZE) || (els > SEGELS(segctlp)) || ((char *)p+(els*SEGELSIZE(segctlp)) > (char *)SEGEND(segctlp) ))
{
els = WORDSIZE;
}
REPORT3(6,"Agc_collect, adjusted to: ptr=0x%p, element in seg=%d, elements=%d\n",
(void *)p,el_in_seg,els);
goto els_sensible;
}
#endif
/* 'els' may be a very silly number, check it is reasonable */
/* before doing arithmetic that may overflow. */
if ( els <= 1 || els > SEGELS(segctlp) || (char *)p+(els*SEGELSIZE(segctlp)) > (char *)SEGEND(segctlp) )
{
/* els = 1; assumed in case array descriptor mis analysed, the ptr is still valid */
if ( !TSTMARK( segctlp->bitmap, el_in_seg ) )
{
SETMARK( segctlp->bitmap, el_in_seg );
if ( SEGELSIZE(segctlp) >= PTRSIZE )
{
/* need only scan elements that are large enough to hold pointer */
PUSH( tstack, p, SEGELSIZE(segctlp) );
REPORT2(6,"Agc_collect: PUSH( ptr=0x%p, size=%d )\n",
(void *)p,SEGELSIZE(segctlp));
}
}
}
else
{
els_sensible:
CALCTSTMARKS( segctlp->bitmap, el_in_seg, els, temp );
if ( !RESTSTMARKS( segctlp->bitmap, el_in_seg, els, temp ) )
{
/*
** At least one element in area has not been marked before.
**
** We could just mark and push unmarked areas,
** but this complicates logic for a fairly rare eventuality,
** mainly caused by the trimming of heap rows.
*/
SETMARKS( segctlp->bitmap, el_in_seg, els );
if ( SEGELSIZE(segctlp) >= PTRSIZE )
{
/* need only scan elements that are large enough to hold pointer */
PUSH( tstack, p, els*SEGELSIZE(segctlp) );
REPORT2(6,"Agc_collect: PUSH( ptr=0x%p, size=%d )\n",
(void *)p,els*SEGELSIZE(segctlp));
}
}
}
}
area = POP(tstack);
}
/* Stack is exhausted, replace end marker */
PUSH(tstack, NIL, 0); /* identifies exhausted stack */
NEXT_AREA(area);
REPORT2(6,"Agc_collect: NEXT_AREA, ptr=0x%p, size=%d\n",(void *)area.addr,area.size);
}
while( area.addr != NIL );
area = POP(tstack); /* pop of (NIL, 0) to leave stack empty and tidy before calling FREE_STACK() */
ASSERT_INIT( area=POP(tstack) );
ASSERT(area.addr == (PTR)Agc_collect && area.size == -42,Agc_collect,tracing stack misuse);
FREE_STACK(tstack);
REPORT1(3, "%s\n", "End of trace");
}
static void _set_button_page(GRAPHICS_CONTROLLER *gc, uint32_t param)
{
unsigned page_flag = param & 0x80000000;
unsigned effect_flag = param & 0x40000000;
unsigned button_flag = param & 0x20000000;
unsigned page_id = (param >> 16) & 0xff;
unsigned button_id = param & 0xffff;
unsigned bog_idx = 0;
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
BD_IG_BUTTON *button = NULL;
GC_TRACE("_set_button_page(0x%08x): page flag %d, id %d, effects %d button flag %d, id %d\n",
param, !!page_flag, page_id, !!effect_flag, !!button_flag, button_id);
/* 10.4.3.4 (D) */
if (!page_flag && !button_flag) {
return;
}
if (page_flag) {
/* current page --> command is ignored */
if (page_id == bd_psr_read(gc->regs, PSR_MENU_PAGE_ID)) {
GC_TRACE(" page is current\n");
return;
}
page = _find_page(&s->ics->interactive_composition, page_id);
/* invalid page --> command is ignored */
if (!page) {
GC_TRACE(" page is invalid\n");
return;
}
/* page changes */
_select_page(gc, page_id);
} else {
/* page does not change */
page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_set_button_page(): PSR_MENU_PAGE_ID refers to unknown page %d\n", page_id);
return;
}
}
if (button_flag) {
/* find correct button and overlap group */
button = _find_button_page(page, button_id, &bog_idx);
if (!page_flag) {
if (!button) {
/* page not given, invalid button --> ignore command */
GC_TRACE(" button is invalid\n");
return;
}
if (button_id == bd_psr_read(gc->regs, PSR_SELECTED_BUTTON_ID)) {
/* page not given, current button --> ignore command */
GC_TRACE(" button is current\n");
return;
}
}
}
if (button) {
gc->bog_data[bog_idx].enabled_button = button_id;
_select_button(gc, button_id);
}
_render_page(gc, 0xffff, NULL); /* auto action not triggered yet */
}
static int _user_input(GRAPHICS_CONTROLLER *gc, uint32_t key, GC_NAV_CMDS *cmds)
{
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
unsigned page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
unsigned cur_btn_id = bd_psr_read(gc->regs, PSR_SELECTED_BUTTON_ID);
unsigned new_btn_id = cur_btn_id;
unsigned ii;
int activated_btn_id = -1;
if (s->ics->interactive_composition.ui_model == IG_UI_MODEL_POPUP && !gc->popup_visible) {
GC_TRACE("_user_input(): popup menu not visible\n");
return -1;
}
if (!gc->ig_drawn) {
GC_ERROR("_user_input(): menu not visible\n");
return -1;
}
GC_TRACE("_user_input(%d)\n", key);
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_user_input(): unknown page id %d (have %d pages)\n",
page_id, s->ics->interactive_composition.num_pages);
return -1;
}
if (key == BD_VK_MOUSE_ACTIVATE) {
if (!gc->valid_mouse_position) {
GC_TRACE("_user_input(): BD_VK_MOUSE_ACTIVATE outside of valid buttons\n");
return -1;
}
key = BD_VK_ENTER;
}
for (ii = 0; ii < page->num_bogs; ii++) {
BD_IG_BOG *bog = &page->bog[ii];
unsigned valid_id = gc->bog_data[ii].enabled_button;
BD_IG_BUTTON *button = _find_button_bog(bog, valid_id);
if (!button) {
continue;
}
/* numeric select */
if (VK_IS_NUMERIC(key)) {
if (button->numeric_select_value == VK_TO_NUMBER(key)) {
new_btn_id = button->id;
}
}
/* cursor keys */
else if (VK_IS_CURSOR(key) || key == BD_VK_ENTER) {
if (button->id == cur_btn_id) {
switch(key) {
case BD_VK_UP:
new_btn_id = button->upper_button_id_ref;
break;
case BD_VK_DOWN:
new_btn_id = button->lower_button_id_ref;
break;
case BD_VK_LEFT:
new_btn_id = button->left_button_id_ref;
break;
case BD_VK_RIGHT:
new_btn_id = button->right_button_id_ref;
break;
case BD_VK_ENTER:
activated_btn_id = cur_btn_id;
cmds->num_nav_cmds = button->num_nav_cmds;
cmds->nav_cmds = button->nav_cmds;
cmds->sound_id_ref = button->activated_sound_id_ref;
break;
default:;
}
}
if (new_btn_id != cur_btn_id) {
BD_IG_BUTTON *new_button = _find_button_page(page, new_btn_id, NULL);
if (new_button) {
cmds->sound_id_ref = new_button->selected_sound_id_ref;
}
}
}
}
/* render page ? */
if (new_btn_id != cur_btn_id || activated_btn_id >= 0) {
_select_button(gc, new_btn_id);
_render_page(gc, activated_btn_id, cmds);
/* found one*/
return 1;
}
return 0;
}
static int _render_page(GRAPHICS_CONTROLLER *gc,
unsigned activated_button_id,
GC_NAV_CMDS *cmds)
{
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
BD_PG_PALETTE *palette = NULL;
unsigned page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
unsigned ii;
unsigned selected_button_id = bd_psr_read(gc->regs, PSR_SELECTED_BUTTON_ID);
if (s->ics->interactive_composition.ui_model == IG_UI_MODEL_POPUP && !gc->popup_visible) {
if (gc->ig_open) {
GC_TRACE("_render_page(): popup menu not visible\n");
_close_osd(gc, BD_OVERLAY_IG);
return 1;
}
return 0;
}
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_render_page: unknown page id %d (have %d pages)\n",
page_id, s->ics->interactive_composition.num_pages);
return -1;
}
palette = _find_palette(s, page->palette_id_ref);
if (!palette) {
GC_ERROR("_render_page: unknown palette id %d (have %d palettes)\n",
page->palette_id_ref, s->num_palette);
return -1;
}
GC_TRACE("rendering page #%d using palette #%d. page has %d bogs\n",
page->id, page->palette_id_ref, page->num_bogs);
if (!gc->ig_open) {
_open_osd(gc, BD_OVERLAY_IG,
s->ics->video_descriptor.video_width,
s->ics->video_descriptor.video_height);
}
for (ii = 0; ii < page->num_bogs; ii++) {
BD_IG_BOG *bog = &page->bog[ii];
unsigned valid_id = gc->bog_data[ii].enabled_button;
BD_IG_BUTTON *button;
button = _find_button_bog(bog, valid_id);
if (!button) {
GC_TRACE("_render_page(): bog %d: button %d not found\n", ii, valid_id);
// render background
_clear_bog_area(gc, &gc->bog_data[ii]);
} else if (button->id == activated_button_id) {
GC_TRACE(" button #%d activated\n", button->id);
_render_button(gc, button, palette, BTN_ACTIVATED, &gc->bog_data[ii]);
} else if (button->id == selected_button_id) {
if (button->auto_action_flag && !gc->auto_action_triggered) {
if (cmds) {
GC_TRACE(" auto-activate #%d\n", button->id);
cmds->num_nav_cmds = button->num_nav_cmds;
cmds->nav_cmds = button->nav_cmds;
gc->auto_action_triggered = 1;
} else {
GC_ERROR(" auto-activate #%d not triggered (!cmds)\n", button->id);
}
_render_button(gc, button, palette, BTN_ACTIVATED, &gc->bog_data[ii]);
} else {
_render_button(gc, button, palette, BTN_SELECTED, &gc->bog_data[ii]);
}
} else {
_render_button(gc, button, palette, BTN_NORMAL, &gc->bog_data[ii]);
}
}
if (gc->ig_dirty) {
_flush_osd(gc, BD_OVERLAY_IG, -1);
gc->ig_dirty = 0;
return 1;
}
return 0;
}
static int _mouse_move(GRAPHICS_CONTROLLER *gc, unsigned x, unsigned y, GC_NAV_CMDS *cmds)
{
PG_DISPLAY_SET *s = gc->igs;
BD_IG_PAGE *page = NULL;
unsigned page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);
unsigned cur_btn_id = bd_psr_read(gc->regs, PSR_SELECTED_BUTTON_ID);
unsigned new_btn_id = 0xffff;
unsigned ii;
gc->valid_mouse_position = 0;
if (!gc->ig_drawn) {
GC_TRACE("_mouse_move(): menu not visible\n");
return -1;
}
page = _find_page(&s->ics->interactive_composition, page_id);
if (!page) {
GC_ERROR("_mouse_move(): unknown page #%d (have %d pages)\n",
page_id, s->ics->interactive_composition.num_pages);
return -1;
}
for (ii = 0; ii < page->num_bogs; ii++) {
BD_IG_BOG *bog = &page->bog[ii];
unsigned valid_id = gc->bog_data[ii].enabled_button;
BD_IG_BUTTON *button = _find_button_bog(bog, valid_id);
if (!button)
continue;
if (x < button->x_pos || y < button->y_pos)
continue;
/* Check for SELECTED state object (button that can be selected) */
BD_PG_OBJECT *object = _find_object_for_button(s, button, BTN_SELECTED, NULL);
if (!object)
continue;
if (x >= button->x_pos + object->width || y >= button->y_pos + object->height)
continue;
/* mouse is over button */
gc->valid_mouse_position = 1;
/* is button already selected? */
if (button->id == cur_btn_id) {
return 1;
}
new_btn_id = button->id;
if (cmds) {
cmds->sound_id_ref = button->selected_sound_id_ref;
}
break;
}
if (new_btn_id != 0xffff) {
_select_button(gc, new_btn_id);
_render_page(gc, -1, cmds);
}
return gc->valid_mouse_position;
}
