static void drawgadget( p_gadget g )
{
int i;
int length;
uiunprotect( g->win );
length = g->end - g->start - 1;
for( i=g->start; i <= g->end; ++i ){
if( g->dir == VERTICAL ) {
uivtextput( g->win, row(g,i), col(g,i), _ATTR, VertScrollFrame, 0 );
} else {
uivtextput( g->win, row(g,i), col(g,i), _ATTR, HorzScrollFrame, 0 );
}
}
/* don't draw scroll thumb in g->total_size <= page_size */
if( ( g->total_size > g->page_size ) && ( length > 1 ) ) {
if( g->dir == HORIZONTAL ) {
uivtextput( g->win, g->anchor, g->linear, _ATTR_SLIDER, SliderChar, 0 );
} else {
uivtextput( g->win, g->linear, g->anchor, _ATTR_SLIDER, SliderChar, 0 );
}
}
if( g->dir == HORIZONTAL ){
uivtextput( g->win, g->anchor, g->start, _ATTR, LeftPoint, 0 );
uivtextput( g->win, g->anchor, g->end, _ATTR, RightPoint, 0 );
} else {
uivtextput( g->win, g->start, g->anchor, _ATTR, UpPoint, 0 );
uivtextput( g->win, g->end, g->anchor, _ATTR, DownPoint, 0 );
}
uiprotect( g->win );
}
void uidrawbox( VSCREEN *vs, SAREA *area, ATTR attr, const char *title )
/**********************************************************************/
{
int length;
int col;
if( area->width < 2 ) {
return;
}
drawbox( &(vs->window.type.buffer), *area, (char *)&UiGChar[ UI_SBOX_TOP_LEFT ],
attr, FALSE );
if( title == NULL ) {
return;
}
length = strlen( title );
col = area->col + 1;
if( length >= area->width - 2 ) {
length = area->width;
}
uivtextput( vs, area->row, col, attr, title, length );
}
void GUIDrawIcon( gui_window * wnd )
{
SAREA area;
int length;
ATTR attr;
char *str;
COPYAREA( wnd->screen.area, area );
area.row = 0;
area.col = 0;
attr = wnd->colours[GUI_ICON];
uivfill( &wnd->screen, area, attr, ' ' );
uidrawbox( &wnd->screen, &area, attr, NULL );
str = NULL;
if( wnd->icon_name != NULL ) {
str = wnd->icon_name;
} else {
if( wnd->screen.name != NULL ) {
str = wnd->screen.name;
}
}
if( str != NULL ) {
length = strlen( str );
if( length > ( area.width - 2 ) ) {
length = area.width - 2;
}
uivtextput( &wnd->screen, ( area.height / 2 ), 1, attr, str, length );
}
}
static void open( void )
/**********************/
{
ui_event ui_ev;
if( uivopen( &opwin ) ) {
uipushlist( oplist );
uivtextput( &opwin, 1, 2, UIData->attrs[ATTR_NORMAL], "Enter file name.", 16 );
inputline.attr = UIData->attrs[ATTR_EDIT];
/* blank out the buffer */
inputline.index = 0;
inputline.scroll = 0;
inputline.update = true;
for( ;; ) {
ui_ev = uiveditline( &opwin, &inputline );
if( ui_ev != EV_NO_EVENT ) {
break;
}
}
if( ui_ev == EV_ENTER ) {
/* open file */
} else if( ui_ev == EV_ESCAPE ) {
/* do nothing */
} else {
/* must be an event handled in the mainline */
uiungetevent();
}
uipoplist( /* oplist */ );
uivclose( &opwin );
}
}
static EVENT setfield( VSCREEN *vptr, VFIELDEDIT *header, VFIELD *cur, ORD col )
/*********************************************/
{
register EVENT ev;
register VFIELD* prev;
if( cur != header->curfield ) {
prev = header->curfield;
if( prev ) {
/* change attribute on field being left */
uivtextput( vptr, prev->row, prev->col, header->exit,
header->buffer, prev->length );
}
header->prevfield = prev;
header->curfield = cur;
header->fieldpending = true;
ev = EV_FIELD_CHANGE;
} else {
ev = EV_NO_EVENT;
}
if( cur != NULL ) {
vptr->row = cur->row;
vptr->col = cur->col + col;
}
return( ev );
}
static void putline( char *buffer, int line )
{
int i;
int start;
helpScreen.col = 0;
i = 0;
while( buffer[i] && helpScreen.col < helpScreen.area.width ) {
start = i;
while( buffer[i] && buffer[i] != HELP_ESCAPE &&
helpScreen.col+i-start<=helpScreen.area.width ) {
if( (unsigned char)buffer[i] == 0xFF )
buffer[i] = 0x20;
++i;
}
if( i - start > 0 ) {
uivtextput( &helpScreen, line, helpScreen.col, currentAttr, &buffer[start], i - start );
}
helpScreen.col += i-start;
if( buffer[i] == HELP_ESCAPE ) {
switch( buffer[i+1] ) {
case H_UNDERLINE:
currentColour |= C_ULINE;
++i;
break;
case H_UNDERLINE_END:
currentColour &= ~C_ULINE;
++i;
break;
case H_BOLD:
currentColour |= C_BOLD;
++i;
break;
case H_BOLD_END:
currentColour &= ~C_BOLD;
++i;
break;
}
++i;
switch( currentColour ) {
case C_PLAIN:
currentAttr = AT( ATTR_NORMAL );
break;
case C_ULINE:
currentAttr = AT( ATTR_BRIGHT );
break;
case C_BOLD:
currentAttr = AT( ATTR_BRIGHT );
break;
case C_ULBOLD:
currentAttr = AT( ATTR_BRIGHT );
break;
}
}
}
}
void uicntrtext( VSCREEN *vs, SAREA *area, ATTR attr, unsigned field_len, const char *text )
/******************************************************************************************/
{
ORD col;
if( field_len > 0 ) {
col = area->col;
if( field_len < area->width ) {
col += ( area->width - field_len ) / 2;
} else {
field_len = area->width;
}
uivtextput( vs, area->row, col, attr, text, field_len );
}
}
void uidrawbox( VSCREEN *vs, SAREA *area, ATTR attr, const char *title )
/**********************************************************************/
{
uisize field_len;
if( area->width > 1 ) {
drawbox( &(vs->window.type.buffer), *area, SBOX_CHARS(), attr, false );
if( title != NULL ) {
field_len = strlen( title );
if( field_len > area->width - 2 ) {
field_len = area->width - 2;
}
uivtextput( vs, area->row, area->col + 1, attr, title, field_len );
}
}
}
static void print_field( VSCREEN *vs, VFIELD *field, unsigned current )
{
SAREA *area;
char *str;
ATTR attr;
ATTR hotattr;
char ctrlbuf[CTRL_BUF_LEN+1];
unsigned length = 0;
a_check *check = NULL;
a_radio *radio = NULL;
a_list *list;
a_combo_box *combo;
a_hot_spot *hotspot;
an_edit_control *edit;
VSCREEN *c_vs;
SAREA c_area;
bool use_hottext;
char hotkey;
if( field == NULL ) return;
area = &field->area;
str = NULL;
use_hottext = FALSE;
memset( ctrlbuf, '\0', CTRL_BUF_LEN+1 );
attr = UIData->attrs[ current ? ATTR_CURR_EDIT : ATTR_EDIT ];
switch( field->typ ) {
case FLD_HOT :
hotspot = field->ptr;
if( current ) {
hotspot->flags |= HOT_CURRENT ;
} else {
hotspot->flags &= (~HOT_CURRENT);
}
hotspot->flags |= uihotspot( vs, hotspot->str,
&field->area, hotspot->flags );
return; // don't want to print anything
case FLD_TEXT :
attr = UIData->attrs[ ATTR_NORMAL ];
str = field->ptr;
break;
case FLD_LABEL :
attr = UIData->attrs[ ATTR_NORMAL ];
strcpy( ctrlbuf, (char *)field->ptr );
strcat( ctrlbuf, ":" );
length = area->width;
break;
case FLD_FRAME :
uidrawbox( vs, area, UIData->attrs[ ATTR_NORMAL ], field->ptr );
return;
case FLD_EDIT :
case FLD_INVISIBLE_EDIT :
edit = field->ptr;
if( edit->buffer != NULL ) {
length = edit->length;
if( length > CTRL_BUF_LEN )
length = CTRL_BUF_LEN;
if( length > area->width ) {
length = area->width;
}
if( field->typ == FLD_INVISIBLE_EDIT ) {
memset( ctrlbuf, '*', length );
} else {
strncpy( ctrlbuf, edit->buffer, length );
}
} else {
length = 0;
}
break;
case FLD_COMBOBOX :
combo = field->ptr;
edit = &combo->edit;
list = &combo->list;
if( combo->perm == FALSE ) {
ctrlbuf[0] = UiGChar[ UI_ARROW_DOWN ]; /* JBS was 25 */
uivtextput( vs, area->row, area->col + area->width + 1,
UIData->attrs[ ATTR_SCROLL_ICON ], ctrlbuf, 1 );
ctrlbuf[0] = '\0';
}
if( edit->buffer != NULL ) {
length = edit->length;
if( length > CTRL_BUF_LEN )
length = CTRL_BUF_LEN;
strncpy( ctrlbuf, edit->buffer, length );
} else {
length = 0;
}
if( list->get == NULL ) {
list->get = ( bool (*) ( void *, unsigned, char *, unsigned ) )
uigetlistelement;
}
if( list->box == NULL && combo->perm == TRUE ) {
c_area = *area;
c_area.row += vs->area.row + 2;
c_area.col += vs->area.col + 1;
c_vs = uiopen( &c_area, NULL, V_DIALOGUE | V_LISTBOX );
if( c_vs == NULL ) {
break;
}
c_area.row = 0;
c_area.col = 0;
list->box = uibeglistbox( c_vs, &c_area, list );
}
break;
case FLD_PULLDOWN :
list = field->ptr;
ctrlbuf[0] = UiGChar[ UI_ARROW_DOWN ]; /* JBS was 25 */
uivtextput( vs, area->row, area->col + area->width,
UIData->attrs[ ATTR_SCROLL_ICON ], ctrlbuf, 1 );
ctrlbuf[0] = '\0';
if( list->get == NULL ) {
list->get = ( bool (*) ( void *, unsigned, char *, unsigned ) )
uigetlistelement;
}
(*list->get)( list->data, list->choice, ctrlbuf, area->width );
length = area->width;
break;
case FLD_LISTBOX:
case FLD_EDIT_MLE:
list = field->ptr;
if( list->box == NULL ) {
c_area = *area;
c_area.row += ((VSCREEN *)vs)->area.row;
c_area.col += ((VSCREEN *)vs)->area.col;
c_vs = uiopen( &c_area, NULL, V_DIALOGUE | V_LISTBOX );
if( c_vs == NULL ) {
break;
}
c_area.row = 0;
c_area.col = 0;
list->box = uibeglistbox( c_vs, &c_area, list );
}
return;
case FLD_CHECK:
attr = UIData->attrs[ current ? ATTR_CURR_EDIT : ATTR_NORMAL ];
check = field->ptr;
ctrlbuf[0] = UiGChar[ UI_CHECKBOX_LEFT ];
if( _checked( check ) ) {
ctrlbuf[1] = UiGChar[ UI_CHECKBOX_FULL ];
} else {
ctrlbuf[1] = UiGChar[ UI_CHECKBOX_EMPTY ];
}
ctrlbuf[2] = UiGChar[ UI_CHECKBOX_RIGHT ];
ctrlbuf[3] = ' ';
strncat( ctrlbuf, check->str, CTRL_BUF_LEN - 4 );
length = strlen( ctrlbuf );
use_hottext = TRUE;
break;
case FLD_RADIO:
attr = UIData->attrs[ current ? ATTR_CURR_EDIT : ATTR_NORMAL ];
radio = field->ptr;
ctrlbuf[0] = UiGChar[ UI_RADIO_LEFT ];
if( radio->value == radio->group->value ) {
ctrlbuf[1] = UiGChar[ UI_RADIO_FULL ];
} else {
ctrlbuf[1] = UiGChar[ UI_RADIO_EMPTY ];
}
ctrlbuf[2] = UiGChar[ UI_RADIO_RIGHT ];
ctrlbuf[3] = ' ';
strncat( ctrlbuf, radio->str, CTRL_BUF_LEN - 4 );
length = strlen( ctrlbuf );
use_hottext = TRUE;
break;
}
if( str != NULL ) {
uivtextput( vs, area->row, area->col, attr, str, area->width );
} else if( use_hottext ) {
if( current ) {
hotattr = attr;
} else {
hotattr = UIData->attrs[ ATTR_RADIO_HOTSPOT ];
}
hotkey = uidrawhottext( vs, ctrlbuf, area, attr, hotattr, FALSE, FALSE, FALSE );
if( field->typ == FLD_CHECK ) {
check->hotkey = hotkey;
} else if( field->typ == FLD_RADIO ) {
radio->hotkey = hotkey;
}
} else {
uitextfield( vs, area->row, area->col, area->width, attr,
ctrlbuf, length );
}
}
void main( void )
/***************/
{
ui_event ui_ev;
SAREA area;
char buff[80];
an_event_string *ptr;
ORD evrow = TOP_ROW;
int mrow, mcol;
int diff;
if( uistart() ) {
#ifdef CHARMAP
uiinitgmouse( INIT_MOUSE_INITIALIZED ); /* the 0=mouseless,1=mouse,2=initialized mouse */
// uivgaattrs();
FlipCharacterMap();
#else
initmouse( INIT_MOUSE_INITIALIZED );
#endif
uimenus( barmenu, pulldownuimenus, EV_F1 );
UIData->mouse_clk_delay = uiclockdelay( 250 /* ms */ );
UIData->tick_delay = uiclockdelay( 3000 /* ms */ );
mainwin.area.height = UIData->height - 7;
if( uivopen( &mainwin ) ) {
for( ;; ) {
uipushlist( evlist );
ui_ev = uivgetevent( &mainwin );
uipoplist( /* evlist */ );
if( ui_ev == EV_MOUSE_PRESS_R ) {
uimousepos( NULL, &mrow, &mcol );
mrow++;
mcol++;
uipushlist( evlist );
ui_ev = uicreatepopup( mrow, mcol, filemenu, false, true, EV_NO_EVENT );
uipoplist( /* evlist */ );
}
switch( ui_ev ) {
case EV_QUIT:
break;
case EV_BACKGROUND_RESIZE:
uivclose( &mainwin );
mainwin.area.height = UIData->height - 7;
uivopen( &mainwin );
if( evrow > mainwin.area.height ) {
evrow = TOP_ROW;
}
break;
case EV_SAMPLE_DIALOG:
sample_dialog();
break;
case EV_OPEN:
open();
break;
case EV_GO:
uispawnstart();
uiblankscreen();
printf( "Type exit to return\n" );
#if defined( __QNX__ ) || defined( __UNIX__ )
system( "" );
#elif defined( __WINDOWS__ )
// do nothing
#else
{
const char *command;
command = getenv( "COMSPEC" );
if( command == NULL ) {
command = "c:\\command.com";
}
system( command );
}
#endif
uispawnend();
// uibackground( "wf.img" );
area.row = 0;
area.col = 0;
area.height = UIData->height;
area.width = UIData->width;
uidirty( area );
break;
case EV_F1:
area.width = 10;
area.height = 10;
area.row = 1;
area.col = 1;
uivattribute( &mainwin, area, (ATTR) 1 );
break;
}
if( ui_ev == EV_QUIT ) {
break;
} else if( ui_ev != EV_NO_EVENT ) {
for( ptr = evstrs; ; ++ptr ) {
if( ptr->ui_ev == EV_NO_EVENT ) {
sprintf( buff, "event 0x%4.4x", ui_ev );
break;
} else if( ptr->ui_ev == ui_ev ) {
sprintf( buff, "event 0x%4.4x (%s)", ui_ev, ptr->str );
break;
}
}
uivtextput( &mainwin, evrow, 2, UIData->attrs[ATTR_NORMAL], buff, 40 );
if( ++evrow >= mainwin.area.height ) {
evrow = TOP_ROW;
}
uivtextput( &mainwin, evrow, 2, UIData->attrs[ATTR_NORMAL], "", 40 );
switch( ui_ev ) {
case EV_MOUSE_PRESS:
BandOn = 1;
uimousepos( NULL, &mrow, &mcol );
BandArea.row = mrow;
BandArea.col = mcol;
BandArea.width = 0;
BandArea.height = 0;
uibandinit( BandArea, UIData->attrs[ATTR_ACTIVE] );
break;
case EV_MOUSE_DRAG:
if( BandOn ) {
uimousepos( NULL, &mrow, &mcol );
diff = mcol - BandArea.col;
if( diff < 0 )
diff = 0;
BandArea.width = diff;
diff = mrow - BandArea.row;
if( diff < 0 )
diff = 0;
BandArea.height = diff;
uibandmove( BandArea );
}
break;
case EV_MOUSE_RELEASE:
if( BandOn )
uibandfini();
BandOn = 0;
break;
}
}
}
uivclose( &mainwin );
}
uinomenus();
uiswap();
uirestorebackground(); /* must be after uiswap */
#ifdef CHARMAP
FlipCharacterMap();
uifinigmouse();
#else
finimouse();
#endif
uistop();
}
}
int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
LPSTR lpCmdLine, int nShowCmd ) {
EVENT ev;
SAREA area;
char buff[80];
an_event_string *ptr;
ORD evrow = TOP_ROW;
BOOL fixup = FALSE;
int mrow, mcol;
int diff;
hInstance = hInstance;
hPrevInstance = hPrevInstance;
lpCmdLine = lpCmdLine;
nShowCmd = nShowCmd;
if( InitSwapper() ) return( 0 ); // Yes - well, I would make the swapper
// return 1 on error, unlike everything
// else, wouldn't I?
if( !uistart() ) return( 0 );
ToCharacter();
initmouse( 2 );
uimenus( barmenu, pulldownuimenus, EV_FUNC( 1 ) );
UIData->mouse_clk_delay = uiclockdelay( 250 );
UIData->tick_delay = uiclockdelay( 3000 );
mainwin.area.height = UIData->height - 7;
area.row = 0;
area.col = 0;
area.width = UIData->width;
area.height = UIData->height;
uidirty( area );
uirefresh();
if( uivopen( &mainwin ) ) {
uirefresh();
sprintf( buff, "screen height : %d\0", UIData->height );
uivtextput( &mainwin, TOP_ROW - 1, 2,
UIData->attrs[ ATTR_NORMAL ],
buff, 30 );
for( ; ; ) {
uipushlist( evlist );
ev = uivgetevent( NULL );
uipoplist();
if( ev == EV_QUIT ) break;
if( ev == EV_ALT_R ) break;
if( ev == EV_MOUSE_PRESS_R ) {
uimousepos( NULL, &mrow, &mcol );
mrow++;
mcol++;
uipushlist( evlist );
ev = uicreatepopup( mrow, mcol, &filemenu, FALSE, TRUE, NULL );
uipoplist();
}
switch ( ev ) {
case EV_SAMPLE_DIALOG:
sample_dialog();
break;
case EV_OPEN:
open();
break;
case EV_FUNC(1):
area.width = 10;
area.height = 10;
area.row = 1;
area.col = 1;
uivattribute( &mainwin, area, (ATTR) 1 );
break;
case EV_CURSOR_RIGHT:
mainwin.col++;
if( mainwin.col >= mainwin.area.width ) mainwin.col--;
fixup = TRUE;
break;
case EV_CURSOR_DOWN:
mainwin.row++;
if( mainwin.row >= mainwin.area.height ) mainwin.row--;
fixup = TRUE;
break;
case EV_CURSOR_LEFT:
if( mainwin.col > 0 ) {
mainwin.col--;
fixup = TRUE;
}
break;
case EV_CURSOR_UP:
if( mainwin.row > 0 ) {
mainwin.row--;
fixup = TRUE;
}
break;
}
if( fixup ) {
fixup = FALSE;
uivsetcursor( &mainwin );
}
if( ev != EV_NO_EVENT ) {
for( ptr=evstrs; ; ++ptr ){
if( ptr->ev == EV_NO_EVENT ) {
sprintf( buff, "event 0x%4.4x", ev );
break;
} else if( ptr->ev == ev ) {
strcpy( buff, ptr->str );
break;
}
}
uivtextput( &mainwin, evrow, 2,
UIData->attrs[ ATTR_NORMAL ],
buff, 30 );
if( ++evrow >= mainwin.area.height ){
evrow = TOP_ROW;
}
uivtextput( &mainwin, evrow, 2,
UIData->attrs[ ATTR_NORMAL ],
"", 30 );
switch( ev ) {
case EV_MOUSE_PRESS:
BandOn = 1;
uimousepos( NULL, &mrow, &mcol );
BandArea.row = mrow;
BandArea.col = mcol;
BandArea.width = 0;
BandArea.height = 0;
uibandinit( BandArea, UIData->attrs[ ATTR_ACTIVE ] );
break;
case EV_MOUSE_DRAG:
if( BandOn ) {
uimousepos( NULL, &mrow, &mcol );
diff = mcol - BandArea.col;
if( diff < 0 ) diff = 0;
BandArea.width = diff;
diff = mrow - BandArea.row;
if( diff < 0 ) diff = 0;
BandArea.height = diff;
uibandmove( BandArea );
}
break;
case EV_MOUSE_RELEASE:
if( BandOn ) uibandfini();
BandOn = 0;
break;
}
}
}
uivclose( &mainwin );
}
uinomenus();
uiswap();
uirestorebackground(); /* must be after uiswap */
finimouse();
ToGraphical();
uistop();
FiniSwapper();
return( 0 );
}
EVENT UIAPI uivfieldedit( VSCREEN *vptr, VFIELDEDIT *header )
/************************************************************/
{
register EVENT ev;
register VFIELD* cur;
auto VBUFFER buffer;
auto SAREA area;
if( header->reset ) {
header->reset = false;
header->prevfield = NULL;
header->curfield = NULL;
header->cursor = true;
area.height = 1;
for( cur = header->fieldlist ; cur != NULL ; cur = cur->link ) {
area.row = cur->row;
area.col = cur->col;
area.width = cur->length;
uivattribute( vptr, area, header->exit );
}
}
if( header->cursor ) {
header->cursor = false;
header->delpending = false;
header->fieldpending = false;
header->cancel = false;
if( vptr->cursor == C_OFF ) {
vptr->cursor = C_NORMAL;
}
return( movecursor( vptr, header, vptr->row, vptr->col ) );
}
if( header->fieldpending ) {
header->update = true;
if( header->cancel ) {
header->cancel = false;
header->curfield = NULL;
setfield( vptr, header, header->prevfield, 0 );
}
header->fieldpending = false;
}
cur = header->curfield;
if( header->update ) {
header->update = false;
if( cur ) { /* this should always be non-NULL */
uipadblanks( header->buffer, cur->length );
if( header->delpending ) {
buffer.content = header->buffer;
buffer.length = cur->length;
buffer.index = vptr->col - cur->col;
uieditevent( EV_DELETE, &buffer );
header->dirty = true;
header->delpending = false;
}
uivtextput( vptr, cur->row, cur->col, header->enter,
header->buffer, cur->length );
}
}
if( header->oktomodify ) {
uipushlist( livefieldevents );
} else {
uipushlist( deadfieldevents );
}
ev = uivgetevent( vptr );
if( ev > EV_NO_EVENT ) {
if( uiintoplist( ev ) ) {
if( cur ) {
buffer.content = header->buffer;
buffer.length = cur->length;
buffer.index = vptr->col - cur->col;
buffer.insert = ( vptr->cursor == C_INSERT );
buffer.dirty = false;
uieditevent( ev, &buffer );
header->dirty |= buffer.dirty;
}
switch( ev ) {
case EV_HOME:
if( cur != NULL ) break; /* home is within field */
/* WARNING: this case falls through to the next */
case EV_TAB_FORWARD:
case EV_TAB_BACKWARD:
cur = tabfield( vptr, header->fieldlist, ev == EV_TAB_FORWARD );
/* WARNING: the EV_HOME case falls through */
if( cur != NULL ) {
ev = setfield( vptr, header, cur, 0 );
cur = NULL; /* kludge - avoid calling movecursor */
}
break;
case EV_INSERT:
if( vptr->cursor == C_INSERT ) {
vptr->cursor = C_NORMAL ;
} else {
vptr->cursor = C_INSERT ;
}
break;
case EV_CURSOR_UP:
ev = movecursor( vptr, header, vptr->row - 1, vptr->col );
break;
case EV_CURSOR_DOWN:
ev = movecursor( vptr, header, vptr->row + 1, vptr->col );
break;
case EV_RUB_OUT:
header->delpending = true;
/* WARNING: this case falls through to the next !!!! */
case EV_CURSOR_LEFT:
if( cur ) {
if( vptr->col > cur->col ) {
break; /* cursor movement within field */
}
}
ev = movecursor( vptr, header, vptr->row, vptr->col - 1 );
break;
case EV_CURSOR_RIGHT:
case ' ':
if( header->curfield ) {
if( vptr->col < cur->col + cur->length - 1 ) {
break; /* cursor movement within field */
}
}
ev = movecursor( vptr, header, vptr->row, vptr->col + 1 );
break;
}
if( ev != EV_FIELD_CHANGE ) {
if( cur ) {
ev = movecursor( vptr, header,
vptr->row, cur->col + buffer.index );
if( buffer.dirty && ( ev == EV_NO_EVENT ) ) {
uivtextput( vptr, cur->row, cur->col, header->enter,
header->buffer, cur->length );
}
} else {
ev = EV_NO_EVENT;
}
header->delpending = false;
}
}
}
uipoplist();
return( ev );
}
static void print_field( VSCREEN *vs, VFIELD *field, bool current )
{
SAREA *area;
ATTR attr;
ATTR hotattr;
char ctrlbuf[CTRL_BUF_LEN + 1];
unsigned ctrlbuf_len = 0;
a_check *check = NULL;
a_radio *radio = NULL;
a_list *list;
a_combo_box *combo;
an_edit_control *edit;
VSCREEN *c_vs;
SAREA c_area;
bool use_hottext;
char hotkey;
UIPICKGETTEXT *fn_get;
if( field == NULL )
return;
area = &field->area;
use_hottext = false;
memset( ctrlbuf, '\0', CTRL_BUF_LEN + 1 );
attr = UIData->attrs[( current ) ? ATTR_CURR_EDIT : ATTR_EDIT];
switch( field->typ ) {
case FLD_HOT :
if( current ) {
field->u.hs->flags |= HOT_CURRENT ;
} else {
field->u.hs->flags &= (~HOT_CURRENT);
}
uidisplayhotspot( vs, field );
return;
case FLD_TEXT :
attr = UIData->attrs[ATTR_NORMAL];
uivtextput( vs, area->row, area->col, attr, field->u.str, area->width );
uirefresh();
return;
case FLD_LABEL :
attr = UIData->attrs[ATTR_NORMAL];
strcpy( ctrlbuf, field->u.str );
strcat( ctrlbuf, ":" );
ctrlbuf_len = strlen( ctrlbuf );
break;
case FLD_FRAME :
uidrawbox( vs, area, UIData->attrs[ATTR_NORMAL], field->u.str );
return;
case FLD_EDIT :
case FLD_INVISIBLE_EDIT :
edit = field->u.edit;
if( edit->buffer != NULL ) {
ctrlbuf_len = edit->length;
if( ctrlbuf_len > CTRL_BUF_LEN )
ctrlbuf_len = CTRL_BUF_LEN;
if( field->typ == FLD_INVISIBLE_EDIT ) {
memset( ctrlbuf, '*', ctrlbuf_len );
} else {
strncpy( ctrlbuf, edit->buffer, ctrlbuf_len );
}
} else {
ctrlbuf_len = 0;
}
break;
case FLD_COMBOBOX :
combo = field->u.combo;
edit = &combo->edit;
list = &combo->list;
if( !combo->perm ) {
ctrlbuf[0] = UiGChar[UI_ARROW_DOWN];
uivtextput( vs, area->row, area->col + area->width + 1,
UIData->attrs[ATTR_SCROLL_ICON], ctrlbuf, 1 );
ctrlbuf[0] = '\0';
}
if( edit->buffer != NULL ) {
ctrlbuf_len = edit->length;
if( ctrlbuf_len > CTRL_BUF_LEN )
ctrlbuf_len = CTRL_BUF_LEN;
strncpy( ctrlbuf, edit->buffer, ctrlbuf_len );
} else {
ctrlbuf_len = 0;
}
if( list->box == NULL && combo->perm ) {
c_area = *area;
c_area.row += vs->area.row + 2;
c_area.col += vs->area.col + 1;
c_vs = uiopen( &c_area, NULL, V_DIALOGUE | V_LISTBOX );
if( c_vs == NULL ) {
break;
}
c_area.row = 0;
c_area.col = 0;
list->box = uibeglistbox( c_vs, &c_area, list );
}
break;
case FLD_PULLDOWN :
list = field->u.list;
ctrlbuf[0] = UiGChar[UI_ARROW_DOWN];
uivtextput( vs, area->row, area->col + area->width,
UIData->attrs[ATTR_SCROLL_ICON], ctrlbuf, 1 );
ctrlbuf[0] = '\0';
fn_get = list->get;
if( fn_get == NULL )
fn_get = uigetlistelement;
(*fn_get)( list->data_handle, list->choice, ctrlbuf, CTRL_BUF_LEN );
/* ctrlbuf does not have to be null terminated */
/* terminate it at maximum length */
ctrlbuf[CTRL_BUF_LEN] = '\0';
ctrlbuf_len = strlen( ctrlbuf );
break;
case FLD_LISTBOX:
case FLD_EDIT_MLE:
list = field->u.list;
if( list->box == NULL ) {
c_area = *area;
c_area.row += ((VSCREEN *)vs)->area.row;
c_area.col += ((VSCREEN *)vs)->area.col;
c_vs = uiopen( &c_area, NULL, V_DIALOGUE | V_LISTBOX );
if( c_vs == NULL ) {
break;
}
c_area.row = 0;
c_area.col = 0;
list->box = uibeglistbox( c_vs, &c_area, list );
}
return;
case FLD_CHECK:
/* ctrlbuf must be null terminated for this case */
use_hottext = true;
attr = UIData->attrs[( current ) ? ATTR_CURR_EDIT : ATTR_NORMAL];
check = field->u.check;
ctrlbuf[0] = CHECKBOX_CHAR( LEFT );
if( _checked( check ) ) {
ctrlbuf[1] = CHECKBOX_CHAR( FULL );
} else {
ctrlbuf[1] = CHECKBOX_CHAR( EMPTY );
}
ctrlbuf[2] = CHECKBOX_CHAR( RIGHT );
ctrlbuf[3] = ' ';
strncat( ctrlbuf, check->str, CTRL_BUF_LEN - 4 );
break;
case FLD_RADIO:
/* ctrlbuf must be null terminated for this case */
use_hottext = true;
attr = UIData->attrs[( current ) ? ATTR_CURR_EDIT : ATTR_NORMAL];
radio = field->u.radio;
ctrlbuf[0] = RADIO_CHAR( LEFT );
if( radio->value == radio->group->value ) {
ctrlbuf[1] = RADIO_CHAR( FULL );
} else {
ctrlbuf[1] = RADIO_CHAR( EMPTY );
}
ctrlbuf[2] = RADIO_CHAR( RIGHT );
ctrlbuf[3] = ' ';
strncat( ctrlbuf, radio->str, CTRL_BUF_LEN - 4 );
break;
}
if( use_hottext ) {
if( current ) {
hotattr = attr;
} else {
hotattr = UIData->attrs[ATTR_RADIO_HOTSPOT];
}
hotkey = uidrawhottext( vs, ctrlbuf, area, attr, hotattr, false, false, false );
if( field->typ == FLD_CHECK ) {
check->hotkey = hotkey;
} else if( field->typ == FLD_RADIO ) {
radio->hotkey = hotkey;
}
} else {
uitextfield( vs, area->row, area->col, area->width, attr, ctrlbuf, ctrlbuf_len );
}
}
void GUIXDrawText( gui_window *wnd, const char *text, size_t length, gui_coord *in_pos,
gui_attr attr, gui_ord extentx, bool draw_extent )
{
int vscroll; /* vertical scroll adjust amount */
int hscroll; /* horizontal scroll adjust amount */
size_t my_length; /* actual length of text (may be > length) */
gui_coord my_pos; /* pos in screen coords */
int pos; /* position to draw on VSCREEN */
int col; /* index into string */
gui_coord extent;
SAREA area;
int width;
int frame_adjust;
if( attr >= wnd->num_attrs ) {
return;
}
if( !( wnd->style & GUI_VISIBLE ) ) {
return;
}
if( wnd->style & GUI_NOFRAME ) {
frame_adjust = 0;
} else {
frame_adjust = 1;
}
my_pos.x = in_pos->x;
my_pos.y = in_pos->y;
GUIScaleToScreenR( &my_pos );
/* adjust for scrolling */
vscroll = 0;
if( ( wnd->vgadget != NULL ) && ( !GUI_VSCROLL_EVENTS_SET( wnd ) ) ) {
vscroll += wnd->vgadget->pos;
}
hscroll = 0;
if( ( wnd->hgadget != NULL ) && !GUI_HSCROLL_EVENTS_SET( wnd ) ) {
hscroll += wnd->hgadget->pos;
}
if( ( my_pos.y - vscroll + frame_adjust ) < frame_adjust ) {
/* row to draw is not visible with vertical scrolling */
return;
}
if( text != NULL ) {
my_length = strlen( text );
if( my_length < length ) {
length = my_length;
}
} else {
my_length = 0;
}
/* if text shows even with scrolling */
if( ( my_pos.x + length ) > hscroll ) {
pos = frame_adjust; /* position on VSCREEN */
col = 0; /* index into curr string */
/* start of text in dirty region */
if( ( ( wnd->dirty.col - 1 ) <= ( my_pos.x - hscroll ) ) &&
( my_pos.x >= hscroll ) ) {
pos += ( my_pos.x - hscroll );
} else {
/* start of text to left of dirty region */
pos += wnd->dirty.col - 1;
if( my_pos.x < hscroll ) {
/* start of text scrolled off screen */
col += ( hscroll - my_pos.x + wnd->dirty.col - 1 );
length -= ( hscroll - my_pos.x + wnd->dirty.col - 1 );
} else {
/* start of text visible but to left of dirty region */
col += ( wnd->dirty.col - 1 + hscroll - my_pos.x );
length -= ( wnd->dirty.col - 1 + hscroll - my_pos.x );
}
}
/* should deal with decreasing length due to text off screen
to right */
if( ( length > 0 ) &&
( ( col - hscroll ) < ( wnd->dirty.col + wnd->dirty.width ) ) ) {
if( ( pos + length ) > ( wnd->dirty.col + wnd->dirty.width ) ) {
length = wnd->dirty.col + wnd->dirty.width - pos;
}
if( length > 0 ) {
char *p;
const char *cp;
for( cp = text; cp < text+col; cp += GUICharLen( *cp ) ) ;
if( cp != text + col ) {
p = alloca( length );
cp = memcpy( p, text+col, length );
p[0] = ' ';
}
uivtextput( &wnd->screen, my_pos.y - vscroll + frame_adjust,
pos, wnd->colours[attr], cp, length );
} else {
length = 0;
}
} else {
length = 0;
}
} else {
pos = -length + 1; /* so (pos+length) will be 1 for drawing extent */
}
if( draw_extent ) {
if( extentx == GUI_NO_COLUMN ) {
/* this is the most that will be covered. It will be adjust for
starting position and dirty rect */
extentx = wnd->use.width;
} else {
/* record total width user wants to cover, adjusting for
* portion not visible due to scrolling scrolling
*/
extent.x = extentx + in_pos->x;
GUIScaleToScreenR( &extent );
extentx = extent.x - hscroll;
}
if( ( pos + length ) <= extentx ) {
area.row = my_pos.y - vscroll + frame_adjust;
area.height = 1;
area.col = pos + length;
/* adjust left border for dirty area */
if( area.col < wnd->dirty.col ) {
area.col = wnd->dirty.col;
}
width = extentx - area.col + 1;
/* adjust right border for dirty area */
if( ( area.col + width ) > ( wnd->dirty.col + wnd->dirty.width ) ) {
width = wnd->dirty.width + wnd->dirty.col - area.col;
}
if( width > 0 ) {
area.width = width;
uivfill( &wnd->screen, area, wnd->colours[attr], ' ' );
}
}
}
}
