/**************************************************************************
...
**************************************************************************/
static int widget_core_redraw(struct widget *pwidget)
{
if (!pwidget || (get_wflags(pwidget) & WF_HIDDEN)) {
return -1;
}
if (pwidget->gfx) {
widget_undraw(pwidget);
}
if (!pwidget->gfx && (get_wflags(pwidget) & WF_RESTORE_BACKGROUND)) {
refresh_widget_background(pwidget);
}
return 0;
}
/**************************************************************************
Universal redraw Group of Widget function. Function is optimized to
WindowGroup: start draw from 'pEnd' and stop on 'pBegin', in theory
'pEnd' is window widget;
**************************************************************************/
Uint16 redraw_group(const struct widget *pBeginGroupWidgetList,
const struct widget *pEndGroupWidgetList,
int add_to_update)
{
Uint16 count = 0;
struct widget *pTmpWidget = (struct widget *) pEndGroupWidgetList;
while (pTmpWidget) {
if ((get_wflags(pTmpWidget) & WF_HIDDEN) != WF_HIDDEN) {
widget_redraw(pTmpWidget);
if (add_to_update) {
widget_mark_dirty(pTmpWidget);
}
count++;
}
if (pTmpWidget == pBeginGroupWidgetList) {
break;
}
pTmpWidget = pTmpWidget->prev;
}
return count;
}
/**************************************************************************
set new x, y position and redraw edit.
**************************************************************************/
int draw_edit(struct widget *pEdit, Sint16 start_x, Sint16 start_y)
{
pEdit->size.x = start_x;
pEdit->size.y = start_y;
if (get_wflags(pEdit) & WF_RESTORE_BACKGROUND) {
refresh_widget_background(pEdit);
}
return redraw_edit(pEdit);
}
/**************************************************************************
...
**************************************************************************/
int draw_icon(struct widget *pIcon, Sint16 start_x, Sint16 start_y)
{
pIcon->size.x = start_x;
pIcon->size.y = start_y;
if (get_wflags(pIcon) & WF_RESTORE_BACKGROUND) {
refresh_widget_background(pIcon);
}
return draw_icon_from_theme(pIcon->theme, get_wstate(pIcon), pIcon->dst,
pIcon->size.x, pIcon->size.y);
}
/**************************************************************************
...
**************************************************************************/
static void widget_core_undraw(struct widget *pwidget)
{
if (get_wflags(pwidget) & WF_RESTORE_BACKGROUND) {
if (pwidget->gfx) {
clear_surface(pwidget->dst->surface, &pwidget->size);
blit_entire_src(pwidget->gfx, pwidget->dst->surface,
pwidget->size.x, pwidget->size.y);
}
} else {
clear_surface(pwidget->dst->surface, &pwidget->size);
}
}
/**************************************************************************
...
**************************************************************************/
int setup_vertical_widgets_position(int step,
Sint16 start_x, Sint16 start_y, Uint16 w, Uint16 h,
struct widget *pBegin, struct widget *pEnd)
{
struct widget *pBuf = pEnd;
register int count = 0;
register int real_start_x = start_x;
int ret = 0;
while(pBuf)
{
pBuf->size.x = real_start_x;
pBuf->size.y = start_y;
if(w) {
pBuf->size.w = w;
}
if(h) {
pBuf->size.h = h;
}
if(!((count + 1) % step)) {
real_start_x = start_x;
start_y += pBuf->size.h;
if (((get_wflags(pBuf) & WF_HIDDEN) != WF_HIDDEN))
{
ret += pBuf->size.h;
}
} else {
real_start_x += pBuf->size.w;
}
if(pBuf == pBegin) {
break;
}
count++;
pBuf = pBuf->prev;
}
return ret;
}
/**************************************************************************
Sellect widget. Redraw this widget;
**************************************************************************/
void widget_sellected_action(struct widget *pWidget)
{
if (!pWidget || pWidget == pSellected_Widget) {
return;
}
if (pSellected_Widget) {
unsellect_widget_action();
}
set_wstate(pWidget, FC_WS_SELLECTED);
pWidget->select(pWidget);
pSellected_Widget = pWidget ;
if (get_wflags(pWidget) & WF_WIDGET_HAS_INFO_LABEL) {
widget_info_counter = 1;
}
}
/**************************************************************************
Find the next visible widget in the widget list starting with
pStartWidget that is drawn at position (x, y). If pStartWidget is NULL,
the search starts with the first entry of the main widget list.
**************************************************************************/
struct widget *find_next_widget_at_pos(struct widget *pStartWidget, int x, int y)
{
SDL_Rect area = {0, 0, 0, 0};
struct widget *pWidget;
pWidget = pStartWidget ? pStartWidget : pBeginMainWidgetList;
while (pWidget) {
area.x = pWidget->dst->dest_rect.x + pWidget->size.x;
area.y = pWidget->dst->dest_rect.y + pWidget->size.y;
area.w = pWidget->size.w;
area.h = pWidget->size.h;
if (is_in_rect_area(x, y, area)
&& !((get_wflags(pWidget) & WF_HIDDEN) == WF_HIDDEN)) {
return (struct widget *) pWidget;
}
pWidget = pWidget->next;
}
return NULL;
}
/**************************************************************************
Unsellect (sellected) widget and redraw this widget;
**************************************************************************/
void unsellect_widget_action(void)
{
if (pSellected_Widget && (get_wstate(pSellected_Widget) != FC_WS_DISABLED)) {
set_wstate(pSellected_Widget, FC_WS_NORMAL);
if (!(get_wflags(pSellected_Widget) & WF_HIDDEN)) {
pSellected_Widget->unselect(pSellected_Widget);
/* turn off quick info timer/counter */
widget_info_counter = 0;
}
}
if (pInfo_Area) {
flush_rect(*pInfo_Area, FALSE);
FC_FREE(pInfo_Area);
FREESURFACE(pInfo_Label);
}
pSellected_Widget = NULL;
}
/**************************************************************************
Find the next enabled and visible widget in the widget list starting
with pStartWidget that handles the given key. If pStartWidget is NULL,
the search starts with the first entry of the main widget list.
NOTE: This function ignores CapsLock and NumLock Keys.
**************************************************************************/
struct widget *find_next_widget_for_key(struct widget *pStartWidget,
SDL_keysym key)
{
struct widget *pWidget;
pWidget = pStartWidget ? pStartWidget : pBeginMainWidgetList;
key.mod &= ~(KMOD_NUM | KMOD_CAPS);
while (pWidget) {
if ((pWidget->key == key.sym ||
(pWidget->key == SDLK_RETURN && key.sym == SDLK_KP_ENTER) ||
(pWidget->key == SDLK_KP_ENTER && key.sym == SDLK_RETURN)) &&
((pWidget->mod & key.mod) || (pWidget->mod == key.mod))) {
if (!((get_wstate(pWidget) == FC_WS_DISABLED) ||
((get_wflags(pWidget) & WF_HIDDEN) == WF_HIDDEN))) {
return (struct widget *) pWidget;
}
}
pWidget = pWidget->next;
}
return NULL;
}
/**************************************************************************
...
**************************************************************************/
void widget_free(struct widget **pWidget)
{
struct widget *pGUI = *pWidget;
if ((get_wflags(pGUI) & WF_FREE_STRING) == WF_FREE_STRING) {
FREESTRING16(pGUI->string16);
}
if ((get_wflags(pGUI) & WF_WIDGET_HAS_INFO_LABEL)
== WF_WIDGET_HAS_INFO_LABEL) {
FREESTRING16(pGUI->info_label);
}
if ((get_wflags(pGUI) & WF_FREE_GFX) == WF_FREE_GFX) {
FREESURFACE(pGUI->gfx);
}
if ((get_wflags(pGUI) & WF_FREE_THEME) == WF_FREE_THEME) {
if (get_wtype(pGUI) == WT_CHECKBOX) {
FREESURFACE(pGUI->private_data.cbox->pTRUE_Theme);
FREESURFACE(pGUI->private_data.cbox->pFALSE_Theme);
} else {
FREESURFACE(pGUI->theme);
}
}
if ((get_wflags(pGUI) & WF_FREE_THEME2) == WF_FREE_THEME2) {
FREESURFACE(pGUI->theme2);
}
if ((get_wflags(pGUI) & WF_FREE_DATA) == WF_FREE_DATA) {
FC_FREE(pGUI->data.ptr);
}
if ((get_wflags(pGUI) & WF_FREE_PRIVATE_DATA) == WF_FREE_PRIVATE_DATA) {
FC_FREE(pGUI->private_data.ptr);
}
if (NULL != pGUI->destroy) {
pGUI->destroy(pGUI);
}
FC_FREE(*pWidget);
}
/**************************************************************************
Create Icon Button image with text and Icon then blit to Dest(ination)
on positon pIButton->size.x , pIButton->size.y.
WARRING: pDest must exist.
Text with atributes is taken from pIButton->string16 parameter.
Graphic for button is taken from pIButton->theme surface
and blit to new created image.
Graphic for Icon is taken from pIButton->theme2 surface and blit to new
created image.
function return (-1) if there are no Icon and Text.
Else return 0.
**************************************************************************/
static int redraw_ibutton(struct widget *pIButton)
{
SDL_Rect dest = { 0, 0, 0, 0 };
SDL_String16 TMPString;
SDL_Surface *pButton = NULL, *pText = NULL, *pIcon = pIButton->theme2;
Uint16 Ix, Iy, x;
Uint16 y = 0; /* FIXME: possibly uninitialized */
int ret;
ret = (*baseclass_redraw)(pIButton);
if (ret != 0) {
return ret;
}
if (pIButton->string16) {
/* make copy of string16 */
TMPString = *pIButton->string16;
if (get_wstate(pIButton) == FC_WS_NORMAL) {
TMPString.fgcol = *get_theme_color(COLOR_THEME_WIDGET_NORMAL_TEXT);
} else if (get_wstate(pIButton) == FC_WS_SELLECTED) {
TMPString.fgcol = *get_theme_color(COLOR_THEME_WIDGET_SELECTED_TEXT);
TMPString.style |= TTF_STYLE_BOLD;
} else if (get_wstate(pIButton) == FC_WS_PRESSED) {
TMPString.fgcol = *get_theme_color(COLOR_THEME_WIDGET_PRESSED_TEXT);
} else if (get_wstate(pIButton) == FC_WS_DISABLED) {
TMPString.fgcol = *get_theme_color(COLOR_THEME_WIDGET_DISABLED_TEXT);
}
pText = create_text_surf_from_str16(&TMPString);
}
if (!pText && !pIcon) {
return -1;
}
/* create Button graphic */
pButton = create_bcgnd_surf(pIButton->theme, get_wstate(pIButton),
pIButton->size.w, pIButton->size.h);
clear_surface(pIButton->dst->surface, &pIButton->size);
alphablit(pButton, NULL, pIButton->dst->surface, &pIButton->size);
FREESURFACE(pButton);
if (pIcon) { /* Icon */
if (pText) {
if (get_wflags(pIButton) & WF_ICON_CENTER_RIGHT) {
Ix = pIButton->size.w - pIcon->w - 5;
} else {
if (get_wflags(pIButton) & WF_ICON_CENTER) {
Ix = (pIButton->size.w - pIcon->w) / 2;
} else {
Ix = 5;
}
}
if (get_wflags(pIButton) & WF_ICON_ABOVE_TEXT) {
Iy = 3;
y = 3 + pIcon->h + 3 + (pIButton->size.h -
(pIcon->h + 6) - pText->h) / 2;
} else {
if (get_wflags(pIButton) & WF_ICON_UNDER_TEXT) {
y = 3 + (pIButton->size.h - (pIcon->h + 3) - pText->h) / 2;
Iy = y + pText->h + 3;
} else { /* center */
Iy = (pIButton->size.h - pIcon->h) / 2;
y = (pIButton->size.h - pText->h) / 2;
}
}
} else { /* no text */
Iy = (pIButton->size.h - pIcon->h) / 2;
Ix = (pIButton->size.w - pIcon->w) / 2;
}
if (get_wstate(pIButton) == FC_WS_PRESSED) {
Ix += 1;
Iy += 1;
}
dest.x = pIButton->size.x + Ix;
dest.y = pIButton->size.y + Iy;
ret = alphablit(pIcon, NULL, pIButton->dst->surface, &dest);
if (ret) {
FREESURFACE(pText);
return ret - 10;
}
}
if (pText) {
if (pIcon) {
if (!(get_wflags(pIButton) & WF_ICON_ABOVE_TEXT) &&
!(get_wflags(pIButton) & WF_ICON_UNDER_TEXT)) {
if (get_wflags(pIButton) & WF_ICON_CENTER_RIGHT) {
if (pIButton->string16->style & SF_CENTER) {
x = (pIButton->size.w - (pIcon->w + 5) - pText->w) / 2;
} else {
if (pIButton->string16->style & SF_CENTER_RIGHT) {
x = pIButton->size.w - (pIcon->w + 7) - pText->w;
} else {
x = 5;
}
}
} /* end WF_ICON_CENTER_RIGHT */
else {
if (get_wflags(pIButton) & WF_ICON_CENTER) {
/* text is blit on icon */
goto Alone;
} /* end WF_ICON_CENTER */
else { /* icon center left - default */
if (pIButton->string16->style & SF_CENTER) {
x = 5 + pIcon->w + ((pIButton->size.w -
(pIcon->w + 5) - pText->w) / 2);
} else {
if (pIButton->string16->style & SF_CENTER_RIGHT) {
x = pIButton->size.w - pText->w - 5;
} else { /* text center left */
x = 5 + pIcon->w + 3;
}
}
} /* end icon center left - default */
}
/* 888888888888888888 */
} else {
goto Alone;
}
} else {
/* !pIcon */
y = (pIButton->size.h - pText->h) / 2;
Alone:
if (pIButton->string16->style & SF_CENTER) {
x = (pIButton->size.w - pText->w) / 2;
} else {
if (pIButton->string16->style & SF_CENTER_RIGHT) {
x = pIButton->size.w - pText->w - 5;
} else {
x = 5;
}
}
}
if (get_wstate(pIButton) == FC_WS_PRESSED) {
x += 1;
} else {
y -= 1;
}
dest.x = pIButton->size.x + x;
dest.y = pIButton->size.y + y;
ret = alphablit(pText, NULL, pIButton->dst->surface, &dest);
}
FREESURFACE(pText);
return 0;
}
/**************************************************************************
This functions are pure madness :)
Create Edit Field surface ( with Text) and blit them to Main.screen,
on position 'pEdit_Widget->size.x , pEdit_Widget->size.y'
Main role of this functions are been text input to GUI.
This code allow you to add, del unichar from unistring.
Graphic is taken from 'pEdit_Widget->theme'
OldText is taken from 'pEdit_Widget->sting16'
NewText is returned to 'pEdit_Widget->sting16' ( after free OldText )
if flag 'FW_DRAW_THEME_TRANSPARENT' is set theme will be blit
transparent ( Alpha = 128 )
NOTE: This functions can return NULL in 'pEdit_Widget->sting16->text' but
never free 'pEdit_Widget->sting16' struct.
**************************************************************************/
static Uint16 edit_key_down(SDL_keysym Key, void *pData)
{
struct EDIT *pEdt = (struct EDIT *)pData;
struct UniChar *pInputChain_TMP;
bool Redraw = FALSE;
/* find which key is pressed */
switch (Key.sym) {
case SDLK_ESCAPE:
/* exit from loop without changes */
return ED_ESC;
case SDLK_RETURN:
case SDLK_KP_ENTER:
/* exit from loop */
return ED_RETURN;
case SDLK_KP6:
if(Key.mod & KMOD_NUM) {
goto INPUT;
}
case SDLK_RIGHT:
{
/* move cursor right */
if (pEdt->pInputChain->next) {
if (pEdt->InputChain_X >= (pEdt->pWidget->size.x + pEdt->pBg->w - adj_size(10))) {
pEdt->Start_X -= pEdt->pInputChain->pTsurf->w -
(pEdt->pWidget->size.x + pEdt->pBg->w - adj_size(5) - pEdt->InputChain_X);
}
pEdt->pInputChain = pEdt->pInputChain->next;
Redraw = TRUE;
}
}
break;
case SDLK_KP4:
if(Key.mod & KMOD_NUM) {
goto INPUT;
}
case SDLK_LEFT:
{
/* move cursor left */
if (pEdt->pInputChain->prev) {
pEdt->pInputChain = pEdt->pInputChain->prev;
if ((pEdt->InputChain_X <=
(pEdt->pWidget->size.x + adj_size(9))) && (pEdt->Start_X != adj_size(5))) {
if (pEdt->InputChain_X != (pEdt->pWidget->size.x + adj_size(5))) {
pEdt->Start_X += (pEdt->pWidget->size.x - pEdt->InputChain_X + adj_size(5));
}
pEdt->Start_X += (pEdt->pInputChain->pTsurf->w);
}
Redraw = TRUE;
}
}
break;
case SDLK_KP7:
if(Key.mod & KMOD_NUM) {
goto INPUT;
}
case SDLK_HOME:
{
/* move cursor to begin of chain (and edit field) */
pEdt->pInputChain = pEdt->pBeginTextChain;
Redraw = TRUE;
pEdt->Start_X = adj_size(5);
}
break;
case SDLK_KP1:
if(Key.mod & KMOD_NUM) {
goto INPUT;
}
case SDLK_END:
{
/* move cursor to end of chain (and edit field) */
pEdt->pInputChain = pEdt->pEndTextChain;
Redraw = TRUE;
if (pEdt->pWidget->size.w - pEdt->Truelength < 0) {
pEdt->Start_X = pEdt->pWidget->size.w - pEdt->Truelength - adj_size(5);
}
}
break;
case SDLK_BACKSPACE:
{
/* del element of chain (and move cursor left) */
if (pEdt->pInputChain->prev) {
if ((pEdt->InputChain_X <=
(pEdt->pWidget->size.x + adj_size(9))) && (pEdt->Start_X != adj_size(5))) {
if (pEdt->InputChain_X != (pEdt->pWidget->size.x + adj_size(5))) {
pEdt->Start_X += (pEdt->pWidget->size.x - pEdt->InputChain_X + adj_size(5));
}
pEdt->Start_X += (pEdt->pInputChain->prev->pTsurf->w);
}
if (pEdt->pInputChain->prev->prev) {
pEdt->pInputChain->prev->prev->next = pEdt->pInputChain;
pInputChain_TMP = pEdt->pInputChain->prev->prev;
pEdt->Truelength -= pEdt->pInputChain->prev->pTsurf->w;
FREESURFACE(pEdt->pInputChain->prev->pTsurf);
FC_FREE(pEdt->pInputChain->prev);
pEdt->pInputChain->prev = pInputChain_TMP;
} else {
pEdt->Truelength -= pEdt->pInputChain->prev->pTsurf->w;
FREESURFACE(pEdt->pInputChain->prev->pTsurf);
FC_FREE(pEdt->pInputChain->prev);
pEdt->pBeginTextChain = pEdt->pInputChain;
}
pEdt->ChainLen--;
Redraw = TRUE;
}
}
break;
case SDLK_KP_PERIOD:
if(Key.mod & KMOD_NUM) {
goto INPUT;
}
case SDLK_DELETE:
{
/* del element of chain */
if (pEdt->pInputChain->next && pEdt->pInputChain->prev) {
pEdt->pInputChain->prev->next = pEdt->pInputChain->next;
pEdt->pInputChain->next->prev = pEdt->pInputChain->prev;
pInputChain_TMP = pEdt->pInputChain->next;
pEdt->Truelength -= pEdt->pInputChain->pTsurf->w;
FREESURFACE(pEdt->pInputChain->pTsurf);
FC_FREE(pEdt->pInputChain);
pEdt->pInputChain = pInputChain_TMP;
pEdt->ChainLen--;
Redraw = TRUE;
}
if (pEdt->pInputChain->next && !pEdt->pInputChain->prev) {
pEdt->pInputChain = pEdt->pInputChain->next;
pEdt->Truelength -= pEdt->pInputChain->prev->pTsurf->w;
FREESURFACE(pEdt->pInputChain->prev->pTsurf);
FC_FREE(pEdt->pInputChain->prev);
pEdt->pBeginTextChain = pEdt->pInputChain;
pEdt->ChainLen--;
Redraw = TRUE;
}
}
break;
default:
{
INPUT:/* add new element of chain (and move cursor right) */
if (Key.unicode) {
if (pEdt->pInputChain != pEdt->pBeginTextChain) {
pInputChain_TMP = pEdt->pInputChain->prev;
pEdt->pInputChain->prev = fc_calloc(1, sizeof(struct UniChar));
pEdt->pInputChain->prev->next = pEdt->pInputChain;
pEdt->pInputChain->prev->prev = pInputChain_TMP;
pInputChain_TMP->next = pEdt->pInputChain->prev;
} else {
pEdt->pInputChain->prev = fc_calloc(1, sizeof(struct UniChar));
pEdt->pInputChain->prev->next = pEdt->pInputChain;
pEdt->pBeginTextChain = pEdt->pInputChain->prev;
}
pEdt->pInputChain->prev->chr[0] = Key.unicode;
pEdt->pInputChain->prev->chr[1] = '\0';
if (pEdt->pInputChain->prev->chr) {
if (get_wflags(pEdt->pWidget) & WF_PASSWD_EDIT) {
Uint16 passwd_chr[2] = {'*', '\0'};
pEdt->pInputChain->prev->pTsurf =
TTF_RenderUNICODE_Blended(pEdt->pWidget->string16->font,
passwd_chr,
pEdt->pWidget->string16->fgcol);
} else {
pEdt->pInputChain->prev->pTsurf =
TTF_RenderUNICODE_Blended(pEdt->pWidget->string16->font,
pEdt->pInputChain->prev->chr,
pEdt->pWidget->string16->fgcol);
}
pEdt->Truelength += pEdt->pInputChain->prev->pTsurf->w;
}
if (pEdt->InputChain_X >= pEdt->pWidget->size.x + pEdt->pBg->w - adj_size(10)) {
if (pEdt->pInputChain == pEdt->pEndTextChain) {
pEdt->Start_X = pEdt->pBg->w - adj_size(5) - pEdt->Truelength;
} else {
pEdt->Start_X -= pEdt->pInputChain->prev->pTsurf->w -
(pEdt->pWidget->size.x + pEdt->pBg->w - adj_size(5) - pEdt->InputChain_X);
}
}
pEdt->ChainLen++;
Redraw = TRUE;
}
}
break;
} /* key pressed switch */
if (Redraw) {
redraw_edit_chain(pEdt);
}
return ID_ERROR;
}
/**************************************************************************
Create Edit Field surface ( with Text) and blit them to Main.screen,
on position 'pEdit_Widget->size.x , pEdit_Widget->size.y'
Graphic is taken from 'pEdit_Widget->theme'
Text is taken from 'pEdit_Widget->sting16'
if flag 'FW_DRAW_THEME_TRANSPARENT' is set theme will be blit
transparent ( Alpha = 128 )
function return Hight of created surfaces or (-1) if theme surface can't
be created.
**************************************************************************/
static int redraw_edit(struct widget *pEdit_Widget)
{
int ret;
if (get_wstate(pEdit_Widget) == FC_WS_PRESSED) {
return redraw_edit_chain((struct EDIT *)pEdit_Widget->data.ptr);
} else {
int iRet = 0;
SDL_Rect rDest = {pEdit_Widget->size.x, pEdit_Widget->size.y, 0, 0};
SDL_Surface *pEdit = NULL;
SDL_Surface *pText;
ret = (*baseclass_redraw)(pEdit_Widget);
if (ret != 0) {
return ret;
}
if (pEdit_Widget->string16->text &&
get_wflags(pEdit_Widget) & WF_PASSWD_EDIT) {
Uint16 *backup = pEdit_Widget->string16->text;
size_t len = unistrlen(backup) + 1;
char *cBuf = fc_calloc(1, len);
memset(cBuf, '*', len - 1);
cBuf[len - 1] = '\0';
pEdit_Widget->string16->text = convert_to_utf16(cBuf);
pText = create_text_surf_from_str16(pEdit_Widget->string16);
FC_FREE(pEdit_Widget->string16->text);
FC_FREE(cBuf);
pEdit_Widget->string16->text = backup;
} else {
pText = create_text_surf_from_str16(pEdit_Widget->string16);
}
pEdit = create_bcgnd_surf(pEdit_Widget->theme, get_wstate(pEdit_Widget),
pEdit_Widget->size.w, pEdit_Widget->size.h);
if (!pEdit) {
return -1;
}
/* blit theme */
alphablit(pEdit, NULL, pEdit_Widget->dst->surface, &rDest);
/* set position and blit text */
if (pText) {
rDest.y += (pEdit->h - pText->h) / 2;
/* blit centred text to botton */
if (pEdit_Widget->string16->style & SF_CENTER) {
rDest.x += (pEdit->w - pText->w) / 2;
} else {
if (pEdit_Widget->string16->style & SF_CENTER_RIGHT) {
rDest.x += pEdit->w - pText->w - adj_size(5);
} else {
rDest.x += adj_size(5); /* cennter left */
}
}
alphablit(pText, NULL, pEdit_Widget->dst->surface, &rDest);
}
/* pText */
iRet = pEdit->h;
/* Free memory */
FREESURFACE(pText);
FREESURFACE(pEdit);
return iRet;
}
return 0;
}
enum Edit_Return_Codes edit_field(struct widget *pEdit_Widget)
{
struct EDIT pEdt;
struct UniChar ___last;
struct UniChar *pInputChain_TMP = NULL;
enum Edit_Return_Codes ret;
void *backup = pEdit_Widget->data.ptr;
pEdt.pWidget = pEdit_Widget;
pEdt.ChainLen = 0;
pEdt.Truelength = 0;
pEdt.Start_X = adj_size(5);
pEdt.InputChain_X = 0;
pEdit_Widget->data.ptr = (void *)&pEdt;
#if 0
SDL_EnableUNICODE(1);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
#endif
pEdt.pBg = create_bcgnd_surf(pEdit_Widget->theme, 2,
pEdit_Widget->size.w, pEdit_Widget->size.h);
/* Creating Chain */
pEdt.pBeginTextChain = text2chain(pEdit_Widget->string16->text);
/* Creating Empty (Last) pice of Chain */
pEdt.pInputChain = &___last;
pEdt.pEndTextChain = pEdt.pInputChain;
pEdt.pEndTextChain->chr[0] = 32; /*spacebar */
pEdt.pEndTextChain->chr[1] = 0; /*spacebar */
pEdt.pEndTextChain->next = NULL;
pEdt.pEndTextChain->prev = NULL;
/* set font style (if any ) */
if (!((pEdit_Widget->string16->style & 0x0F) & TTF_STYLE_NORMAL)) {
TTF_SetFontStyle(pEdit_Widget->string16->font,
(pEdit_Widget->string16->style & 0x0F));
}
pEdt.pEndTextChain->pTsurf =
TTF_RenderUNICODE_Blended(pEdit_Widget->string16->font,
pEdt.pEndTextChain->chr,
pEdit_Widget->string16->fgcol);
/* create surface for each font in chain and find chain length */
if (pEdt.pBeginTextChain) {
pInputChain_TMP = pEdt.pBeginTextChain;
while (TRUE) {
pEdt.ChainLen++;
if (get_wflags(pEdit_Widget) & WF_PASSWD_EDIT) {
const Uint16 passwd_chr[2] = {'*', '\0'};
pInputChain_TMP->pTsurf =
TTF_RenderUNICODE_Blended(pEdit_Widget->string16->font,
passwd_chr,
pEdit_Widget->string16->fgcol);
} else {
pInputChain_TMP->pTsurf =
TTF_RenderUNICODE_Blended(pEdit_Widget->string16->font,
pInputChain_TMP->chr,
pEdit_Widget->string16->fgcol);
}
pEdt.Truelength += pInputChain_TMP->pTsurf->w;
if (pInputChain_TMP->next == NULL) {
break;
}
pInputChain_TMP = pInputChain_TMP->next;
}
/* set terminator of list */
pInputChain_TMP->next = pEdt.pInputChain;
pEdt.pInputChain->prev = pInputChain_TMP;
pInputChain_TMP = NULL;
} else {
pEdt.pBeginTextChain = pEdt.pInputChain;
}
redraw_edit_chain(&pEdt);
set_wstate(pEdit_Widget, FC_WS_PRESSED);
{
/* local loop */
Uint16 rety = gui_event_loop((void *)&pEdt, NULL,
edit_key_down, NULL, edit_mouse_button_down, NULL, NULL);
if (pEdt.pBeginTextChain == pEdt.pEndTextChain) {
pEdt.pBeginTextChain = NULL;
}
if (rety == MAX_ID) {
ret = ED_FORCE_EXIT;
} else {
ret = (enum Edit_Return_Codes) rety;
/* this is here becouse we have no knowladge that pEdit_Widget exist
or nor in force exit mode from gui loop */
/* reset font settings */
if (!((pEdit_Widget->string16->style & 0x0F) & TTF_STYLE_NORMAL)) {
TTF_SetFontStyle(pEdit_Widget->string16->font, TTF_STYLE_NORMAL);
}
if(ret != ED_ESC) {
FC_FREE(pEdit_Widget->string16->text);
pEdit_Widget->string16->text =
chain2text(pEdt.pBeginTextChain, pEdt.ChainLen);
pEdit_Widget->string16->n_alloc = (pEdt.ChainLen + 1) * sizeof(Uint16);
}
pEdit_Widget->data.ptr = backup;
set_wstate(pEdit_Widget, FC_WS_NORMAL);
}
}
FREESURFACE(pEdt.pEndTextChain->pTsurf);
del_chain(pEdt.pBeginTextChain);
FREESURFACE(pEdt.pBg);
/* disable repeate key */
#if 0
SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
/* disable Unicode */
SDL_EnableUNICODE(0);
#endif
return ret;
}
/**************************************************************************
Do default Widget action when pressed, and then call widget callback
function.
example for Button:
set flags FW_Pressed
redraw button ( pressed )
refresh screen ( to see result )
wait 300 ms ( to see result :)
If exist (button callback function) then
call (button callback function)
Function normal return Widget ID.
NOTE: NOZERO return of this function deterninate exit of
MAIN_SDL_GAME_LOOP
if ( pWidget->action )
if ( pWidget->action(pWidget) ) ID = 0;
if widget callback function return = 0 then return NOZERO
I default return (-1) from Widget callback functions.
**************************************************************************/
Uint16 widget_pressed_action(struct widget * pWidget)
{
Uint16 ID = 0;
if (!pWidget) {
return 0;
}
widget_info_counter = 0;
if (pInfo_Area) {
sdl_dirty_rect(*pInfo_Area);
FC_FREE(pInfo_Area);
FREESURFACE(pInfo_Label);
}
switch (get_wtype(pWidget)) {
case WT_TI_BUTTON:
case WT_I_BUTTON:
case WT_ICON:
case WT_ICON2:
if (Main.event.button.button == SDL_BUTTON_LEFT) {
set_wstate(pWidget, FC_WS_PRESSED);
widget_redraw(pWidget);
widget_mark_dirty(pWidget);
flush_dirty();
set_wstate(pWidget, FC_WS_SELLECTED);
SDL_Delay(300);
}
ID = pWidget->ID;
if (pWidget->action) {
if (pWidget->action(pWidget)) {
ID = 0;
}
}
break;
case WT_EDIT:
{
if (Main.event.button.button == SDL_BUTTON_LEFT) {
bool ret, loop = ((get_wflags(pWidget) & WF_EDIT_LOOP) == WF_EDIT_LOOP);
enum Edit_Return_Codes change;
do {
ret = FALSE;
change = edit_field(pWidget);
if (change != ED_FORCE_EXIT && (!loop || change != ED_RETURN)) {
widget_redraw(pWidget);
widget_mark_dirty(pWidget);
flush_dirty();
}
if (change != ED_FORCE_EXIT && change != ED_ESC && pWidget->action) {
if (pWidget->action(pWidget)) {
ID = 0;
}
}
if (loop && change == ED_RETURN) {
ret = TRUE;
}
} while(ret);
ID = 0;
}
break;
}
case WT_VSCROLLBAR:
case WT_HSCROLLBAR:
if (Main.event.button.button == SDL_BUTTON_LEFT) {
set_wstate(pWidget, FC_WS_PRESSED);
widget_redraw(pWidget);
widget_mark_dirty(pWidget);
flush_dirty();
}
ID = pWidget->ID;
if (pWidget->action) {
if (pWidget->action(pWidget)) {
ID = 0;
}
}
break;
case WT_CHECKBOX:
case WT_TCHECKBOX:
if (Main.event.button.button == SDL_BUTTON_LEFT) {
set_wstate(pWidget, FC_WS_PRESSED);
widget_redraw(pWidget);
widget_mark_dirty(pWidget);
flush_dirty();
set_wstate(pWidget, FC_WS_SELLECTED);
togle_checkbox(pWidget);
SDL_Delay(300);
}
ID = pWidget->ID;
if (pWidget->action) {
if (pWidget->action(pWidget)) {
ID = 0;
}
}
break;
case WT_COMBO:
if (Main.event.button.button == SDL_BUTTON_LEFT) {
set_wstate(pWidget, FC_WS_PRESSED);
combo_popup(pWidget);
} else {
combo_popdown(pWidget);
}
break;
default:
ID = pWidget->ID;
if (pWidget->action) {
if (pWidget->action(pWidget) != 0) {
ID = 0;
}
}
break;
}
return ID;
}
