/*----------------------------------------------------------------------------------------*/
void sld_arrow( SLD *slider, int16 scroll, int16 val )
{
EVNTDATA ev;
GRECT rect;
int16 pos;
switch( scroll )
{
case SCROLL_LINE:
wdset_state( slider->wd, ( val < 0 ? slider->up : slider->down ), SELECTED, TRUE );
break;
case SCROLL_PAGE:
graf_mkstate( &ev );
objc_rect( slider->wd->tree, slider->white, &rect );
if( !val ) /* new */
val = ev.y < rect.g_y ? -1 : 1;
break;
}
do
{
pos = slider->scroll( slider->wd, scroll, val );
sld_setpos( slider, pos );
sld_redraw( slider );
graf_mkstate( &ev );
evnt_timer(20);
} while ( ev.bstate & 0x01 );
wdset_state( slider->wd, ( val < 0 ? slider->up : slider->down ), SELECTED, FALSE );
}
/* --------------------------
| Move Micro-wire slider |
-------------------------- */
void mw_move(int inx)
{
int obj_y, obj_y2, obj_x;
int mx, my, mk, ks;
int obj_h;
int red, dummy;
objc_offset(setmw_dia.tree, mw_sld[inx], &dummy, &obj_y);
obj_h = setmw_dia.tree[mw_sld[inx]].ob_height;
graf_mkstate(&mx, &my, &mk, &ks);
mk = 1;
do
{
if (mk == 1 && my < obj_y || my >= obj_y + obj_h)
{
red = 0;
if (my > obj_y && mw_data[inx])
{
mw_data[inx]--;
red = 1;
}
if (my < obj_y && mw_data[inx] < mw_sldd[inx])
{
mw_data[inx]++;
red = 1;
}
if (red)
{
set_mwsld(inx);
objc_offset(setmw_dia.tree, mw_sld[inx], &obj_x, &obj_y2);
if (obj_y2 < obj_y)
dialog_redraw(setmw_dia.w_handle, ROOT,
obj_x,
obj_y2,
setmw_dia.tree[mw_sld[inx]].ob_width + 4,
setmw_dia.tree[mw_sld[inx]].ob_height + 4
+ obj_y - obj_y2);
else
dialog_redraw(setmw_dia.w_handle, ROOT,
obj_x,
obj_y,
setmw_dia.tree[mw_sld[inx]].ob_width + 4,
setmw_dia.tree[mw_sld[inx]].ob_height + 4
+ obj_y2 - obj_y);
obj_y = obj_y2;
}
}
graf_mkstate(&mx, &my, &mk, &ks);
}while(mk == 1);
}
main()
{
int gr_mkmx, gr_mkmy;
int gr_mkmstate, gr_mkkstate;
int tmpx, tmpy;
int tmpx1, tmpy1;
int tmpx2, tmpy2;
int index, rgb_in[3];
int draw;
appl_init();
phys_handle = graf_handle(&gl_wchar, &gl_hchar, &gl_wbox, &gl_hbox);
wind_get(0, WF_WORKXYWH, &xdesk, &ydesk, &wdesk, &hdesk);
open_vwork();
wi_handle = wind_create(0x0040&0x0080, xdesk, ydesk, wdesk, hdesk);
graf_mouse(3, 0x0L);
vswr_mode(handle, 3);
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
while(!(0x0002&gr_mkmstate)) {
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
if (0x0001&gr_mkmstate) {
tmpy = gr_mkmy;
tmpx = gr_mkmx;
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
graf_mouse(M_OFF, 0x0L);
tmpy1 = gr_mkmy;
tmpx1 = gr_mkmx;
drawframe(tmpx, tmpy, tmpx1, tmpy1);
graf_mouse(M_ON, 0x0L);
while (0x0001&gr_mkmstate) {
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
if (((tmpx1 != gr_mkmx) || (tmpy1 != gr_mkmy)) &&
(0x0001&gr_mkmstate)) {
graf_mouse(M_OFF, 0x0L);
drawframe(tmpx, tmpy, tmpx1, tmpy1);
drawframe(tmpx, tmpy, gr_mkmx, gr_mkmy);
graf_mouse(M_ON, 0x0L);
tmpy1 = gr_mkmy;
tmpx1 = gr_mkmx;
}
}
graf_mouse(M_OFF, 0x0L);
drawframe(tmpx, tmpy, tmpx1, tmpy1);
graf_mouse(M_ON, 0x0L);
}
}
wind_delete(wi_handle);
v_clsvwk(handle);
appl_exit();
}
static void do_bar(OBJECT *tree, SLIDER *sl, XDINFO *info)
{
int my, oy, dummy, old, max;
graf_mkstate(&dummy, &my, &dummy, &dummy);
objc_offset(tree, sl->slider, &dummy, &oy);
do
{
old = sl->line;
if (my < oy)
{
sl->line -= sl->lines;
if (sl->line < 0)
sl->line = 0;
}
else
{
sl->line += sl->lines;
max = sl->n - sl->lines;
if (sl->line > max)
sl->line = max;
}
if (sl->line != old)
{
sl_set_slider(tree, sl, info);
sl->set_selector(sl, TRUE, info);
}
}
while (xe_button_state() & 0x1);
}
static int OnRButtonDown(void *w, int mk_state, int x, int y)
{
GEM_WINDOW *wnd = w ;
HEX_DUMP *hex_dump = (HEX_DUMP *) wnd->Extension ;
OBJECT *popup ;
int clicked ;
int i, mx, my, dummy ;
popup = popup_make( 4, 15 ) ;
if ( popup == NULL ) return( 0 ) ;
i = 0 ;
strcpy( popup[++i].ob_spec.free_string, " Byte " ) ;
strcpy( popup[++i].ob_spec.free_string, " Word " ) ;
strcpy( popup[++i].ob_spec.free_string, " Long " ) ;
strcpy( popup[++i].ob_spec.free_string, " Find... " ) ;
if ( ( hex_dump->display_type >= DT_BYTE ) && ( hex_dump->display_type <= DT_MIXED ) )
popup[hex_dump->display_type].ob_spec.free_string[0] = 8 ;
graf_mkstate( &mx, &my, &dummy, &dummy ) ;
clicked = popup_formdo( &popup, mx-16, my, 1, 0 ) ;
popup_kill( popup, 4 ) ;
if ( clicked >= 0 )
{
}
return( GW_EVTSTOPROUTING ) ;
}
/* test for shift key, and mark as 'selected' rather than VIEWED */
char view_or_select(void)
{
int dummy,shift;
if (ncn<0) { return( VIEWED ); } /* no 'select' while offline */
graf_mkstate(&dummy,&dummy,&dummy,&shift);
if (shift&(K_RSHIFT+K_LSHIFT)) { return( SELECT_RET ); } else { return( VIEWED ); }
}
/*! desk events */
void event_desk(void) {
int old_x, old_y, new_x, new_y, dummy;
evnt_timer(70, 0); /* timer delay */
graf_mkstate(&dummy, &dummy, &mk, &dummy);
if((object == BU_ICN) &&(mk == 1)) { /* icon still cliked -> move */
old_x = adr_desk[object].ob_x;
old_y = adr_desk[object].ob_y;
graf_dragbox(adr_desk[object].ob_width, adr_desk[object].ob_height,
adr_desk[object].ob_x + bureau.xd, adr_desk[object].ob_y + bureau.yd,
bureau.xd, bureau.yd, bureau.wd, bureau.hd, &new_x, &new_y);
adr_desk[object].ob_x = new_x - bureau.xd;
adr_desk[object].ob_y = new_y - bureau.yd;
form_dial(FMD_FINISH, 0, 0, 0, 0, old_x + bureau.xd, old_y + bureau.yd,
adr_desk[object].ob_width, adr_desk[object].ob_height);
form_dial(FMD_FINISH, 0, 0, 0, 0,
adr_desk[object].ob_x + bureau.xd, adr_desk[object].ob_y + bureau.yd,
adr_desk[object].ob_width, adr_desk[object].ob_height);
}
else if(((object == BU_BOXTXT) ||(object == BU_TXT1)
||(object == BU_TXT2)) &&(mk == 1)) {
/* text stiil cliked -> move */
old_x = adr_desk[BU_BOXTXT].ob_x;
old_y = adr_desk[BU_BOXTXT].ob_y;
graf_dragbox(adr_desk[BU_BOXTXT].ob_width, adr_desk[BU_BOXTXT].ob_height,
adr_desk[BU_BOXTXT].ob_x + bureau.xd, adr_desk[BU_BOXTXT].ob_y + bureau.yd,
bureau.xd, bureau.yd, bureau.wd, bureau.hd, &new_x, &new_y);
adr_desk[BU_BOXTXT].ob_x = new_x - bureau.xd;
adr_desk[BU_BOXTXT].ob_y = new_y - bureau.yd;
form_dial(FMD_FINISH, 0, 0, 0, 0, old_x + bureau.xd - 3, old_y + bureau.yd - 3,
adr_desk[BU_BOXTXT].ob_width + 6, adr_desk[BU_BOXTXT].ob_height + 6);
form_dial(FMD_FINISH, 0, 0, 0, 0,
adr_desk[BU_BOXTXT].ob_x + bureau.xd - 3,
adr_desk[BU_BOXTXT].ob_y + bureau.yd - 3,
adr_desk[BU_BOXTXT].ob_width + 6, adr_desk[BU_BOXTXT].ob_height + 6);
}
else if(((object == ZERO) ||(object == BU_IMG)) &&
(adr_desk[BU_ICN].ob_state & SELECTED) &&(mk == 0)) {
/* desk clicked -> deselect */
adr_desk[BU_ICN].ob_state &= ~SELECTED;
form_dial(FMD_FINISH, 0, 0, 0, 0,
adr_desk[BU_ICN].ob_x + bureau.xd, adr_desk[BU_ICN].ob_y + bureau.yd,
adr_desk[BU_ICN].ob_width, adr_desk[BU_ICN].ob_height);
}
else if((object == BU_ICN) && NOT(adr_desk[BU_ICN].ob_state & SELECTED)
&& (mk == 0)) {
/* simple click icon -> select */
adr_desk[BU_ICN].ob_state |= SELECTED;
form_dial(FMD_FINISH, 0, 0, 0, 0,
adr_desk[BU_ICN].ob_x + bureau.xd, adr_desk[BU_ICN].ob_y + bureau.yd,
adr_desk[BU_ICN].ob_width, adr_desk[BU_ICN].ob_height);
}
} /* end of event_desk() */
static WORD hndl_button(WORD clicks, WORD mx, WORD my, WORD button, WORD keystate)
{
WORD done, junk;
GRECT c;
WORD wh, dobj, dest_wh;
WORD root;
WNODE *wn;
done = FALSE;
wh = wind_find(mx, my);
if (wh != G.g_cwin)
desk_clear(G.g_cwin);
desk_verify(wh, FALSE);
wind_get_grect(wh, WF_WXYWH, &c);
if (clicks == 1)
{
act_bsclick(G.g_cwin, G.g_screen, G.g_croot, mx, my,
keystate, &c, FALSE);
graf_mkstate(&junk, &junk, &button, &junk);
if (button & 0x0001)
{
dest_wh = act_bdown(G.g_cwin, G.g_screen, G.g_croot, &mx, &my,
&keystate, &c, &dobj);
if (dest_wh != NIL)
{
root = 1;
if (dest_wh != 0)
{
wn = win_find(dest_wh);
if (wn)
root = wn->w_root;
}
desk1_drag(wh, dest_wh, root, dobj, mx, my, keystate);
desk_clear(wh);
}
}
}
else
{
act_bsclick(G.g_cwin, G.g_screen, G.g_croot, mx, my, keystate, &c, TRUE);
done = do_filemenu(OPENITEM);
}
men_update(G.a_trees[ADMENU]);
return done;
}
void
Do_Slider( int base, int slider, int index, int dclick )
{
MRETS mk;
int oldy;
if( dclick )
do_rgb( slider, base, index );
else
{
(*xcpb->MFsave)(MFSAVE, &orig_mf);
if( AES_Version >= 0x0320 )
graf_mouse( FLAT_HAND, 0L );
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XSelect( tree, slider );
curslid = slider;
graf_mkstate( &mk.x, &oldy, &mk.buttons, &mk.kstate );
do
{
graf_mkstate( &mk.x, &mk.y, &mk.buttons, &mk.kstate );
}while( mk.buttons && ( mk.y == oldy ));
if( mk.buttons && ( mk.y != oldy ))
(*xcpb->Sl_dragy)(tree, base, slider, 0, 1000,
&curscrn[index], adjcol);
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XDeselect( tree, slider );
(*xcpb->MFsave)(MFRESTORE, &orig_mf);
}
}
VOID hndl_spsel(WORD mx, WORD my, WORD mb, WORD ks)
{
WORD curr_ob;
WORD state, shifted;
LONG tree;
tree = ad_spol;
shifted = (ks & K_LSHIFT) || (ks & K_RSHIFT);
curr_ob = objc_find((OBJECT FAR *)tree, ROOT, MAX_DEPTH, mx, my);
if ( (curr_ob >= F1NAME) &&
(curr_ob <= F12NAME) &&
(gl_sppfn[curr_ob - F1NAME] != NULL) )
{
state = the_spol[curr_ob].ob_state;
if ( !shifted )
{
if ( !(state & SELECTED) )
{
act_allchg(curr_ob, &the_spol[0].ob_x, SELECTED, FALSE);
state |= SELECTED;
}
}
else
{
if (state & SELECTED)
state &= ~SELECTED;
else
state |= SELECTED;
}
if (state != the_spol[curr_ob].ob_state )
spol_chg(curr_ob, state);
}
else
{
act_allchg(curr_ob, &the_spol[0].ob_x, SELECTED, FALSE);
}
graf_mkstate(&mx, &my, &mb, &ks);
if (mb & 0x0001)
spol_down(mx, my);
}
void
iw_drag(ICONWIND iw, WORD xoff, WORD yoff)
{
UWORD e;
WORD mx, my, mb, i;
wind_update(BEG_MCTRL);
graf_mkstate(&mx, &my, &mb, &i);
do {
iw->w.rwind.g_x = min(max(mx + xoff, desk.g_x),
desk.g_x + desk.g_w - iw->w.rwind.g_w);
iw->w.rwind.g_y = min(max(my + yoff, desk.g_y),
desk.g_y + desk.g_h - iw->w.rwind.g_h);
iw_xdraw(iw);
e = evnt_multi(MU_BUTTON|MU_M1, 1,1,!mb,
1,mx,my,1,1, 0,0,0,0,0,
NULL, 0,0, &mx, &my, &i, &i, &i, &i);
iw_xdraw(iw);
} while (!(e & MU_BUTTON));
wind_update(END_MCTRL);
iw->w.sizecalc(&iw->w, &iw->w.rwind);
}
int OnObjectNotifyGamma(void *w, int obj)
{
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_GAMMA *wext = wnd->DlgData->UserData ;
OBJECT *adr_gamma = wnd->DlgData->BaseObject ;
int xm, dummy ;
int code = -1 ;
switch( obj )
{
case GAMMA_RMOINS :
case GAMMA_RPLUS : if ( obj == GAMMA_RPLUS ) wext->rgamma += 0.05 ;
else wext->rgamma -= 0.05 ;
if ( wext->rgamma < 0.02 ) wext->rgamma = 0.02 ;
if ( wext->rgamma > 2.0 ) wext->rgamma = 2.0 ;
wext->off_x = (int) (wext->rgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_RSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_RVAL ) ;
break ;
case GAMMA_RBAR : graf_mkstate(&xm, &dummy, &dummy, &dummy) ;
objc_offset(adr_gamma, GAMMA_RSLIDER, &wext->off_x, &wext->off_y) ;
if (xm > wext->off_x) wext->rgamma += 0.2 ;
else wext->rgamma -= 0.2 ;
if (wext->rgamma < 0.02) wext->rgamma = 0.02 ;
if (wext->rgamma > 2.0) wext->rgamma = 2.0 ;
wext->off_x = (int) (wext->rgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_RSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_RVAL) ;
break ;
case GAMMA_RSLIDER : wext->rgamma = (float) graf_slidebox(adr_gamma, GAMMA_RBAR, GAMMA_RSLIDER, 0) ;
wext->rgamma = wext->rgamma*2.0/1000.0 ;
if (wext->rgamma < 0.02) wext->rgamma = 0.02 ;
wext->off_x = (int) (wext->rgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_RSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_RVAL) ;
break ;
case GAMMA_VMOINS :
case GAMMA_VPLUS : if ( obj == GAMMA_VPLUS ) wext->vgamma += 0.05 ;
else wext->vgamma -= 0.05 ;
if (wext->vgamma < 0.02) wext->vgamma = 0.02 ;
if (wext->vgamma > 2.0) wext->vgamma = 2.0 ;
wext->off_x = (int) (wext->vgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_VSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_VVAL) ;
break ;
case GAMMA_VBAR : graf_mkstate(&xm, &dummy, &dummy, &dummy) ;
objc_offset(adr_gamma, GAMMA_VSLIDER, &wext->off_x, &wext->off_y) ;
if (xm > wext->off_x) wext->vgamma += 0.2 ;
else wext->vgamma -= 0.2 ;
if (wext->vgamma < 0.02) wext->vgamma = 0.02 ;
if (wext->vgamma > 2.0) wext->vgamma = 2.0 ;
wext->off_x = (int) (wext->vgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_VSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_VVAL) ;
break ;
case GAMMA_VSLIDER : wext->vgamma = (float) graf_slidebox(adr_gamma, GAMMA_VBAR, GAMMA_VSLIDER, 0) ;
wext->vgamma = wext->vgamma*2.0/1000.0 ;
if (wext->vgamma < 0.02) wext->vgamma = 0.02 ;
wext->off_x = (int) (wext->vgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_VSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_VVAL) ;
break ;
case GAMMA_BMOINS :
case GAMMA_BPLUS : if ( obj == GAMMA_BPLUS ) wext->bgamma += 0.05 ;
else wext->bgamma -= 0.05 ;
if (wext->bgamma < 0.02) wext->bgamma = 0.02 ;
if (wext->bgamma > 2.0) wext->bgamma = 2.0 ;
wext->off_x = (int) (wext->bgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_BSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_BVAL) ;
break ;
case GAMMA_BBAR : graf_mkstate(&xm, &dummy, &dummy, &dummy) ;
objc_offset(adr_gamma, GAMMA_BSLIDER, &wext->off_x, &wext->off_y) ;
if (xm > wext->off_x) wext->bgamma += 0.2 ;
else wext->bgamma -= 0.2 ;
if (wext->bgamma < 0.02) wext->bgamma = 0.02 ;
if (wext->bgamma > 2.0) wext->bgamma = 2.0 ;
wext->off_x = (int) (wext->bgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_BSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_BVAL) ;
break ;
case GAMMA_BSLIDER : wext->bgamma = (float) graf_slidebox(adr_gamma, GAMMA_BBAR, GAMMA_BSLIDER, 0) ;
wext->bgamma = wext->bgamma*2.0/1000.0 ;
if (wext->bgamma < 0.02) wext->bgamma = 0.02 ;
wext->off_x = (int) (wext->bgamma*(float)wext->wbar/2.0) ;
adr_gamma[GAMMA_BSLIDER].ob_x = wext->off_x ;
update_gammabox( wnd, GAMMA_BVAL) ;
break ;
case GAMMA_GROUP :
case GAMMA_TGROUP : inv_select(adr_gamma, GAMMA_GROUP) ;
break ;
case GAMMA_OK : code = IDOK ;
break ;
case GAMMA_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
}
return( code ) ;
}
/* button handling using XFORM_DO
*/
int
handle_button( int button, WORD *msg )
{
OBJECT *tree = (OBJECT *)rs_trindex[GENERAL];
int done = FALSE;
BOOLEAN click_flag = FALSE;
MRETS mk;
int ox, oy;
if( ( button != -1 ) && ( button & 0x8000 ) )
{
click_flag = TRUE;
button &= 0x7FFF;
}
switch( button )
{
case GSAVE: if( (*xcpb->XGen_Alert)( SAVE_DEFAULTS ) )
{
(*xcpb->CPX_Save)( &cur_value, sizeof( GEN ) );
push_data();
Set_Data();
}
XDeselect( tree, GSAVE );
break;
case GOK: done = TRUE;
Set_Data();
Deselect( GOK );
break;
case GCANCEL: done = TRUE;
pop_data();
Deselect( GCANCEL );
break;
case STATUS: graf_mkstate( &mk.x, &mk.y, &mk.buttons, &mk.kstate );
if( objc_find( tree, ROOT, MAX_DEPTH, mk.x, mk.y ) == STATUS )
do_status();
break;
case BELL: keybell_handle( BELLICON, &cur_value.bell );
break;
case KEYCLICK:keybell_handle( KEYICON, &cur_value.keyclick );
break;
case M0:
case M1:
case M2:
case M3:
case M4: Dclick_Select( button );
break;
case DOUBLE: Dclick_Handle( click_flag, button );
break;
case KREPEAT: (*xcpb->MFsave )( MFSAVE, &Other );
if( AES_Version >= 0x0320 )
graf_mouse( FLAT_HAND, 0L );
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XSelect( tree, KREPEAT );
graf_mkstate( &ox, &mk.y, &mk.buttons, &mk.kstate );
do
{
graf_mkstate( &mk.x, &mk.y, &mk.buttons, &mk.kstate );
}while( mk.buttons && ( mk.x == ox ));
if( mk.buttons && ( mk.x != ox ))
{
(*xcpb->Sl_dragx)( tree, REPTBASE, KREPEAT, KEYMIN,
KEYMAX, &cur_value.repeat,
KRepeat );
Set_Kbrate();
}
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XDeselect( tree, KREPEAT );
(*xcpb->MFsave)( MFRESTORE, &Other );
break;
case KRESPONS: (*xcpb->MFsave)( MFSAVE, &Other );
if( AES_Version >= 0x0320 )
graf_mouse( FLAT_HAND, 0L );
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XSelect( tree, KRESPONS );
graf_mkstate( &ox, &mk.y, &mk.buttons, &mk.kstate );
do
{
graf_mkstate( &mk.x, &mk.y, &mk.buttons, &mk.kstate );
}while( mk.buttons && ( mk.x == ox ));
if( mk.buttons && ( mk.x != ox ))
{
(*xcpb->Sl_dragx)( tree, RESPBASE, KRESPONS, KEYMIN,
KEYMAX, &cur_value.response,
KResponse );
Set_Kbrate();
}
if(( AES_Version >= 0x0330 )
&& ( numcol > LWHITE ) )
XDeselect( tree, KRESPONS );
(*xcpb->MFsave)( MFRESTORE, &Other );
break;
case RRESP: (*xcpb->Sl_arrow)( tree, RESPBASE, KRESPONS, RRESP,
1, KEYMIN, KEYMAX,
&cur_value.response, HORIZONTAL,
KResponse );
Set_Kbrate();
break;
case LRESP: (*xcpb->Sl_arrow)( tree, RESPBASE, KRESPONS, LRESP,
-1, KEYMIN, KEYMAX,
&cur_value.response, HORIZONTAL,
KResponse );
Set_Kbrate();
break;
case RREPEAT: (*xcpb->Sl_arrow)( tree, REPTBASE, KREPEAT, RREPEAT,
1, KEYMIN, KEYMAX,
&cur_value.repeat, HORIZONTAL,
KRepeat );
Set_Kbrate();
break;
case LREPEAT: (*xcpb->Sl_arrow)( tree, REPTBASE, KREPEAT, LREPEAT,
-1, KEYMIN, KEYMAX,
&cur_value.repeat, HORIZONTAL,
KRepeat );
Set_Kbrate();
break;
case REPTBASE: Graf_mkstate( &mk );
objc_offset( tree, KREPEAT, &ox, &oy );
oy = (( mk.x < ox ) ? ( -3 ) : ( 3 ) );
(*xcpb->Sl_arrow)( tree, REPTBASE, KREPEAT, -1,
oy, KEYMIN, KEYMAX,
&cur_value.repeat, HORIZONTAL,
KRepeat );
Set_Kbrate();
break;
case RESPBASE: Graf_mkstate( &mk );
objc_offset( tree, KRESPONS, &ox, &oy );
oy = (( mk.x < ox ) ? ( -3 ) : ( 3 ));
(*xcpb->Sl_arrow)( tree, RESPBASE, KRESPONS, -1,
oy, KEYMIN, KEYMAX,
&cur_value.response, HORIZONTAL,
KResponse );
Set_Kbrate();
break;
case BLK1BUTT: Do_Speed();
break;
case BLK2BUTT: Do_Block2();
default: if( button == -1 )
{
switch( msg[0] )
{
case WM_REDRAW: Redraw_Objects();
break;
case AC_CLOSE: done = TRUE;
pop_data();
break;
case WM_CLOSED: done = TRUE;
Set_Data();
break;
default:
break;
}
}
break;
}
return( done );
}
WORD insa_dial(LONG tree, WORD nicon, WORD numics)
{
WORD firstslot, nstate, ystate, i;
WORD touchob, oicon, value;
WORD mx, my, kret, bret, cont;
BYTE *pstr, doctype[4];
GRECT pt;
/* draw the form */
show_hide(FMD_START, tree);
/* init for while loop by forcing initial fs_newdir call */
cont = TRUE;
while ( cont )
{
firstslot = 6;
for (i = 0; i < firstslot; i++)
{
pstr = &doctype[0];
inf_sget(tree, APDFTYPE+i, pstr);
if (*pstr == '\0')
firstslot = i;
}
touchob = form_do((OBJECT FAR *)tree, APDFTYPE+firstslot);
graf_mkstate(&mx, &my, &kret, &bret);
value = nstate = ystate = 0;
touchob &= 0x7fff;
switch ( touchob )
{
case APINST:
case APREMV:
case APCNCL:
cont = FALSE;
break;
case APFUPARO:
value = -1;
break;
case APFDNARO:
value = 1;
break;
case APGEM:
nstate = SELECTED;
ystate = DISABLED;
break;
case APDOS:
case APPARMS:
nstate = LWGET(OB_STATE(APNMEM));
ystate = LWGET(OB_STATE(APYMEM));
if ( ystate == DISABLED )
{
nstate = SELECTED;
ystate = NORMAL;
}
break;
case APFSVSLI:
ob_actxywh(tree, APFSVELE, &pt);
pt.g_x -= 3;
pt.g_w += 6;
if ( rc_inside(&pt, mx, my) )
goto dofelev;
value = (my <= pt.g_y) ? -1 : 1;
break;
case APFSVELE:
dofelev: wind_update(3);
ob_relxywh(tree, APFSVSLI, &pt);
pt.g_x += 3;
pt.g_w -= 6;
LWSET(OB_X(APFSVSLI), pt.g_x);
LWSET(OB_WIDTH(APFSVSLI), pt.g_w);
value = graf_slidebox((OBJECT FAR *)tree, APFSVSLI, APFSVELE, TRUE);
pt.g_x -= 3;
pt.g_w += 6;
LWSET(OB_X(APFSVSLI), pt.g_x);
LWSET(OB_WIDTH(APFSVSLI), pt.g_w);
wind_update(2);
#if M68000
value = (WORD)((LONG)value * (LONG)(numics-1) / 1000) - nicon;
#else
value = mul_div(value, numics-1, 1000) - nicon;
#endif
break;
}
if (nstate != ystate)
{
LWSET(OB_STATE(APNMEM), nstate);
LWSET(OB_STATE(APYMEM), ystate);
draw_fld(tree, APMEMBOX);
}
if (value)
{
oicon = nicon;
nicon += value;
if (nicon < 0)
nicon = 0;
if (nicon >= numics)
nicon = numics - 1;
if (oicon != nicon)
{
insa_elev(tree, nicon, numics);
draw_fld(tree, APFTITLE);
draw_fld(tree, APFSVSLI);
draw_fld(tree, APFILEBO);
}
}
}
/* undraw the form */
show_hide(FMD_FINISH, tree);
return(nicon);
}
/* device_mover_button()
*==========================================================================
* Handles the button events for the CPX Mover/Rename Function
* IN: int obj: The RCS Object clicked on.
* OUT: BOOLEAN: TRUE - Exit the CPX Mover Config
* FALSE - Remain in the CPX Mover Config
*
*/
void
device_mover_button( int obj )
{
MRETS mk;
int ox,oy;
DEV_PTR curptr;
Old_Slit = Cur_Slit;
if( obj == Mup )
{
sl_arrow( tree, Mbase, Mslider, Mup, -1,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Device_Slit );
return;
}
if( obj == Mdown )
{
sl_arrow( tree, Mbase, Mslider, Mdown, 1,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Device_Slit );
return;
}
if( obj == Mslider )
{
MF_Save();
if( AES_Version >= 0x0320 )
graf_mouse( FLAT_HAND, 0L );
if(( AES_Version >= 0x0330 )
&& ( gl_ncolors > LWHITE ) )
XSelect( tree, Mslider );
graf_mkstate( ( int *)&mk.x, &oy, ( int *)&mk.buttons, (int *)&mk.kstate );
do
{
graf_mkstate( (int*)&mk.x, (int*)&mk.y, (int*)&mk.buttons, (int*)&mk.kstate );
}while( mk.buttons && ( mk.y == oy ));
if( mk.buttons && ( mk.y != oy ))
{
sl_dragy( tree, Mbase, Mslider,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, Draw_Device_Slit );
}
if(( AES_Version >= 0x0330 )
&& ( gl_ncolors > LWHITE ) )
XDeselect( tree, Mslider );
MF_Restore();
return;
}
if( obj == Mbase )
{
Graf_mkstate( &mk );
objc_offset( tree, Mslider, &ox, &oy );
ox = (( mk.y < oy ) ? ( -MAX_SLITS ) : ( MAX_SLITS ) );
sl_arrow( tree, Mbase, Mslider, -1, ox,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Device_Slit );
return;
}
if( ( obj >= DCOVER0 ) && ( obj <= DCOVER11 ))
{
if( !IsSelected( obj ) )
{
curptr = Device_Slit[ (( obj - 5 ) - DLINE0 ) / 6 ];
if( !curptr )
{
Undo_Dnodes( device_head, TRUE );
return;
}
Undo_Dnodes( device_head, FALSE );
DFLAG( curptr ) = TRUE;
Select( obj );
Objc_draw( tree, obj - 5, MAX_DEPTH, NULL );
if( IsDisabled( DMODIFY ) )
{
MakeExit( DMODIFY );
Enable( DMODIFY );
RedrawObject( tree, DMODIFY );
}
if( IsDisabled( DDELETE ) && ( DDEV( curptr ) > 9 ) )
{
Enable( DDELETE );
MakeExit( DDELETE );
RedrawObject( tree, DDELETE );
}
if( !IsDisabled( DDELETE ) && ( DDEV( curptr ) <= 9 ))
{
NoExit( DDELETE );
Disable( DDELETE );
RedrawObject( tree, DDELETE );
}
}
else
{
Undo_Dnodes( device_head, TRUE );
}
WaitForUpButton();
}
}
main()
{
int gr_mkmx, gr_mkmy;
int gr_mkmstate, gr_mkkstate;
int tmpx, tmpy;
int tmpx1, tmpy1;
int tmpx2, tmpy2;
int index, rgb_in[3];
int draw;
appl_init();
phys_handle = graf_handle(&gl_wchar, &gl_hchar, &gl_wbox, &gl_hbox);
wind_get(0, WF_WORKXYWH, &xdesk, &ydesk, &wdesk, &hdesk);
open_vwork();
wi_handle = wind_create(0x0040&0x0080, xdesk, ydesk, wdesk, hdesk);
graf_mouse(3, 0x0L);
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
tmpx = gr_mkmx;
tmpy = gr_mkmy;
vswr_mode(handle, 3);
v_enter_cur(handle);
v_exit_cur(handle);
graf_mouse(M_OFF, 0x0L);
drawicon(gr_mkmx,gr_mkmy);
graf_mouse(M_ON, 0x0L);
drawicon(gr_mkmx+65,gr_mkmy);
drawicon(gr_mkmx+65,gr_mkmy+65);
drawicon(gr_mkmx+130,gr_mkmy);
drawicon(gr_mkmx+130,gr_mkmy+130);
drawicon(gr_mkmx+195,gr_mkmy);
drawicon(gr_mkmx+195,gr_mkmy+195);
drawicon(gr_mkmx+260,gr_mkmy);
drawicon(gr_mkmx+260,gr_mkmy+260);
drawicon(gr_mkmx+325,gr_mkmy);
drawicon(gr_mkmx+325,gr_mkmy+325);
drawicon(gr_mkmx+390,gr_mkmy);
drawicon(gr_mkmx,gr_mkmy+65);
drawicon(gr_mkmx+130,gr_mkmy+65);
drawicon(gr_mkmx+195,gr_mkmy+65);
drawicon(gr_mkmx+260,gr_mkmy+65);
drawicon(gr_mkmx+325,gr_mkmy+65);
drawicon(gr_mkmx+390,gr_mkmy+65);
drawicon(gr_mkmx,gr_mkmy+130);
drawicon(gr_mkmx+65,gr_mkmy+130);
drawicon(gr_mkmx+195,gr_mkmy+130);
drawicon(gr_mkmx+260,gr_mkmy+130);
drawicon(gr_mkmx+325,gr_mkmy+130);
drawicon(gr_mkmx+390,gr_mkmy+130);
drawicon(gr_mkmx,gr_mkmy+195);
drawicon(gr_mkmx+65,gr_mkmy+195);
drawicon(gr_mkmx+130,gr_mkmy+195);
drawicon(gr_mkmx+260,gr_mkmy+195);
drawicon(gr_mkmx+325,gr_mkmy+195);
drawicon(gr_mkmx+390,gr_mkmy+195);
drawicon(gr_mkmx,gr_mkmy+260);
drawicon(gr_mkmx+65,gr_mkmy+260);
drawicon(gr_mkmx+130,gr_mkmy+260);
drawicon(gr_mkmx+195,gr_mkmy+260);
drawicon(gr_mkmx+325,gr_mkmy+260);
drawicon(gr_mkmx+390,gr_mkmy+260);
drawicon(gr_mkmx,gr_mkmy+325);
drawicon(gr_mkmx+65,gr_mkmy+325);
drawicon(gr_mkmx+130,gr_mkmy+325);
drawicon(gr_mkmx+195,gr_mkmy+325);
drawicon(gr_mkmx+260,gr_mkmy+325);
drawicon(gr_mkmx+390,gr_mkmy+325);
while(!(0x0002&gr_mkmstate)) {
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
tmpx1 = gr_mkmx;
tmpy1 = gr_mkmy;
tmpx2 = gr_mkmx;
tmpy2 = gr_mkmy;
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
while (((tmpx1 != gr_mkmx) || (tmpy1 != gr_mkmy)) &&
((abs(tmpx1, tmpx2) < 6) || (abs(tmpy1, tmpy2) < 6)) &&
(0x0001&gr_mkmstate)) {
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
tmpx1 = gr_mkmx;
tmpy1 = gr_mkmy;
graf_mkstate(&gr_mkmx, &gr_mkmy, &gr_mkmstate, &gr_mkkstate);
draw = 1;
}
if (draw) {
/*
v_enter_cur(handle);
graf_mouse(M_OFF, 0x0L);
graf_mouse(M_ON, 0x0L);
*/
v_exit_cur(handle);
drawicon(gr_mkmx,gr_mkmy);
drawicon(gr_mkmx+65,gr_mkmy);
drawicon(gr_mkmx+65,gr_mkmy+65);
drawicon(gr_mkmx+130,gr_mkmy);
drawicon(gr_mkmx+130,gr_mkmy+130);
drawicon(gr_mkmx+195,gr_mkmy);
drawicon(gr_mkmx+195,gr_mkmy+195);
drawicon(gr_mkmx+260,gr_mkmy);
drawicon(gr_mkmx+260,gr_mkmy+260);
drawicon(gr_mkmx+325,gr_mkmy);
drawicon(gr_mkmx+325,gr_mkmy+325);
drawicon(gr_mkmx+390,gr_mkmy);
drawicon(gr_mkmx,gr_mkmy+65);
drawicon(gr_mkmx+130,gr_mkmy+65);
drawicon(gr_mkmx+195,gr_mkmy+65);
drawicon(gr_mkmx+260,gr_mkmy+65);
drawicon(gr_mkmx+325,gr_mkmy+65);
drawicon(gr_mkmx+390,gr_mkmy+65);
drawicon(gr_mkmx,gr_mkmy+130);
drawicon(gr_mkmx+65,gr_mkmy+130);
drawicon(gr_mkmx+195,gr_mkmy+130);
drawicon(gr_mkmx+260,gr_mkmy+130);
drawicon(gr_mkmx+325,gr_mkmy+130);
drawicon(gr_mkmx+390,gr_mkmy+130);
drawicon(gr_mkmx,gr_mkmy+195);
drawicon(gr_mkmx+65,gr_mkmy+195);
drawicon(gr_mkmx+130,gr_mkmy+195);
drawicon(gr_mkmx+260,gr_mkmy+195);
drawicon(gr_mkmx+325,gr_mkmy+195);
drawicon(gr_mkmx+390,gr_mkmy+195);
drawicon(gr_mkmx,gr_mkmy+260);
drawicon(gr_mkmx+65,gr_mkmy+260);
drawicon(gr_mkmx+130,gr_mkmy+260);
drawicon(gr_mkmx+195,gr_mkmy+260);
drawicon(gr_mkmx+325,gr_mkmy+260);
drawicon(gr_mkmx+390,gr_mkmy+260);
drawicon(gr_mkmx,gr_mkmy+325);
drawicon(gr_mkmx+65,gr_mkmy+325);
drawicon(gr_mkmx+130,gr_mkmy+325);
drawicon(gr_mkmx+195,gr_mkmy+325);
drawicon(gr_mkmx+260,gr_mkmy+325);
drawicon(gr_mkmx+390,gr_mkmy+325);
draw = 0;
}
}
wind_delete(wi_handle);
v_clsvwk(handle);
appl_exit();
}
/* ***PopUp darstellen*** */
short wdial_popup(OBJECT *ptree, short *pitem, short popupx, short popupy, void (*msghndlr)(int msgbf[]), unsigned long msec, void (*tmrhndlr)())
{
int mpopupret, pwhndl;
int dx, dy, dw, dh;
int newitem=-1, olditem=-1;
int msgbuf[8]; int which;
int mx, my, mb, br;
wind_get(0, WF_WORKXYWH, &dx, &dy, &dw, &dh); /* Desktopgr��e */
if(popupx+ptree->ob_width > dx+dw)
popupx=dx+dw-ptree->ob_width;
if(popupx<dx) popupx=dx;
ptree->ob_x=popupx;
if(*pitem > 0) popupy-=ptree[*pitem].ob_y;
if(popupy+ptree->ob_height > dy+dh)
popupy=dy+dh-ptree->ob_height;
if(popupy<dy) popupy=dy;
ptree->ob_y=popupy;
wind_calc(WC_BORDER, 0, ptree->ob_x, ptree->ob_y,
ptree->ob_width, ptree->ob_height, &dx, &dy, &dw, &dh);
pwhndl=wind_create(0, dx, dy, dw, dh); /* Fenster anmelden */
if(pwhndl<0) return(FALSE);
wind_open(pwhndl, dx, dy, dw, dh); /* Fenster �ffnen */
/*objc_draw(ptree, 0, 1, dx, dy, dw, dh); ->Durch WM_REDRAW zeichnen lassen*/
do graf_mkstate(&mx, &my, &mb, &dx); while(mb); /* Maustasten vorher loslassen */
do
{
which=evnt_multi(MU_MESAG|MU_BUTTON|MU_TIMER, 1,1,1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
msgbuf, (short)msec,(short)(msec>>16), &mx, &my, &mb,
&dx, &dx, &br);
if(which&MU_MESAG)
{
if(msgbuf[3]==pwhndl && msgbuf[0]>=WM_REDRAW && msgbuf[0]<=WM_NEWTOP)
{
switch(msgbuf[0])
{
case WM_REDRAW:
wdial_redraw(pwhndl, ptree, (GRECT *)(&msgbuf[4]));
break;
case WM_TOPPED:
wind_set(pwhndl, WF_TOP, 0L, 0L);
break;
}
}
else if( msghndlr ) msghndlr(msgbuf);
}
if(which&MU_TIMER)
{
newitem=objc_find(ptree, 0, 1, mx, my);
if(newitem>0 && newitem!=olditem)
{
if( (ptree[newitem].ob_flags&TOUCHEXIT) && !(ptree[newitem].ob_state&DISABLED) )
{
GRECT prct;
ptree[olditem].ob_state&=~SELECTED;
ptree[newitem].ob_state|=SELECTED;
prct.g_x=ptree->ob_x+ptree[olditem].ob_x;
prct.g_y=ptree->ob_y+ptree[olditem].ob_y;
prct.g_w=ptree[olditem].ob_width; prct.g_h=ptree[olditem].ob_height;
wdial_redraw(pwhndl, ptree, &prct);
prct.g_x=ptree->ob_x+ptree[newitem].ob_x;
prct.g_y=ptree->ob_y+ptree[newitem].ob_y;
prct.g_w=ptree[newitem].ob_width; prct.g_h=ptree[newitem].ob_height;
wdial_redraw(pwhndl, ptree, &prct);
olditem=newitem;
}
else
newitem=olditem;
}
else
newitem=olditem;
if( tmrhndlr ) tmrhndlr();
}
}
while(mb!=1); /* Bis Maustaste gedr�ckt */
newitem=objc_find(ptree, 0, 1, mx, my);
if(newitem>0 && (ptree[newitem].ob_flags&TOUCHEXIT) && !(ptree[newitem].ob_state&DISABLED) )
{ *pitem=newitem; mpopupret=TRUE; }
else { mpopupret=FALSE; }
if(olditem>0) ptree[olditem].ob_state&=~SELECTED;
wind_close(pwhndl); wind_delete(pwhndl); /* Fenster schliessen */
return(mpopupret);
}
/* mover_button()
*==========================================================================
* Handles the button events for the CPX Mover/Rename Function
* IN: int obj: The RCS Object clicked on.
* OUT: BOOLEAN: TRUE - Exit the CPX Mover Config
* FALSE - Remain in the CPX Mover Config
*
*/
void
mover_button( int obj )
{
MRETS mk;
int ox,oy;
HDEVICE_PTR curptr;
DEV_PTR temp_device;
Old_Slit = Cur_Slit;
if( obj == Mup )
{
sl_arrow( tree, Mbase, Mslider, Mup, -1,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Slit );
return;
}
if( obj == Mdown )
{
sl_arrow( tree, Mbase, Mslider, Mdown, 1,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Slit );
return;
}
if( obj == Mslider )
{
MF_Save();
if( AES_Version >= 0x0320 )
graf_mouse( FLAT_HAND, 0L );
if(( AES_Version >= 0x0330 )
&& ( gl_ncolors > LWHITE ) )
XSelect( tree, Mslider );
graf_mkstate( ( int *)&mk.x, &oy, (int *)&mk.buttons, ( int *)&mk.kstate );
do
{
graf_mkstate( (int *)&mk.x, (int *)&mk.y, (int *)&mk.buttons, ( int *)&mk.kstate );
}while( mk.buttons && ( mk.y == oy ));
if( mk.buttons && ( mk.y != oy ))
{
sl_dragy( tree, Mbase, Mslider,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, Draw_Slit );
}
if(( AES_Version >= 0x0330 )
&& ( gl_ncolors > LWHITE ) )
XDeselect( tree, Mslider );
MF_Restore();
return;
}
if( obj == Mbase )
{
Graf_mkstate( &mk );
objc_offset( tree, Mslider, &ox, &oy );
ox = (( mk.y < oy ) ? ( -MAX_SLITS ) : ( MAX_SLITS ) );
sl_arrow( tree, Mbase, Mslider, -1, ox,
max( Total - MAX_SLITS, 0 ), 0,
&Cur_Slit, VERTICAL, Draw_Slit );
return;
}
if(( obj >= Obj_Beg ) && ( obj <= Obj_End ))
{
if( !IsSelected( obj ) )
{
curptr = Active_Slit[ obj - First_Obj ];
if( !curptr )
return;
/* SetChangeFlag();*/
Undo_Fnodes( hdriver_head );
HFLAG( curptr ) = TRUE;
XSelect( tree, obj );
cur_cdriver = HNAME( curptr );
strcpy( driver_text, cdrivers[ HNAME( curptr )] );
TedText( FPRINTER ) = &driver_text[0];
Objc_draw( tree, FPRINTER, MAX_DEPTH, NULL );
temp_device = find_device( 21 ); /* find the printer device */
if( !temp_device )
{
/* Add the Device if necessary */
temp_device = AddNewDevice( 21 );
if( temp_device )
{
/* found a slot and added it to the device linked list array. */
DNAME( temp_device ) = cdriver_array[ cur_cdriver ];
}
}
else
/* Else, just change the device name */
DNAME( temp_device ) = cdriver_array[ cur_cdriver ];
if( IsDisabled( FREMOVE ) )
ChangeButton( tree, FREMOVE, TRUE );
if( strstr( cdrivers[ cur_cdriver ], NonSpeedo ) )
{
if( !IsDisabled( FCONFIG ) )
ChangeButton( tree, FCONFIG, FALSE );
}
else
{
if( IsDisabled( FCONFIG ) )
ChangeButton( tree, FCONFIG, TRUE );
}
/* WRITE THE ASSIGN.SYS IMMEDIATELY */
write_assign();
}
}
}
void GEM_PumpEvents(_THIS)
{
short mousex, mousey, mouseb, dummy;
short kstate, prevkc, prevks;
int i;
SDL_keysym keysym;
memset(gem_currentkeyboard,0,sizeof(gem_currentkeyboard));
prevkc = prevks = 0;
for (;;)
{
int quit, resultat;
short buffer[8], kc;
quit = 0;
resultat = evnt_multi(
MU_MESAG|MU_TIMER|MU_KEYBD,
0,0,0,
0,0,0,0,0,
0,0,0,0,0,
buffer,
10,
&dummy,&dummy,&dummy,&kstate,&kc,&dummy
);
/* Message event ? */
if (resultat & MU_MESAG)
quit = do_messages(this, buffer);
/* Keyboard event ? */
if (resultat & MU_KEYBD) {
if ((prevkc != kc) || (prevks != kstate)) {
do_keyboard(kc,kstate);
} else {
/* Avoid looping, if repeating same key */
break;
}
}
/* Timer event ? */
if ((resultat & MU_TIMER) || quit)
break;
}
/* Update mouse */
graf_mkstate(&mousex, &mousey, &mouseb, &kstate);
do_mouse(this, mousex, mousey, mouseb, kstate);
/* Now generate keyboard events */
for (i=0; i<ATARIBIOS_MAXKEYS; i++) {
/* Key pressed ? */
if (gem_currentkeyboard[i] && !gem_previouskeyboard[i])
SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(i, gem_currentascii[i], &keysym));
/* Key unpressed ? */
if (gem_previouskeyboard[i] && !gem_currentkeyboard[i])
SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(i, gem_currentascii[i], &keysym));
}
memcpy(gem_previouskeyboard,gem_currentkeyboard,sizeof(gem_previouskeyboard));
}
/*----------------------------------------------------------------------------------------*/
void sld_lscroll( SLD *sld )
{
OBJECT *tree = sld->wd->tree;
EVNTDATA ev;
GRECT rect1;
GRECT rect2;
GRECT rect3;
int16 newy = 0;
int16 oldy = 0;
int16 mmin, mmax;
graf_mkstate( &ev );
newy = oldy = ev.y;
objc_rect( tree, sld->white, &rect1 );
objc_rect( tree, sld->back, &rect2 );
mmin = oldy - tree[sld->white].ob_y;
mmax = oldy + (tree[sld->back].ob_height - tree[sld->white].ob_y - tree[sld->white].ob_height);
graf_mouse( FLAT_HAND, NULL );
do
{
objc_rect( tree, sld->white, &rect2 );
tree[sld->white].ob_y += ( newy-oldy );
objc_rect( tree, sld->white, &rect1 );
rect3.g_x = rect1.g_x;
rect3.g_y = min( rect1.g_y, rect2.g_y );
rect3.g_w = rect1.g_w;
rect3.g_h = (( (newy-oldy) < 0 ) ? -(newy-oldy) : (newy-oldy) ) + rect1.g_h;
if(newy-oldy != 0)
{
hide_mouse();
if( gl_naes )
{
rect3.g_x-=2;
rect3.g_y-=2;
rect3.g_w+=4;
rect3.g_h+=4;
}
objc_draw( tree, sld->back, MAX_DEPTH, &rect3 );
sld->pos_old = sld->pos_new = sld_getpos(sld);
if( sld->scroll )
sld->scroll( sld->wd, SCROLL_LIVE, sld->pos_new );
show_mouse();
}
graf_mkstate( &ev );
oldy = newy;
newy = min( mmax, ev.y );
newy = max( mmin, newy );
evnt_timer(20);
} while ( ev.bstate & 0x01 );
graf_mouse( ARROW, NULL );
}
void gui_poll(bool active)
{
struct gui_window *tmp;
short mx, my, dummy;
unsigned short nkc = 0;
aes_event_in.emi_tlow = schedule_run();
if(active || rendering)
aes_event_in.emi_tlow = 0;
if(aes_event_in.emi_tlow < 0) {
aes_event_in.emi_tlow = 10000;
printf("long poll!\n");
}
struct gui_window * g;
if( !active ) {
if(input_window && input_window->root->redraw_slots.areas_used > 0) {
window_process_redraws(input_window->root);
}
}
graf_mkstate(&mx, &my, &dummy, &dummy);
aes_event_in.emi_m1.g_x = mx;
aes_event_in.emi_m1.g_y = my;
evnt_multi_fast(&aes_event_in, aes_msg_out, &aes_event_out);
if(!gemtk_wm_dispatch_event(&aes_event_in, &aes_event_out, aes_msg_out)) {
if( (aes_event_out.emo_events & MU_MESAG) != 0 ) {
LOG(("WM: %d\n", aes_msg_out[0]));
switch(aes_msg_out[0]) {
case MN_SELECTED:
LOG(("Menu Item: %d\n",aes_msg_out[4]));
deskmenu_dispatch_item(aes_msg_out[3], aes_msg_out[4]);
break;
default:
break;
}
}
if((aes_event_out.emo_events & MU_KEYBD) != 0) {
uint16_t nkc = gem_to_norm( (short)aes_event_out.emo_kmeta,
(short)aes_event_out.emo_kreturn);
deskmenu_dispatch_keypress(aes_event_out.emo_kreturn,
aes_event_out.emo_kmeta, nkc);
}
}
tmp = window_list;
while(tmp){
if(tmp->root->redraw_slots.areas_used > 0){
window_process_redraws(tmp->root);
}
tmp = tmp->next;
}
if(hl.tv->redraw){
atari_treeview_redraw(hl.tv);
}
if(gl_history.tv->redraw){
atari_treeview_redraw(gl_history.tv);
}
}
/*----------------------------------------------------------------------------------------*/
int16 icn_popup( int16 ptree, int16 obj, int16 x_off, int16 y_off )
{
OBJECT *tree;
GRECT rect, desk, rect1, rect2;
GRECT kl_rect = {0,0,0,0};
int16 item, founditem, olditem;
int16 first_child, last_child;
int16 event, ret;
UWORD uret;
int16 bclicks, bmask, bstate;
BOOL leave, found;
EVNTDATA ev;
rsrc_gaddr(R_TREE, ptree, &tree);
first_child = (tree[obj].ob_head);
last_child = (tree[obj].ob_tail);
olditem = -1;
while(last_child != -1)
{
olditem = last_child;
last_child = (tree[last_child].ob_tail);
}
last_child = olditem;
tree[R_TREE].ob_x = 0; /* Anpassen des Parent-Objekts */
tree[R_TREE].ob_y = 0;
tree[obj].ob_x = x_off; /* Anpassen der Popup-Box */
tree[obj].ob_y = y_off;
wind_get(0,WF_WORKXYWH, &desk.g_x, &desk.g_y, &desk.g_w, &desk.g_h);
/* Das POPUP darf nicht ausserhalb des Bildschirms erscheinen) */
if( (tree[obj].ob_x + tree[obj].ob_width) > (desk.g_x + desk.g_w) )
tree[obj].ob_x = (desk.g_x + desk.g_w - tree[obj].ob_width);
if( (tree[obj].ob_y + tree[obj].ob_height) > (desk.g_y + desk.g_h) )
tree[obj].ob_y = (desk.g_y + desk.g_h - tree[obj].ob_height);
if(tree[obj].ob_x < 0) tree[obj].ob_x = desk.g_x;
if(tree[obj].ob_y < 0) tree[obj].ob_y = desk.g_y;
rect.g_x = tree[obj].ob_x - 8;
rect.g_y = tree[obj].ob_y - 8;
rect.g_w = tree[obj].ob_width + 16;
rect.g_h = tree[obj].ob_height + 16;
form_dial(FMD_START, &kl_rect, &rect);
graf_mkstate( &ev );
olditem = NIL;
founditem = item = objc_find(tree, obj, 1, ev.x, ev.y); /* In Men� ? */
if (item != NIL)
if ((tree[item].ob_state & DISABLED) || !(tree[item].ob_flags & SELECTABLE))
item = NIL;
if (item != NIL) tree[item].ob_state |= SELECTED;
objc_draw(tree, obj, MAX_DEPTH, &rect);
wind_update(BEG_MCTRL); /* Ich will die Kontrolle */
do
{
if (founditem != NIL) /* In Men�eintrag */
{
leave = TRUE;
objc_rect (tree, founditem, &rect1);
}
else /* Au�erhalb Pop-Up-Men� */
{
leave = FALSE;
objc_rect (tree, obj, &rect1);
}
graf_mkstate( &ev );
if( !((ev.bstate) & 3) )
bclicks = 258;
else
bclicks = 0;
bmask = 3;
bstate = 0;
event = evnt_multi ( MU_KEYBD | MU_BUTTON | MU_M1,
bclicks, bmask, bstate,
leave, &rect1, 0, &kl_rect,
NULL, 0, &ev, (int16 *)&uret, (int16 *)&ret);
olditem = item;
if(!(event & MU_KEYBD))
{
founditem = item = objc_find (tree, obj, 1, ev.x, ev.y);
if (item != NIL)
{
if ((tree[item].ob_state & DISABLED) || !(tree[item].ob_flags & SELECTABLE))
item = NIL;
}
}
else
{
if((uret >> 8) == 80) /* Pfeil runter */
{
found = FALSE;
while(!found)
{
item++;
if((item < first_child) || (item > last_child))
{
item = first_child;
}
if ((tree[item].ob_flags & SELECTABLE))
{
if( tree[item].ob_state & DISABLED )
found = FALSE;
else
found = TRUE;
}
}
}
if((uret >> 8) == 72) /* Pfeil rauf */
{
found = FALSE;
while(!found)
{
item--;
if((item < first_child) || (item > last_child))
{
item = last_child;
}
if ((tree[item].ob_flags & SELECTABLE))
{
if( tree[item].ob_state & DISABLED )
found = FALSE;
else
found = TRUE;
}
}
}
if(((uret >> 8) == 28)||((uret >> 8) == 114)) /* Enter/Return */
event = MU_BUTTON;
if(((uret >> 8) == 01)||((uret >> 8) == 97)) /* Esc/UNDO */
{
item = NIL;
event = MU_BUTTON;
}
}
if (olditem != item)
{
if (olditem != NIL)
{
if(tree[olditem].ob_state & SELECTED)
tree[olditem].ob_state &= ~SELECTED;
else
tree[olditem].ob_state |= SELECTED;
objc_rect(tree, olditem, &rect2);
objc_draw(tree, obj, MAX_DEPTH, &rect2);
}
if (item != NIL)
{
if(tree[item].ob_state & SELECTED)
tree[item].ob_state &= ~SELECTED;
else
tree[item].ob_state |= SELECTED;
objc_rect(tree, item, &rect2);
objc_draw(tree, obj, MAX_DEPTH, &rect2);
}
}
} while (! (event & MU_BUTTON));
wind_update(END_MCTRL);
form_dial(FMD_FINISH, &kl_rect, &rect);
if (item != NIL) tree[item].ob_state &= ~SELECTED;
graf_mkstate( &ev );
bclicks = 0;
if (~ev.bstate & bmask)
evnt_button (bclicks, bmask, 0x00, &ev); /* Warte auf Mausknopf */
return(item);
}
static void __CDECL browser_evnt_mbutton( COMPONENT * c, long buff[8], void * data)
{
short mx, my, dummy, mbut;
LGRECT cwork;
browser_mouse_state bmstate = 0;
struct gui_window * gw = data;
if( input_window != gw ){
input_window = gw;
}
window_set_focus( gw, BROWSER, (void*)gw->browser );
browser_get_rect( gw, BR_CONTENT, &cwork );
/* convert screen coords to component coords: */
mx = evnt.mx - cwork.g_x;
my = evnt.my - cwork.g_y;
/* Translate GEM key state to netsurf mouse modifier */
if( evnt.mkstate & (K_RSHIFT | K_LSHIFT) ){
bmstate |= BROWSER_MOUSE_MOD_1;
} else {
bmstate &= ~(BROWSER_MOUSE_MOD_1);
}
if( (evnt.mkstate & K_CTRL) ){
bmstate |= BROWSER_MOUSE_MOD_2;
} else {
bmstate &= ~(BROWSER_MOUSE_MOD_2);
}
if( (evnt.mkstate & K_ALT) ){
bmstate |= BROWSER_MOUSE_MOD_3;
} else {
bmstate &= ~(BROWSER_MOUSE_MOD_3);
}
/* convert component coords to scrolled content coords: */
int sx_origin = (mx + gw->browser->scroll.current.x);
int sy_origin = (my + gw->browser->scroll.current.y);
short rel_cur_x, rel_cur_y;
short prev_x=sx_origin, prev_y=sy_origin;
bool dragmode = 0;
/* Detect left mouse button state and compare with event state: */
graf_mkstate(&rel_cur_x, &rel_cur_y, &mbut, &dummy);
if( (mbut & 1) && (evnt.mbut & 1) ){
/* Mouse still pressed, report drag */
rel_cur_x = (rel_cur_x - cwork.g_x) + gw->browser->scroll.current.x;
rel_cur_y = (rel_cur_y - cwork.g_y) + gw->browser->scroll.current.y;
browser_window_mouse_click( gw->browser->bw,
BROWSER_MOUSE_DRAG_ON|BROWSER_MOUSE_DRAG_1,
sx_origin, sy_origin);
do{
if( abs(prev_x-rel_cur_x) > 5 || abs(prev_y-rel_cur_y) > 5 ){
browser_window_mouse_track( gw->browser->bw,
BROWSER_MOUSE_DRAG_ON|BROWSER_MOUSE_DRAG_1,
rel_cur_x, rel_cur_y);
prev_x = rel_cur_x;
prev_y = rel_cur_y;
dragmode = true;
} else {
if( dragmode == false ){
browser_window_mouse_track( gw->browser->bw,BROWSER_MOUSE_PRESS_1,
rel_cur_x, rel_cur_y);
}
}
if( browser_redraw_required( gw ) ){
browser_redraw( gw );
}
graf_mkstate(&rel_cur_x, &rel_cur_y, &mbut, &dummy);
rel_cur_x = (rel_cur_x - cwork.g_x) + gw->browser->scroll.current.x;
rel_cur_y = (rel_cur_y - cwork.g_y) + gw->browser->scroll.current.y;
} while( mbut & 1 );
browser_window_mouse_track(gw->browser->bw, 0, rel_cur_x,rel_cur_y);
} else {
/* Right button pressed? */
if( (evnt.mbut & 2 ) ) {
context_popup( gw, evnt.mx, evnt.my );
} else {
browser_window_mouse_click(gw->browser->bw,
bmstate|BROWSER_MOUSE_PRESS_1,
sx_origin,sy_origin);
browser_window_mouse_click(gw->browser->bw,
bmstate|BROWSER_MOUSE_CLICK_1,
sx_origin,sy_origin);
}
}
}
int OnObjectNotifyAlb(void *w, int obj)
{
GEM_WINDOW *wprog ;
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_ALBUM *wext = wnd->DlgData->UserData ;
OBJECT *adr_album = wnd->DlgData->BaseObject ;
float pc ;
int i, y, clicked, bs, err, code = -1 ;
int mx, my, dummy ;
int valid, must_crash = 0 ;
char *c, *n ;
char buf[PATH_MAX] ;
char vss_name[PATH_MAX] ;
char is_registered = IsRegistered ;
bs = obj ;
obj &= 32767 ;
if ( !(adr_album[obj].ob_state & DISABLED) && obj )
{
read_text(adr_album, ALBUM_COMMENT, buf) ;
if ( strcmp(buf, wext->img_comment ) )
{
catalog_setimgcomment( wext->last_num, buf ) ;
strcpy( wext->img_comment, buf ) ;
}
}
switch( obj )
{
case ALBUM_INFOS : show_infos( wext->categorie ) ;
deselect( adr_album, obj ) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
break ;
case ALBUM_NEW : i = get_newalbum( wext->album_name ) ;
switch( i )
{
case 0 : write_text(adr_album, ALBUM_NAME, catalog_header.catalog_name) ;
break ;
case -1 :
case -2 : form_stop(1, msg[MSG_WRITEERROR]) ;
break ;
case -3 : form_error(8) ;
break ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
if ( wext->album_name[0] == 0 )
{
wext->first = 0 ;
adr_album[ALBUM_REMOVE].ob_state |= DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state |= DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state |= DISABLED ;
adr_album[ALBUM_INFOS].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state |= DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state |= DISABLED ;
adr_album[ALBUM_CONFIG].ob_state |= DISABLED ;
adr_album[ALBUM_UPDATE].ob_state |= DISABLED ;
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
adr_album[ALBUM_TOVSS].ob_state |= DISABLED ;
}
else
{
adr_album[ALBUM_REMOVE].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOS].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_CONFIG].ob_state &= ~DISABLED ;
adr_album[ALBUM_UPDATE].ob_state &= ~DISABLED ;
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
adr_album[ALBUM_TOVSS].ob_state &= ~DISABLED ;
}
if (i == 0)
{
wext->first = 0 ;
wext->last_num = -1 ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++) deselect(adr_album, i) ;
select(adr_album, ALBUM_ITEM1) ;
make_category_popup( wnd ) ;
update_list( wnd, 1 ) ;
load_icon( wnd, wext->first ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
}
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_OPEN : strcpy(buf, config.path_album) ;
strcat(buf, "\\*.VIC") ;
if ( file_name(buf, "", buf) )
{
c = strrchr(buf, '\\') ;
c++ ;
n = wext->nom ;
while ((*c != 0) && (*c != '.')) *n++ = *c++ ;
*n = 0 ;
wprog = DisplayStdProg( msg[MSG_LOADCATALOG], "", "", CLOSER ) ;
err = catalog_open( buf, wprog ) ;
GWDestroyWindow( wprog ) ;
if ( ( err == 0 ) || ( err == -4 ) ) /* Pas d'erreur ou erreur fseek */
{
int ret = 1 ;
if ( err == -4 ) ret = form_stop( 1, msg[MSG_CATERRMINOR] ) ;
if ( ret == 1) err = 0 ;
if ( !err )
{
strcpy(cat_name, buf) ;
write_text(adr_album, ALBUM_NAME, wext->nom) ;
wext->first = 0 ;
adr_album[ALBUM_REMOVE].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOS].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_CONFIG].ob_state &= ~DISABLED ;
adr_album[ALBUM_UPDATE].ob_state &= ~DISABLED ;
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
adr_album[ALBUM_TOVSS].ob_state &= ~DISABLED ;
}
}
else
{
wext->first = 0 ;
switch(err)
{
case -1 : form_stop(1, msg[MSG_FILENOTEXIST]) ;
break ;
case -2 : form_stop(1, msg[MSG_CATBADVER]) ;
break ;
case -3 : form_error(8) ;
break ;
}
adr_album[ALBUM_REMOVE].ob_state |= DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state |= DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state |= DISABLED ;
adr_album[ALBUM_INFOS].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state |= DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state |= DISABLED ;
adr_album[ALBUM_CONFIG].ob_state |= DISABLED ;
adr_album[ALBUM_UPDATE].ob_state |= DISABLED ;
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
adr_album[ALBUM_TOVSS].ob_state |= DISABLED ;
}
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
wext->first = 0 ;
wext->last_num = -1 ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++) deselect(adr_album, i) ;
if ( !err )
{
select(adr_album, ALBUM_ITEM1) ;
update_list( wnd, 1 ) ;
make_category_popup( wnd ) ;
load_icon( wnd, wext->first ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
}
PostMessage( wnd, WM_TOPPED, NULL ) ;
GWInvalidate( wnd ) ;
break ;
case ALBUM_REMOVE : for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
{
err = catalog_remove(wext->first+i-ALBUM_ITEM1) ;
inv_select(adr_album, obj) ;
wext->first-- ;
if (wext->first < 0) wext->first = 0 ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
}
break ;
case ALBUM_ADDIMG : strcpy(buf, config.path_img) ;
strcat(buf, "\\*.*") ;
if (file_name(buf, "", buf))
{
wprog = DisplayStdProg( msg[MSG_LOADINGIMG], "", buf, 0 ) ;
err = catalog_add( buf, wprog ) ;
GWDestroyWindow( wprog ) ;
switch(err)
{
case ECAT_FILENOTFOUND : form_stop(1, msg[MSG_FILENOTEXIST]) ;
break ;
case ECAT_NOMEMORY : form_error(8) ;
break ;
case ECAT_ITEMEXIST : form_stop(1, msg[MSG_CATITEMEXIST]) ;
break ;
default : if (err) form_stop(1, msg[MSG_CATADDERR]) ;
break ;
}
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_ADDFOLDER : if ( is_registered )
{
long original_key = KeyDecrypt( ident.crypted_key ) ;
long second_key = KeyDecrypt( ident.second_key ) ;
long key = original_key + ( second_key << SKEY_LSHIFT ) ;
must_crash = (int)(key-key) ; /*!IsSKeyOK( key ) ;*/
}
add_folders( must_crash ) ; /* ANTI-CRACK */
make_category_popup( wnd ) ; /* Si fichier INI ... */
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_ITEM1 :
case ALBUM_ITEM2 :
case ALBUM_ITEM3 :
case ALBUM_ITEM4 :
case ALBUM_ITEM5 :
case ALBUM_ITEM6 :
case ALBUM_ITEM7 :
case ALBUM_ITEM8 :
case ALBUM_ITEM9 :
case ALBUM_ITEM10 : read_text( adr_album, obj, buf ) ;
if ( buf[0] )
{
if ( bs > 0 )
{
load_icon( wnd, wext->first+obj-ALBUM_ITEM1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
}
else
{
catalog_getfullname(wext->first+obj-ALBUM_ITEM1, buf) ;
config.color_protect = wext->cconfig ;
load_wpicture( buf, 0 ) ;
config.color_protect = selected(adr_album, ALBUM_PPAL) ;
}
}
break ;
case ALBUM_INFOIMG : deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
show_imginfo(wext->first+i-ALBUM_ITEM1, wext->img_comment) ;
break ;
case ALBUM_IMAGE : deselect(adr_album, obj) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
{
catalog_getfullname(wext->first+i-ALBUM_ITEM1, buf) ;
config.color_protect = wext->cconfig ;
load_wpicture( buf, 0 ) ;
config.color_protect = selected(adr_album, ALBUM_PPAL) ;
}
break ;
case ALBUM_MOINS : if (wext->first > 0)
{
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != ALBUM_ITEM10)
{
deselect(adr_album, i) ;
select(adr_album, i+1) ;
}
wext->first-- ;
update_list( wnd, 1 ) ;
}
break ;
case ALBUM_PLUS : if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 < catalog_filter.nb_visibles)
{
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != ALBUM_ITEM1)
{
deselect(adr_album, i) ;
select(adr_album, i-1) ;
}
wext->first++ ;
update_list( wnd, 1 ) ;
}
break ;
case ALBUM_BOX : graf_mkstate(&mx, &my, &dummy, &dummy) ;
objc_offset(adr_album, ALBUM_SLIDER, &dummy, &mx) ;
if (my > mx) wext->first += 1+ALBUM_ITEM10-ALBUM_ITEM1 ;
else wext->first -= 1+ALBUM_ITEM10-ALBUM_ITEM1 ;
if (wext->first < 0) wext->first = 0 ;
if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 > catalog_filter.nb_visibles)
wext->first = (int) (catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1) ;
update_list( wnd, 1 ) ;
break ;
case ALBUM_SLIDER : pc = (float) graf_slidebox(adr_album, ALBUM_BOX, ALBUM_SLIDER, 1) ;
pc = (1000.0-pc)/10.0 ;
y = (int) ((100.0-pc)*(float)wext->hf/100.0) ;
adr_album[ALBUM_SLIDER].ob_y = y ;
wext->first = (int) ((float)y*(float)(catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1)/wext->hf) ;
if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 > catalog_filter.nb_visibles)
wext->first = (int) (catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1) ;
if (wext->first < 0) wext->first = 0 ;
update_list( wnd, 1 ) ;
break ;
case ALBUM_PTPAL : inv_select( adr_album, ALBUM_PPAL ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_PPAL ) ;
case ALBUM_PPAL : config.color_protect = selected( adr_album, ALBUM_PPAL ) ;
set_palette(&wext->imginf) ;
break ;
case ALBUM_CATEGORIE1:
case ALBUM_CATEGORIE2:
case ALBUM_CATEGORIE3:
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if ((tab_index == NULL) || (i == 1+ALBUM_ITEM10)) break ;
deselect(adr_album, obj) ;
objc_offset(adr_album, obj, &mx, &my) ;
switch(obj)
{
case ALBUM_CATEGORIE1 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_1, -1 ) ;
break ;
case ALBUM_CATEGORIE2 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_2, -1 ) ;
break ;
case ALBUM_CATEGORIE3 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_3, -1 ) ;
break ;
}
if (clicked > 1)
{
sprintf(buf, " %s", catalog_header.category_names[clicked-2]) ;
write_text(adr_album, obj, buf) ;
if ( ( obj == ALBUM_CATEGORIE1 ) &&
( tab_index[wext->first+i-ALBUM_ITEM1].category_1 == tab_index[wext->first+i-ALBUM_ITEM1].category_2 ) &&
( tab_index[wext->first+i-ALBUM_ITEM1].category_2 == tab_index[wext->first+i-ALBUM_ITEM1].category_3 )
)
{
int j ;
for (j = 1; j <= 3 ; j++ )
catalog_setcategory( wext->first+i-ALBUM_ITEM1, clicked-2, j ) ;
}
else
catalog_setcategory(wext->first+i-ALBUM_ITEM1, clicked-2, 1+obj-ALBUM_CATEGORIE1) ;
}
else if (clicked == 1)
{
int index_category ;
char buffer[80] ;
lstd_input( msg[MSG_CATENEW], buffer ) ;
if (buffer[0])
{
index_category = catalog_addcategory(buffer) ;
make_category_popup( wnd ) ;
sprintf(buf, " %s", buffer) ;
write_text(adr_album, obj, buf) ;
catalog_setcategory(wext->first+i-ALBUM_ITEM1, index_category, 1+obj-ALBUM_CATEGORIE1) ;
}
}
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
break ;
case ALBUM_CONFIG : if (album_config() == 1)
{
mouse_busy() ;
sort_index() ;
wext->first = 0 ;
mouse_restore() ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
if (catalog_filter.nb_visibles <= 0)
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
else
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_WINDOW ) ;
break ;
case ALBUM_UPDATE : catalog_update( msg[MSG_UPDATECAT] ) ;
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
break ;
case ALBUM_WINDOW : if ( WndAlbum == NULL ) album_window() ;
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
break ;
case ALBUM_TOVSS : sprintf( vss_name, "%s\\*.VSS", config.path_album ) ;
valid = file_name(vss_name, "", vss_name) ;
if ( valid )
{
GEM_WINDOW *wprog ;
FILE *stream ;
long num ;
int r ;
char full_name[200] ;
char buf[50] ;
if ( FileExist( vss_name ) )
r = form_interrogation(2, msg[MSG_FILEEXISTS]) ;
if ( r == 2 ) break ;
stream = fopen( vss_name, "wb" ) ;
if ( stream == NULL )
{
form_stop(1,msg[MSG_WRITEERROR]) ;
break ;
}
wprog = DisplayStdProg( msg[MSG_SAVEVSS], "", "", CLOSER ) ;
for ( num = 0; num < catalog_filter.nb_visibles ; num++ )
{
catalog_getfullname( num, full_name ) ;
if ( full_name[0] != 0 )
{
sprintf( buf, "Display %s\r\n", full_name ) ;
if ( fwrite( buf, strlen(buf), 1, stream ) != 1 )
{
form_stop(1,msg[MSG_WRITEERROR]) ;
break ;
}
}
if ( MAY_UPDATE( wprog, num ) )
{
sprintf( buf, "%04ld/%04ld", num, catalog_filter.nb_visibles ) ;
wprog->ProgPc( wprog, (int) ((100L*num)/(long)catalog_filter.nb_visibles), buf ) ;
}
}
fclose( stream ) ;
GWDestroyWindow( wprog ) ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
break ;
case ALBUM_OK : code = IDOK ;
break ;
}
if ( code == IDOK )
{
}
return( code ) ;
}
int OnObjectNotifyPal(void *w, int obj)
{
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_PAL *wext = wnd->DlgData->UserData ;
OBJECT *adr_mkpal = wnd->DlgData->BaseObject ;
int off_x, off_y ;
int xm, ym, dummy ;
int pb_x, pb_y ;
int x1, y1, x2, y2 ;
int code = -1 ;
char buf[15] ;
graf_mkstate( &xm, &ym, &dummy, &dummy ) ;
switch( obj )
{
case MKPAL_MRED :
case MKPAL_PRED : if ( obj == MKPAL_PRED ) wext->curr_rgb[0]++ ;
else wext->curr_rgb[0]-- ;
if (wext->curr_rgb[0] < 1) wext->curr_rgb[0] = 1 ;
if (wext->curr_rgb[0] > 1000) wext->curr_rgb[0] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_MGREEN :
case MKPAL_PGREEN : if ( obj == MKPAL_PGREEN ) wext->curr_rgb[1]++ ;
else wext->curr_rgb[1]-- ;
if (wext->curr_rgb[1] < 1) wext->curr_rgb[1] = 1 ;
if (wext->curr_rgb[1] > 1000) wext->curr_rgb[1] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_MBLUE :
case MKPAL_PBLUE : if ( obj == MKPAL_PBLUE ) wext->curr_rgb[2]++ ;
else wext->curr_rgb[2]-- ;
if (wext->curr_rgb[2] < 1) wext->curr_rgb[2] = 1 ;
if (wext->curr_rgb[2] > 1000) wext->curr_rgb[2] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_REDBOX :
objc_offset(adr_mkpal, MKPAL_RED, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[0] = wext->curr_rgb[0]-20 ;
else wext->curr_rgb[0] = wext->curr_rgb[0]+20 ;
if (wext->curr_rgb[0] < 1) wext->curr_rgb[0] = 1 ;
if (wext->curr_rgb[0] > 1000) wext->curr_rgb[0] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_GREENBOX :
objc_offset(adr_mkpal, MKPAL_GREEN, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[1] = wext->curr_rgb[1]-20 ;
else wext->curr_rgb[1] = wext->curr_rgb[1]+20 ;
if (wext->curr_rgb[1] < 1) wext->curr_rgb[1] = 1 ;
if (wext->curr_rgb[1] > 1000) wext->curr_rgb[1] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_BLUEBOX :
objc_offset(adr_mkpal, MKPAL_BLUE, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[2] = wext->curr_rgb[2]-20 ;
else wext->curr_rgb[2] = wext->curr_rgb[2]+20 ;
if (wext->curr_rgb[2] < 1) wext->curr_rgb[2] = 1 ;
if (wext->curr_rgb[2] > 1000) wext->curr_rgb[2] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_RED : wext->curr_rgb[0] = (float) graf_slidebox(adr_mkpal, MKPAL_REDBOX, MKPAL_RED, 1) ;
off_y = (int) (wext->curr_rgb[0]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
wext->curr_rgb[0] = 1000-wext->curr_rgb[0] ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_GREEN : wext->curr_rgb[1] = (float) graf_slidebox(adr_mkpal, MKPAL_GREENBOX, MKPAL_GREEN, 1) ;
off_y = (int) (wext->curr_rgb[1]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
wext->curr_rgb[1] = 1000-wext->curr_rgb[1] ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_BLUE : wext->curr_rgb[2] = (float) graf_slidebox(adr_mkpal, MKPAL_BLUEBOX, MKPAL_BLUE, 1) ;
off_y = (int) (wext->curr_rgb[2]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
wext->curr_rgb[2] = 1000-wext->curr_rgb[2] ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_LOAD : charge_palette() ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
wext->flag_aff = 0 ;
break ;
case MKPAL_SAVE : sauve_palette() ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
wext->flag_aff = 0 ;
break ;
case MKPAL_START :
case MKPAL_END : if ( obj == MKPAL_START ) wext->stdeg = wext->index ;
else wext->enddeg = wext->index ;
if (selected(adr_mkpal, MKPAL_START) && selected(adr_mkpal, MKPAL_END))
{
deselect(adr_mkpal, MKPAL_START) ;
deselect(adr_mkpal, MKPAL_END) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_START ) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_END ) ;
cree_degrade(wext->stdeg, wext->enddeg) ;
wext->stdeg = wext->enddeg = 500 ;
}
break ;
case MKPAL_APPLIQUE : read_text(adr_mkpal, MKPAL_TRED, buf) ;
wext->rgb[0] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
read_text(adr_mkpal, MKPAL_TGREEN, buf) ;
wext->rgb[1] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
read_text(adr_mkpal, MKPAL_TBLUE, buf) ;
wext->rgb[2] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
vs_color(handle, wext->index, wext->rgb) ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
break ;
case MKPAL_BOX : objc_offset(adr_mkpal, obj, &pb_x, &pb_y) ;
if (wext->flag_aff)
{
x1 = pb_x+(wext->index % wext->nb_col_x)*wext->ww ;
y1 = pb_y+(wext->index / wext->nb_col_x)*wext->hh ;
x2 = x1+wext->ww-1 ;
y2 = y1+wext->hh-1 ;
vsf_color(handle, 1) ;
vswr_mode(handle, MD_XOR) ;
vsl_width(handle, 3) ;
v_hide_c(handle) ;
rectangle(x1, y1, x2, y2) ;
v_show_c(handle, 1) ;
}
else wext->flag_aff = 1 ;
graf_mkstate(&xm, &ym, &dummy, &dummy) ;
wext->index = (xm-pb_x)/wext->ww+ wext->nb_col_x*((ym-pb_y)/wext->hh) ;
vq_color(handle, wext->index, 0, wext->rgb) ;
sprintf(buf, "%.4d", wext->rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
sprintf(buf, "%.4d", wext->rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
sprintf(buf, "%.4d", wext->rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_RGB ) ;
x1 = pb_x+wext->ww*((xm-pb_x)/wext->ww) ;
y1 = pb_y+wext->hh*((ym-pb_y)/wext->hh) ;
x2 = x1+wext->ww-1 ;
y2 = y1+wext->hh-1 ;
vsf_color(handle, 1) ;
v_hide_c(handle) ;
vswr_mode(handle, MD_XOR) ;
vsl_width(handle, 3) ;
rectangle(x1, y1, x2, y2) ;
v_show_c(handle, 1) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_CURRCOL ) ;
off_y = (int) ((1000-wext->rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
off_y = (int) ((1000-wext->rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
off_y = (int) ((1000-wext->rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
break ;
case MKPAL_OK : code = IDOK ;
break ;
case MKPAL_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
}
return( code ) ;
}
short select_exports( short *type_ptr )
{
int oset = 0 ; /* slider offset in numbers of people */
short done = FALSE ;
short fdone ;
short export = FALSE ;
short button ;
short m_x, m_y ;
short dummy ;
short obj_x, obj_y ;
Filter filter ;
short i, flag ;
match_refs = (int *) pmalloc( sizeof (int) * next_person ) ;
pcross_refs = (int *) pmalloc( sizeof (int) * next_person ) ;
ccross_refs = (int *) pmalloc( sizeof (int) * next_couple ) ;
total_people = 0 ;
for( i=1; i<next_person; i++ )
{
if( people[i].birth_date != DELETED_DATE )
matches[total_people++] = i ;
}
exp_selected = (char *) pmalloc( total_people ) ;
if( !exp_selected || !match_refs || !pcross_refs || !ccross_refs )
{
rsrc_form_alert( 1, NO_MEMORY ) ;
if( exp_selected ) free( exp_selected ) ;
if( match_refs ) free( match_refs ) ;
if( pcross_refs ) free( pcross_refs ) ;
if( ccross_refs ) free( ccross_refs ) ;
return FALSE ;
}
qsort( matches, (size_t) total_people, (size_t) 4, pidx_compare ) ;
/* initialise match_refs as not all of array is used */
for( i=0; i<next_person; i++ ) match_refs[i] = -1 ;
/* load array to get from reference to match position */
for( i=0; i<total_people; i++ ) match_refs[matches[i]] = i ;
for( i=0; i<total_people; i++ ) exp_selected[i] = FALSE ;
if( total_people > 16 )
{
if( total_people < 256 )
esel_ptr[ES_SLIDER].ob_height
= esel_ptr[ES_SLIDE_RANGE].ob_height * 16 / total_people ;
else
esel_ptr[ES_SLIDER].ob_height
= esel_ptr[ES_SLIDE_RANGE].ob_height / 16 ;
set_slide( 0, total_people-16, esel_ptr,
ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
}
else
{
esel_ptr[ES_SLIDER].ob_height = esel_ptr[ES_SLIDE_RANGE].ob_height ;
set_slide( 0, 1, esel_ptr, ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
}
list_exportees( oset ) ;
app_modal_init( esel_ptr, "Export", TITLED ) ;
while( !done )
{
button = app_modal_do() ;
button &= ~DOUBLE_CLICK ;
if( button && button != APP_MODAL_TERM ) esel_ptr[button].ob_state &= ~SELECTED ;
switch( button )
{
case ES_SLIDER :
if( total_people > 16 )
{
oset = move_slide( esel_ptr,
ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
oset = ( total_people - 16 ) * oset / 1000 ;
}
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ES_UP :
if( total_people > 16 && oset > 0 )
{
oset-- ;
set_slide( oset, total_people-16, esel_ptr,
ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
}
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ES_DOWN :
if( total_people > 16 && oset < total_people - 16 )
{
oset++ ;
set_slide( oset, total_people - 16, esel_ptr,
ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
}
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ES_SLIDE_RANGE :
if( total_people > 16 )
{
graf_mkstate( &m_x, &m_y, &dummy, &dummy ) ;
objc_offset( esel_ptr, ES_SLIDER, &obj_x, &obj_y ) ;
if( m_y > obj_y )
{
oset += 15 ;
if( oset > total_people - 16 ) oset = total_people - 16 ;
}
else
{
oset -= 15 ;
if( oset < 0 ) oset = 0 ;
}
set_slide( oset, total_people-16, esel_ptr,
ES_SLIDER, ES_SLIDE_RANGE, app_modal_box() ) ;
}
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ESEL0 :
case ESEL1 :
case ESEL2 :
case ESEL3 :
case ESEL4 :
case ESEL5 :
case ESEL6 :
case ESEL7 :
case ESEL8 :
case ESEL9 :
case ESEL10 :
case ESEL11 :
case ESEL12 :
case ESEL13 :
case ESEL14 :
case ESEL15 :
if( esel_ptr[ANCESTORS].ob_state & SELECTED )
{
ancestor_select( matches[button-ESEL0 + oset] ) ;
esel_ptr[ANCESTORS].ob_state &= ~SELECTED ;
esel_ptr[DESCENDANTS].ob_state &= ~SELECTED ;
list_exportees( oset ) ;
objc_draw( esel_ptr, ROOT, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
}
else if( esel_ptr[DESCENDANTS].ob_state & SELECTED )
{
descendant_select( matches[button-ESEL0 + oset], 0, 0 ) ;
esel_ptr[DESCENDANTS].ob_state &= ~SELECTED ;
list_exportees( oset ) ;
objc_draw( esel_ptr, ROOT, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
}
else
{
if( !exp_selected[button-ESEL0 + oset] )
{
exp_selected[button-ESEL0 + oset] = TRUE ;
esel_ptr[button].ob_state |= CHECKED ;
}
else
{
exp_selected[button-ESEL0 + oset] = FALSE ;
esel_ptr[button].ob_state &= ~CHECKED ;
}
objc_draw( esel_ptr, button, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
}
break ;
case ES_SEL_ALL :
for( i=0; i<total_people; i++ ) exp_selected[i] = TRUE ;
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
objc_draw( esel_ptr, ES_SEL_ALL, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ES_DSEL_ALL :
for( i=0; i<total_people; i++ ) exp_selected[i] = FALSE ;
list_exportees( oset ) ;
objc_draw( esel_ptr, ES_LIST, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
objc_draw( esel_ptr, ES_DSEL_ALL, MAX_DEPTH, PTRS( app_modal_box() ) ) ;
break ;
case ES_FILTER :
clear_efil_form() ;
clear_form_flags() ;
for( i = 0 ; i <= FL_NOT8 - FL_NOT1 ; i+= FL_NOT2 - FL_NOT1 )
{
set_to_ignore(FL_NOT1+i) ;
flags_ptr[FL_NOT1+i].ob_state |= SELECTED ;
}
fdone = FALSE ; /* loop until filter done */
while( !fdone )
{
button = do_sub_form( efil_ptr, "Export Filter", EXP_HELP, TITLED ) ;
switch( button )
{
case EXP_SEL :
case EXP_DESEL :
busy( BUSY_MORE ) ;
update_filter( &filter, efil_form_addrs.efam_name,
efil_form_addrs.eforename, efil_form_addrs.ebefore,
efil_form_addrs.eafter, efil_form_addrs.eplace ) ;
if( button == EXP_DESEL ) flag = FALSE ;
else flag = TRUE ;
for( i=0; i<total_people; i++ )
{
if( test_match( &filter, matches[i] ) )
exp_selected[i] = flag ;
}
busy( BUSY_LESS ) ;
case EXP_CANCEL :
fdone = TRUE ;
break ;
case EXP_FLAGS :
do_sub_form( flags_ptr, "Filter Flags", FL_HELP, TITLED ) ;
break ;
}
}
list_exportees( oset ) ;
break ;
case ES_CANCEL :
case APP_MODAL_TERM :
done = TRUE ;
break ;
case ES_OK :
export = TRUE ;
done = TRUE ;
break ;
case ES_HELP :
help( export_help ) ;
objc_draw( esel_ptr, ES_HELP, 0, PTRS( app_modal_box() ) ) ;
break ;
default :
break ;
}
}
esel_ptr[ANCESTORS].ob_state &= ~SELECTED ;
esel_ptr[DESCENDANTS].ob_state &= ~SELECTED ;
if( esel_ptr[GEDCOM].ob_state & SELECTED )
*type_ptr = GEDCOM_TYPE ;
else if( esel_ptr[CSV].ob_state & SELECTED )
*type_ptr = CSV_TYPE ;
else *type_ptr = FAMTREE_TYPE ;
app_modal_end() ;
return export ;
}
int16 main(void)
{
GRECT n = {0,0,0,0};
GRECT r1;
EVNTDATA ev;
int16 bclicks, bmask, bstate;
boolean leave;
quit = FALSE;
debug_init("MControl", null, NULL);
init_app("mcontrol.rsc");
init_rsrc();
init_conf();
init_dial();
init_comm();
init_beta();
/* Callback f�r modale Fensterdialoge, Fenster-Alerts usw. */
set_mdial_wincb(handle_msg);
graf_mkstate( &ev );
wdial_hover( ev.x, ev.y, &r1, &leave );
while (!quit)
{
mbutton = 0;
if( !((ev.bstate) & 3) )
bclicks = 258;
else
bclicks = 0;
bmask = 3;
bstate = 0;
event = evnt_multi( MU_BUTTON|MU_M1|MU_MESAG|MU_KEYBD,
bclicks, bmask, bstate,
leave, &r1, 0, &n,
msg,
0l,
&ev,
&kreturn, &mclick );
msx = ev.x;
msy = ev.y;
mbutton = ev.bstate;
kstate = ev.kstate;
if (event & MU_MESAG)
{
if( msg[0] == WM_MOVED )
wdial_hover( msx, msy, &r1, &leave );
handle_msg(msg);
}
if (event & MU_BUTTON)
{
if( mbutton == 2 )
menu_context( msx, msy );
else if (!click_wdial(mclick, msx, msy, kstate, mbutton))
;
}
if (event & MU_M1)
wdial_hover( msx, msy, &r1, &leave );
if (event & MU_KEYBD)
{
int16 title, item;
if (is_menu_key(kreturn, kstate, &title, &item))
handle_menu(title, item);
else
{
key_wdial(kreturn, kstate);
key_sdial(kreturn, kstate);
}
}
}
exit_comm();
exit_dial();
exit_rsrc();
debug_exit();
exit_app(0);
return 0;
}
/**
* Core atari event processing.
*/
static void atari_poll(void)
{
struct gui_window *tmp;
short mx, my, dummy;
aes_event_in.emi_tlow = schedule_run();
if(rendering){
aes_event_in.emi_tlow = nsoption_int(atari_gui_poll_timeout);
}
if(aes_event_in.emi_tlow < 0) {
aes_event_in.emi_tlow = 10000;
printf("long poll!\n");
}
if(input_window && input_window->root->redraw_slots.areas_used > 0) {
window_process_redraws(input_window->root);
}
graf_mkstate(&mx, &my, &dummy, &dummy);
aes_event_in.emi_m1.g_x = mx;
aes_event_in.emi_m1.g_y = my;
evnt_multi_fast(&aes_event_in, aes_msg_out, &aes_event_out);
if(gemtk_wm_dispatch_event(&aes_event_in, &aes_event_out, aes_msg_out) == 0) {
if( (aes_event_out.emo_events & MU_MESAG) != 0 ) {
LOG("WM: %d\n", aes_msg_out[0]);
switch(aes_msg_out[0]) {
case MN_SELECTED:
LOG("Menu Item: %d\n", aes_msg_out[4]);
deskmenu_dispatch_item(aes_msg_out[3], aes_msg_out[4]);
break;
case AP_TERM:
atari_quit = true;
break;
default:
break;
}
}
if((aes_event_out.emo_events & MU_KEYBD) != 0) {
uint16_t nkc = gem_to_norm( (short)aes_event_out.emo_kmeta,
(short)aes_event_out.emo_kreturn);
deskmenu_dispatch_keypress(aes_event_out.emo_kreturn,
aes_event_out.emo_kmeta, nkc);
}
}
tmp = window_list;
while(tmp){
if(tmp->root->redraw_slots.areas_used > 0){
window_process_redraws(tmp->root);
}
tmp = tmp->next;
}
/** @todo implement generic treeview redraw function. */
/** @todo rename hl to atari_hotlist or create getter for it... */
atari_treeview_flush_redraws();
}
xamdeflst()
{
long mul;
int botptr, bret, value;
int xoff, yoff, mx, my;
int i, ret, cont;
int np, xam;
int k1, k2;
/* Allocate memory to hold defects */
if ((xampaddr = mymalloc(npndefs*(sizeof(PADDR)))) <= 0) {
return err(nomemory);
}
for (np = 0; np < npndefs; np++) {
xampaddr[np].exist = nppaddr[np].exist;
xampaddr[np].head = nppaddr[np].head;
xampaddr[np].cylndr = nppaddr[np].cylndr;
xampaddr[np].btoffst = nppaddr[np].btoffst;
}
r_items(); /* read items */
totcnt = npndefs;
if (npndefs > NM_ITEMS) /* bigger than one window */
botptr = npndefs - NM_ITEMS;
else
botptr = 0;
cont = TRUE; /* control flag */
while(cont) {
bret = form_do(xamform, -1);
graf_mkstate(&mx, &my, &k1, &k2); /* graf mkstate */
ret = bret & 0x7FFF; /* mask off double click */
LWSET(OB_STATE(xamform, ret), 0);
value = 1; /* scroll factor */
switch (ret) { /* Big Switch */
case FSVSLID:
objc_offset(xamform, FSVELEV, &xoff, &yoff);
value = NM_ITEMS; /* one full window size */
if (my <= yoff)
goto up;
goto down;
case FSVELEV:
value = graf_slidebox(xamform, FSVSLID, FSVELEV, TRUE);
mul = (npndefs - NM_ITEMS) * value;
mul /= 1000;
value = (int)mul;
value = (topptr - value);
if (value >= 0)
goto up; /* go up */
else
value = -value; /* go down */
down: case FDNAROW: /* scroll down */
if (topptr == botptr)
break;
if ((topptr + value) <= botptr)
topptr += value;
else
topptr = botptr;
goto sfiles;
up: case FUPAROW: /* scroll up */
if (!topptr)
break;
if ((topptr - value) >= 0)
topptr -= value;
else
topptr = 0;
sfiles: r_show(topptr); /* redisplay the file */
break;
case FCLSBOX:
cont = FALSE;
break;
default:
if (ret >= ENTRY0 && ret <= ENTRY7) {
erasemsg(); /* erase EXAMINING box */
want2edt(ret); /* let user edit entry */
dsplymsg(xamform); /* redraw EXAMINING box */
}
break;
} /* end of switch */
} /* while */
erasemsg();
/* New inputted list = Examined list */
for (xam = 0, np = 0; xam < npndefs; xam++) {
if (xampaddr[xam].exist) {
nppaddr[np].head = xampaddr[xam].head;
nppaddr[np].cylndr = xampaddr[xam].cylndr;
nppaddr[np].btoffst = xampaddr[xam].btoffst;
np++;
}
}
npndefs = np; /* current number of input entries */
free(xampaddr);
return (TRUE);
}
static bool select_font( bool is_prn )
{
int button, cx, cy, cw, ch, mousey, slidey, dum;
int index, i, double_click;
long pos;
static int top = 0; /* first name set to the top */
wind_update(BEG_UPDATE);
set_slider_size(); /* set slider size and position, like a GEM window */
set_slider_pos(top);
((TEDINFO *)chooser[CHACTION].ob_spec)->te_ptext = " Choose GDOS font ";
((TEDINFO *)chooser[CHTITLE].ob_spec)->te_ptext = is_prn? " Printer font list: ": " Screen font list: ";
((TEDINFO *)chooser[GEMFNAME].ob_spec)->te_ptext = gem_file_name;
((TEDINFO *)chooser[GEMFNAME].ob_spec)->te_txtlen = sizeof(gem_file_name);
form_center(chooser, &cx, &cy, &cw, &ch);
form_dial(FMD_START, 0, 0, 0, 0, cx, cy, cw, ch);
objc_draw(chooser, ROOT, MAX_DEPTH, cx, cy, cw, ch);
/*
** the chooser can show up to MAX_NAMES names. If there are fewer than this,
** the empty slots are disabled by clearing the TOUCHEXIT flags
*/
for( i=0; i<MAX_NAMES; i++ ) {
if( i<nr_names ) {
chooser[NAME1+i].ob_flags |= TOUCHEXIT;
}
else {
chooser[NAME1+i].ob_flags &= ~TOUCHEXIT;
} /* if */
} /* for */
show_names( top ); /* display the font names */
/** the main loop **/
do {
button =form_do( chooser, GEMFNAME );
dprintf(( "\033Hbutton is %x\n", button)); dgetchar();
if(button&0x8000) { /* double click */
double_click = TRUE;
button &= 0x7fff;
}
else double_click = FALSE;
if(button ==DNARR) {
if((top+MAX_NAMES)<nr_names) {
top++; /* next name in the list */
show_names( top );
set_slider_pos(top);
objc_draw(chooser, SLIDEBAR, MAX_DEPTH, cx, cy, cw, ch);
}
}
else if(button ==UPARR) {
if(top>0) {
top--;
show_names( top );
set_slider_pos(top);
objc_draw(chooser, SLIDEBAR, MAX_DEPTH, cx, cy, cw, ch);
}
}
else if(button ==SLIDEBAR && nr_names>MAX_NAMES) { /* handle clicks on the slidebar */
graf_mkstate(&dum, &mousey, &dum, &dum); /* where is the mouse - above or below the slider? */
objc_offset(chooser, SLIDER, &dum, &slidey);
if(mousey<slidey) { /* mouse is above the slider */
top-=MAX_NAMES; /* move up one page of names */
if(top<0) top =0;
}
else {
top+=MAX_NAMES;
if(top>(nr_names-MAX_NAMES)) top =nr_names-MAX_NAMES;
} /* if */
show_names( top );
set_slider_pos(top);
objc_draw(chooser, SLIDEBAR, MAX_DEPTH, cx, cy, cw, ch);
}
else if(button ==SLIDER && nr_names>MAX_NAMES) { /* handle the slider */
pos =graf_slidebox(chooser, SLIDEBAR, SLIDER, 1); /* the position the user wants */
chooser[SLIDER].ob_y =pos*(long)(chooser[SLIDEBAR].ob_height-chooser[SLIDER].ob_height)/1000;
top =pos*(nr_names-MAX_NAMES)/1000;
if(top<0) top =0;
if(top>(nr_names-MAX_NAMES)) top =nr_names-MAX_NAMES;
show_names( top );
objc_draw(chooser, SLIDEBAR, MAX_DEPTH, cx, cy, cw, ch);
}
else if(button>=NAME1 && button<=NAME8) {
/*** the user has clicked on a font name ***/
index = top+button-NAME1;
dprintf(( "\033Hindex is %d\n", index)); dgetchar();
if( iSelected == index ) { /* the name is already selected */
assert( iSelected >=0 );
assert( iSelected < nr_names );
iSelected = NO_INDEX; /* deselect it */
highlight(button); /* remove the highlight from the name */
}
else {
/* is the currently selected font name displayed in the box? */
if( iSelected!=NO_INDEX
&& (iSelected+NAME1-top)>=NAME1
&& (iSelected+NAME1-top)<=NAME8 ) {
highlight( iSelected+NAME1-top ); /* remove highlight */
} /* if */
iSelected = index; /* set the index for the new selection */
highlight(button); /* and highlight it */
} /* if */
if(double_click) button =CHOOSEOK; /* if double clicked on a name, exit immediately */
} /* if */
assert( iSelected == NO_INDEX || iSelected >=0 );
assert( iSelected == NO_INDEX || iSelected < nr_names );
} while(button!=CHOOSEOK && button!=CHOOSECA);
/** returned from form, process user actions **/
dprintf(( "\033HiSelected is %d\n", iSelected)); dgetchar();
dprintf(( "selected name is %s\n", name_table[iSelected].name ));
dprintf(( "gem file name is %s\n",
((TEDINFO *)chooser[GEMFNAME].ob_spec)->te_ptext ));
dprintf(( "%s format%s\n",
chooser[MOT].ob_state&SELECTED ? "motorola" : "intel",
chooser[WIDONLY].ob_state&SELECTED ? ", width tables only" : "" ));
dgetchar();
assert( (chooser[MOT].ob_state & SELECTED) != (chooser[INTEL].ob_state&SELECTED) );
fMot = (chooser[MOT].ob_state & SELECTED) != 0;
fWidOnly = (chooser[WIDONLY].ob_state & SELECTED) != 0;
chooser[button].ob_state &= ~SELECTED;
form_dial( FMD_FINISH, 0, 0, 0, 0, cx, cy, cw, ch );
wind_update( END_UPDATE );
return button==CHOOSEOK;
} /* select_font() */
