/**************************************************************************
Draw Themed Frame.
**************************************************************************/
void draw_frame(SDL_Surface * pDest, Sint16 start_x, Sint16 start_y,
Uint16 w, Uint16 h)
{
SDL_Surface *pTmpLeft =
ResizeSurface(pTheme->FR_Left, pTheme->FR_Left->w, h, 1);
SDL_Surface *pTmpRight =
ResizeSurface(pTheme->FR_Right, pTheme->FR_Right->w, h, 1);
SDL_Surface *pTmpTop =
ResizeSurface(pTheme->FR_Top, w, pTheme->FR_Top->h, 1);
SDL_Surface *pTmpBottom =
ResizeSurface(pTheme->FR_Bottom, w, pTheme->FR_Bottom->h, 1);
SDL_Rect tmp,dst = {start_x, start_y, 0, 0};
tmp = dst;
alphablit(pTmpLeft, NULL, pDest, &tmp);
dst.x += w - pTmpRight->w;
tmp = dst;
alphablit(pTmpRight, NULL, pDest, &tmp);
dst.x = start_x;
tmp = dst;
alphablit(pTmpTop, NULL, pDest, &tmp);
dst.y += h - pTmpBottom->h;
tmp = dst;
alphablit(pTmpBottom, NULL, pDest, &tmp);
FREESURFACE(pTmpLeft);
FREESURFACE(pTmpRight);
FREESURFACE(pTmpTop);
FREESURFACE(pTmpBottom);
}
/**************************************************************************
...
**************************************************************************/
static int redraw_icon2(struct widget *pIcon)
{
int ret;
SDL_Rect dest;
Uint32 state;
ret = (*baseclass_redraw)(pIcon);
if (ret != 0) {
return ret;
}
if(!pIcon) {
return -3;
}
if(!pIcon->theme) {
return -4;
}
state = get_wstate(pIcon);
dest.x = pIcon->size.x;
dest.y = pIcon->size.y;
dest.w = pIcon->theme->w;
dest.h = pIcon->theme->h;
if (state == FC_WS_SELLECTED) {
putframe(pIcon->dst->surface,
dest.x + 1, dest.y + 1,
dest.x + dest.w + adj_size(2), dest.y + dest.h + adj_size(2),
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_SELECTED_FRAME));
}
if (state == FC_WS_PRESSED) {
putframe(pIcon->dst->surface,
dest.x + 1, dest.y + 1,
dest.x + dest.w + adj_size(2), dest.y + dest.h + adj_size(2),
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_SELECTED_FRAME));
putframe(pIcon->dst->surface,
dest.x, dest.y,
dest.x + dest.w + adj_size(3), dest.y + dest.h + adj_size(3),
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_PRESSED_FRAME));
}
if (state == FC_WS_DISABLED) {
putframe(pIcon->dst->surface,
dest.x + 1, dest.y + 1,
dest.x + dest.w + adj_size(2), dest.y + dest.h + adj_size(2),
get_theme_color(COLOR_THEME_WIDGET_DISABLED_TEXT));
}
dest.x += adj_size(2);
dest.y += adj_size(2);
ret = alphablit(pIcon->theme, NULL, pIcon->dst->surface, &dest);
if (ret) {
return ret;
}
return 0;
}
/****************************************************************************
Draw a full sprite onto the canvas.
****************************************************************************/
void canvas_put_sprite_full(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *sprite)
{
SDL_Rect dst = {canvas_x, canvas_y, 0, 0};
alphablit(GET_SURF(sprite), NULL, pcanvas->surf, &dst);
}
/**************************************************************************
...
**************************************************************************/
static int redraw_icon(struct widget *pIcon)
{
int ret;
SDL_Rect src, area = pIcon->size;
ret = (*checkbox_baseclass_redraw)(pIcon);
if (ret != 0) {
return ret;
}
if (!pIcon->theme) {
return -3;
}
src.x = (pIcon->theme->w / 4) * (Uint8) (get_wstate(pIcon));
src.y = 0;
src.w = (pIcon->theme->w / 4);
src.h = pIcon->theme->h;
if (pIcon->size.w != src.w) {
area.x += (pIcon->size.w - src.w) / 2;
}
if (pIcon->size.h != src.h) {
area.y += (pIcon->size.h - src.h) / 2;
}
return alphablit(pIcon->theme, &src, pIcon->dst->surface, &area);
}
/****************************************************************************
Draw some or all of a sprite onto the canvas.
****************************************************************************/
void canvas_put_sprite(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *sprite,
int offset_x, int offset_y, int width, int height)
{
SDL_Rect src = {offset_x, offset_y, width, height};
SDL_Rect dst = {canvas_x + offset_x, canvas_y + offset_y, 0, 0};
alphablit(GET_SURF(sprite), &src, pcanvas->surf, &dst);
}
/**************************************************************************
Copies an area from the source canvas to the destination canvas.
**************************************************************************/
void canvas_copy(struct canvas *dest, struct canvas *src,
int src_x, int src_y, int dest_x, int dest_y, int width,
int height)
{
SDL_Rect src_rect = {src_x, src_y, width, height};
SDL_Rect dest_rect = {dest_x, dest_y, width, height};
alphablit(src->surf, &src_rect, dest->surf, &dest_rect);
}
/**************************************************************************
Ugly hack to create 4-state icon theme from static icon;
**************************************************************************/
SDL_Surface *create_icon_theme_surf(SDL_Surface * pIcon)
{
SDL_Color bg_color = { 255, 255, 255, 128 };
SDL_Rect dest, src = get_smaller_surface_rect(pIcon);
SDL_Surface *pTheme = create_surf_alpha((src.w + adj_size(4)) * 4, src.h + adj_size(4),
SDL_SWSURFACE);
dest.x = adj_size(2);
dest.y = (pTheme->h - src.h) / 2;
/* normal */
alphablit(pIcon, &src, pTheme, &dest);
/* sellected */
dest.x += (src.w + adj_size(4));
alphablit(pIcon, &src, pTheme, &dest);
/* draw sellect frame */
putframe(pTheme,
dest.x - 1, dest.y - 1, dest.x + (src.w), dest.y + src.h,
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_SELECTED_FRAME));
/* pressed */
dest.x += (src.w + adj_size(4));
alphablit(pIcon, &src, pTheme, &dest);
/* draw sellect frame */
putframe(pTheme,
dest.x - 1, dest.y - 1, dest.x + src.w, dest.y + src.h,
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_SELECTED_FRAME));
/* draw press frame */
putframe(pTheme,
dest.x - adj_size(2), dest.y - adj_size(2),
dest.x + (src.w + 1), dest.y + (src.h + 1),
get_theme_color(COLOR_THEME_CUSTOM_WIDGET_PRESSED_FRAME));
/* disabled */
dest.x += (src.w + adj_size(4));
alphablit(pIcon, &src, pTheme, &dest);
dest.w = src.w;
dest.h = src.h;
SDL_FillRectAlpha(pTheme, &dest, &bg_color);
return pTheme;
}
/**************************************************************************
...
**************************************************************************/
void refresh_widget_background(struct widget *pWidget)
{
if (pWidget) {
if (pWidget->gfx && pWidget->gfx->w == pWidget->size.w &&
pWidget->gfx->h == pWidget->size.h) {
clear_surface(pWidget->gfx, NULL);
alphablit(pWidget->dst->surface, &pWidget->size, pWidget->gfx, NULL);
} else {
FREESURFACE(pWidget->gfx);
pWidget->gfx = crop_rect_from_surface(pWidget->dst->surface, &pWidget->size);
}
}
}
/****************************************************************************
Fill the area covered by the sprite with the given color.
****************************************************************************/
void canvas_fog_sprite_area(struct canvas *pcanvas, struct sprite *psprite,
int canvas_x, int canvas_y)
{
SDL_Rect dst = {canvas_x, canvas_y, GET_SURF(psprite)->w,
GET_SURF(psprite)->h};
SDL_Surface *tmp_surf = create_surf_alpha(GET_SURF(psprite)->w,
GET_SURF(psprite)->h,
SDL_SWSURFACE);
SDL_FillRect(tmp_surf, NULL, SDL_MapRGBA(tmp_surf->format, 0, 0, 0, 64));
alphablit(tmp_surf, NULL, pcanvas->surf, &dst);
FREESURFACE(tmp_surf);
}
/**************************************************************************
Blit Icon image to pDest(ination) on positon
start_x , start_y. WARRING: pDest must exist.
Graphic is taken from pIcon_theme surface.
Type of Icon depend of "state" parametr.
state = 0 - normal
state = 1 - selected
state = 2 - pressed
state = 3 - disabled
Function return: -3 if pIcon_theme is NULL.
std return of alphablit(...) function.
**************************************************************************/
int draw_icon_from_theme(SDL_Surface * pIcon_theme, Uint8 state,
struct gui_layer * pDest, Sint16 start_x, Sint16 start_y)
{
SDL_Rect src, des = {start_x, start_y, 0, 0};
if (!pIcon_theme) {
return -3;
}
/* src.x = 0 + pIcon_theme->w/4 * state */
src.x = 0 + (pIcon_theme->w / 4) * state;
src.y = 0;
src.w = pIcon_theme->w / 4;
src.h = pIcon_theme->h;
return alphablit(pIcon_theme, &src, pDest->surface, &des);
}
/**************************************************************************
...
**************************************************************************/
int write_text16(SDL_Surface * pDest, Sint16 x, Sint16 y,
SDL_String16 * pString)
{
SDL_Rect dst_rect = { x, y, 0, 0 };
SDL_Surface *pText = create_text_surf_from_str16(pString);
if (alphablit(pText, NULL, pDest, &dst_rect) < 0) {
log_error("write_text16: couldn't blit text to display: %s",
SDL_GetError());
FREESURFACE(pText);
return -1;
}
FREESURFACE(pText);
return 0;
}
/**************************************************************************
...
**************************************************************************/
void draw_intro_gfx(void)
{
SDL_Surface *pIntro = theme_get_background(theme, BACKGROUND_MAINPAGE);
if(pIntro->w != Main.screen->w)
{
SDL_Surface *pTmp = ResizeSurface(pIntro, Main.screen->w, Main.screen->h,1);
FREESURFACE(pIntro);
pIntro = pTmp;
}
/* draw intro gfx center in screen */
alphablit(pIntro, NULL, Main.map, NULL);
FREESURFACE(pIntro);
}
/****************************************************************************
Draw a full sprite onto the canvas. If "fog" is specified draw it with
fog.
****************************************************************************/
void canvas_put_sprite_fogged(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *psprite,
bool fog, int fog_x, int fog_y)
{
SDL_Rect dst = {canvas_x, canvas_y, 0, 0};
if (fog) {
SDL_Surface *tmp_surf = blend_surface(GET_SURF(psprite), 160);
alphablit(tmp_surf, NULL, pcanvas->surf, &dst);
FREESURFACE(tmp_surf);
} else {
canvas_put_sprite_full(pcanvas, canvas_x, canvas_y, psprite);
}
}
/**************************************************************************
...
**************************************************************************/
void redraw_widget_info_label(SDL_Rect *rect)
{
SDL_Surface *pText, *pBcgd;
SDL_Rect srcrect, dstrect;
SDL_Color color;
struct widget *pWidget = pSellected_Widget;
if (!pWidget || !pWidget->info_label) {
return;
}
if (!pInfo_Label) {
pInfo_Area = fc_calloc(1, sizeof(SDL_Rect));
color = pWidget->info_label->fgcol;
pWidget->info_label->style |= TTF_STYLE_BOLD;
pWidget->info_label->fgcol =
*get_theme_color(COLOR_THEME_QUICK_INFO_TEXT);
/* create string and bcgd theme */
pText = create_text_surf_from_str16(pWidget->info_label);
pWidget->info_label->fgcol = color;
pBcgd = create_filled_surface(pText->w + adj_size(10), pText->h + adj_size(6),
SDL_SWSURFACE, get_theme_color(COLOR_THEME_QUICK_INFO_BG), TRUE);
/* calculate start position */
if ((pWidget->dst->dest_rect.y + pWidget->size.y) - pBcgd->h - adj_size(6) < 0) {
pInfo_Area->y = (pWidget->dst->dest_rect.y + pWidget->size.y) + pWidget->size.h + adj_size(3);
} else {
pInfo_Area->y = (pWidget->dst->dest_rect.y + pWidget->size.y) - pBcgd->h - adj_size(5);
}
if ((pWidget->dst->dest_rect.x + pWidget->size.x) + pBcgd->w + adj_size(5) > Main.screen->w) {
pInfo_Area->x = (pWidget->dst->dest_rect.x + pWidget->size.x) - pBcgd->w - adj_size(5);
} else {
pInfo_Area->x = (pWidget->dst->dest_rect.x + pWidget->size.x) + adj_size(3);
}
pInfo_Area->w = pBcgd->w + adj_size(2);
pInfo_Area->h = pBcgd->h + adj_size(3);
pInfo_Label = SDL_DisplayFormatAlpha(pBcgd);
FREESURFACE(pBcgd);
/* draw text */
dstrect.x = adj_size(6);
dstrect.y = adj_size(3);
alphablit(pText, NULL, pInfo_Label, &dstrect);
FREESURFACE(pText);
/* draw frame */
putframe(pInfo_Label,
0, 0, pInfo_Label->w - 1, pInfo_Label->h - 1,
get_theme_color(COLOR_THEME_QUICK_INFO_FRAME));
}
if (rect) {
dstrect.x = MAX(rect->x, pInfo_Area->x);
dstrect.y = MAX(rect->y, pInfo_Area->y);
srcrect.x = dstrect.x - pInfo_Area->x;
srcrect.y = dstrect.y - pInfo_Area->y;
srcrect.w = MIN((pInfo_Area->x + pInfo_Area->w), (rect->x + rect->w)) - dstrect.x;
srcrect.h = MIN((pInfo_Area->y + pInfo_Area->h), (rect->y + rect->h)) - dstrect.y;
alphablit(pInfo_Label, &srcrect, Main.screen, &dstrect);
} else {
alphablit(pInfo_Label, NULL, Main.screen, pInfo_Area);
}
if (correct_rect_region(pInfo_Area)) {
SDL_UpdateRect(Main.screen, pInfo_Area->x, pInfo_Area->y,
pInfo_Area->w, pInfo_Area->h);
}
return;
}
/**************************************************************************
...
**************************************************************************/
static SDL_Surface *create_str16_multi_surf(SDL_String16 * pString)
{
SDL_Rect des = {0, 0, 0, 0};
SDL_Surface *pText = NULL, **pTmp = NULL;
Uint16 i, w = 0, count = 0;
Uint32 color;
Uint16 *pBuf = pString->text;
Uint16 **UniTexts = create_new_line_unistrings(pString->text);
while (UniTexts[count]) {
count++;
}
pTmp = fc_calloc(count, sizeof(SDL_Surface *));
for (i = 0; i < count; i++) {
pString->text = UniTexts[i];
pTmp[i] = create_str16_surf(pString);
}
pString->text = pBuf;
/* find max len */
for (i = 0; i < count; i++) {
if (pTmp[i]->w > w) {
w = pTmp[i]->w;
}
}
/* create and fill surface */
color = pTmp[0]->format->colorkey;
switch (pString->render) {
case 1:
pText = create_surf(w, count * pTmp[0]->h, SDL_SWSURFACE);
SDL_FillRect(pText, NULL, color);
SDL_SetColorKey(pText, SDL_SRCCOLORKEY, color);
break;
case 2:
pText = create_surf_with_format(pTmp[0]->format,
w, count * pTmp[0]->h, pTmp[0]->flags);
SDL_FillRect(pText, NULL, color);
break;
default:
pText = create_surf(w, count * pTmp[0]->h, SDL_SWSURFACE);
SDL_FillRect(pText, NULL, color);
break;
}
/* blit (default: center left) */
for (i = 0; i < count; i++) {
if (pString->style & SF_CENTER) {
des.x = (w - pTmp[i]->w) / 2;
} else {
if (pString->style & SF_CENTER_RIGHT) {
des.x = w - pTmp[i]->w;
} else {
des.x = 0;
}
}
alphablit(pTmp[i], NULL, pText, &des);
des.y += pTmp[i]->h;
}
/* Free Memmory */
for (i = 0; i < count; i++) {
FC_FREE(UniTexts[i]);
FREESURFACE(pTmp[i]);
}
FC_FREE(pTmp);
return pText;
}
/**************************************************************************
...
**************************************************************************/
static int redraw_edit_chain(struct EDIT *pEdt)
{
struct UniChar *pInputChain_TMP;
SDL_Rect Dest, Dest_Copy = {0, 0, 0, 0};
int iStart_Mod_X;
int ret;
Dest_Copy.x = pEdt->pWidget->size.x;
Dest_Copy.y = pEdt->pWidget->size.y;
ret = (*baseclass_redraw)(pEdt->pWidget);
if (ret != 0) {
return ret;
}
/* blit theme */
Dest = Dest_Copy;
alphablit(pEdt->pBg, NULL, pEdt->pWidget->dst->surface, &Dest);
/* set start parametrs */
pInputChain_TMP = pEdt->pBeginTextChain;
iStart_Mod_X = 0;
Dest_Copy.y += (pEdt->pBg->h - pInputChain_TMP->pTsurf->h) / 2;
Dest_Copy.x += pEdt->Start_X;
/* draw loop */
while (pInputChain_TMP) {
Dest_Copy.x += iStart_Mod_X;
/* chech if we draw inside of edit rect */
if (Dest_Copy.x > pEdt->pWidget->size.x + pEdt->pBg->w - 4) {
break;
}
if (Dest_Copy.x > pEdt->pWidget->size.x) {
Dest = Dest_Copy;
alphablit(pInputChain_TMP->pTsurf, NULL, pEdt->pWidget->dst->surface, &Dest);
}
iStart_Mod_X = pInputChain_TMP->pTsurf->w;
/* draw cursor */
if (pInputChain_TMP == pEdt->pInputChain) {
Dest = Dest_Copy;
putline(pEdt->pWidget->dst->surface,
Dest.x - 1, Dest.y + (pEdt->pBg->h / 8),
Dest.x - 1, Dest.y + pEdt->pBg->h - (pEdt->pBg->h / 4),
get_game_colorRGB(COLOR_THEME_EDITFIELD_CARET));
/* save active element position */
pEdt->InputChain_X = Dest_Copy.x;
}
pInputChain_TMP = pInputChain_TMP->next;
} /* while - draw loop */
widget_flush(pEdt->pWidget);
return 0;
}
/**************************************************************************
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;
}
/**************************************************************************
Popup (or raise) the player list dialog.
**************************************************************************/
void popup_players_dialog(bool raise)
{
struct widget *pWindow = NULL, *pBuf = NULL;
SDL_Surface *pLogo = NULL, *pZoomed = NULL;
SDL_String16 *pStr;
SDL_Rect dst;
int i, n, h;
double a, b, r;
SDL_Rect area;
if (pPlayers_Dlg) {
return;
}
n = 0;
players_iterate(pPlayer) {
if(is_barbarian(pPlayer)) {
continue;
}
n++;
} players_iterate_end;
if(n < 2) {
return;
}
pPlayers_Dlg = fc_calloc(1, sizeof(struct SMALL_DLG));
pStr = create_str16_from_char(_("Players"), adj_font(12));
pStr->style |= TTF_STYLE_BOLD;
pWindow = create_window_skeleton(NULL, pStr, 0);
pWindow->action = players_window_dlg_callback;
set_wstate(pWindow, FC_WS_NORMAL);
add_to_gui_list(ID_WINDOW, pWindow);
pPlayers_Dlg->pEndWidgetList = pWindow;
/* ---------- */
/* exit button */
pBuf = create_themeicon(pTheme->Small_CANCEL_Icon, pWindow->dst,
WF_WIDGET_HAS_INFO_LABEL | WF_RESTORE_BACKGROUND);
pBuf->info_label = create_str16_from_char(_("Close Dialog (Esc)"),
adj_font(12));
pBuf->action = exit_players_dlg_callback;
set_wstate(pBuf, FC_WS_NORMAL);
pBuf->key = SDLK_ESCAPE;
add_to_gui_list(ID_BUTTON, pBuf);
/* ---------- */
for(i = 0; i<DS_LAST; i++) {
switch (i) {
case DS_ARMISTICE:
pBuf = create_checkbox(pWindow->dst,
(SDL_Client_Flags & CF_DRAW_PLAYERS_NEUTRAL_STATUS),
WF_RESTORE_BACKGROUND);
pBuf->action = toggle_draw_neutral_status_callback;
pBuf->key = SDLK_n;
break;
case DS_WAR:
pBuf = create_checkbox(pWindow->dst,
(SDL_Client_Flags & CF_DRAW_PLAYERS_WAR_STATUS),
WF_RESTORE_BACKGROUND);
pBuf->action = toggle_draw_war_status_callback;
pBuf->key = SDLK_w;
break;
case DS_CEASEFIRE:
pBuf = create_checkbox(pWindow->dst,
(SDL_Client_Flags & CF_DRAW_PLAYERS_CEASEFIRE_STATUS),
WF_RESTORE_BACKGROUND);
pBuf->action = toggle_draw_ceasefire_status_callback;
pBuf->key = SDLK_c;
break;
case DS_PEACE:
pBuf = create_checkbox(pWindow->dst,
(SDL_Client_Flags & CF_DRAW_PLAYERS_PEACE_STATUS),
WF_RESTORE_BACKGROUND);
pBuf->action = toggle_draw_pease_status_callback;
pBuf->key = SDLK_p;
break;
case DS_ALLIANCE:
pBuf = create_checkbox(pWindow->dst,
(SDL_Client_Flags & CF_DRAW_PLAYERS_ALLIANCE_STATUS),
WF_RESTORE_BACKGROUND);
pBuf->action = toggle_draw_alliance_status_callback;
pBuf->key = SDLK_a;
break;
default:
/* no contact */
continue;
break;
}
set_wstate(pBuf, FC_WS_NORMAL);
add_to_gui_list(ID_CHECKBOX, pBuf);
}
/* ---------- */
players_iterate(pPlayer) {
if(is_barbarian(pPlayer)) {
continue;
}
pStr = create_string16(NULL, 0, adj_font(10));
pStr->style |= (TTF_STYLE_BOLD|SF_CENTER);
pLogo = get_nation_flag_surface(nation_of_player(pPlayer));
{
/* Aim for a flag height of 60 pixels, but draw smaller flags if there
* are more players */
double zoom = DEFAULT_ZOOM * (60.0 - n) / pLogo->h;
pZoomed = zoomSurface(pLogo, zoom, zoom, 1);
}
pBuf = create_icon2(pZoomed, pWindow->dst,
WF_RESTORE_BACKGROUND | WF_WIDGET_HAS_INFO_LABEL
| WF_FREE_THEME);
pBuf->info_label = pStr;
if(!pPlayer->is_alive) {
pStr = create_str16_from_char(_("R.I.P.") , adj_font(10));
pStr->style |= TTF_STYLE_BOLD;
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_TEXT);
pLogo = create_text_surf_from_str16(pStr);
FREESTRING16(pStr);
dst.x = (pZoomed->w - pLogo->w) / 2;
dst.y = (pZoomed->h - pLogo->h) / 2;
alphablit(pLogo, NULL, pZoomed, &dst);
FREESURFACE(pLogo);
}
if(pPlayer->is_alive) {
set_wstate(pBuf, FC_WS_NORMAL);
}
pBuf->data.player = pPlayer;
pBuf->action = player_callback;
add_to_gui_list(ID_LABEL, pBuf);
} players_iterate_end;
pPlayers_Dlg->pBeginWidgetList = pBuf;
resize_window(pWindow, NULL, NULL, adj_size(500), adj_size(400));
area = pWindow->area;
r = MIN(area.w, area.h);
r -= ((MAX(pBuf->size.w, pBuf->size.h) * 2));
r /= 2;
a = (2.0 * M_PI) / n;
widget_set_position(pWindow,
(Main.screen->w - pWindow->size.w) / 2,
(Main.screen->h - pWindow->size.h) / 2);
/* exit button */
pBuf = pWindow->prev;
pBuf->size.x = area.x + area.w - pBuf->size.w - 1;
pBuf->size.y = pWindow->size.y + adj_size(2);
n = area.y;
pStr = create_string16(NULL, 0, adj_font(10));
pStr->style |= TTF_STYLE_BOLD;
pStr->bgcol = (SDL_Color) {0, 0, 0, 0};
for(i = 0; i<DS_LAST; i++) {
switch (i) {
case DS_ARMISTICE:
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_ARMISTICE);
break;
case DS_WAR:
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_WAR);
break;
case DS_CEASEFIRE:
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_CEASEFIRE);
break;
case DS_PEACE:
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_PEACE);
break;
case DS_ALLIANCE:
pStr->fgcol = *get_theme_color(COLOR_THEME_PLRDLG_ALLIANCE);
break;
default:
/* no contact */
continue;
break;
}
copy_chars_to_string16(pStr, diplstate_type_translated_name(i));
pLogo = create_text_surf_from_str16(pStr);
pBuf = pBuf->prev;
h = MAX(pBuf->size.h, pLogo->h);
pBuf->size.x = area.x + adj_size(5);
pBuf->size.y = n + (h - pBuf->size.h) / 2;
dst.x = adj_size(5) + pBuf->size.w + adj_size(6);
dst.y = n + (h - pLogo->h) / 2;
alphablit(pLogo, NULL, pWindow->theme, &dst);
n += h;
FREESURFACE(pLogo);
}
FREESTRING16(pStr);
/* first player shield */
pBuf = pBuf->prev;
pBuf->size.x = area.x + area.w / 2 - pBuf->size.w / 2;
pBuf->size.y = area.y + area.h / 2 - r - pBuf->size.h / 2;
n = 1;
if(pBuf != pPlayers_Dlg->pBeginWidgetList) {
do{
pBuf = pBuf->prev;
b = M_PI_2 + n * a;
pBuf->size.x = area.x + area.w / 2 - r * cos(b) - pBuf->size.w / 2;
pBuf->size.y = area.y + area.h / 2 - r * sin(b) - pBuf->size.h / 2;
n++;
} while(pBuf != pPlayers_Dlg->pBeginWidgetList);
}
players_dialog_update();
}
/**************************************************************************
Do any necessary pre-initialization of the UI, if necessary.
**************************************************************************/
void ui_init(void)
{
char device[20];
/* struct widget *pInit_String = NULL;*/
SDL_Surface *pBgd;
Uint32 iSDL_Flags;
button_behavior.counting = FALSE;
button_behavior.button_down_ticks = 0;
button_behavior.hold_state = MB_HOLD_SHORT;
button_behavior.event = fc_calloc(1, sizeof(SDL_MouseButtonEvent));
SDL_Client_Flags = 0;
iSDL_Flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
/* auto center new windows in X enviroment */
putenv((char *)"SDL_VIDEO_CENTERED=yes");
init_sdl(iSDL_Flags);
log_normal(_("Using Video Output: %s"),
SDL_VideoDriverName(device, sizeof(device)));
/* create splash screen */
#ifdef SMALL_SCREEN
{
SDL_Surface *pTmpSurf = load_surf(fileinfoname(get_data_dirs(),
"misc/intro.png"));
pBgd = zoomSurface(pTmpSurf, DEFAULT_ZOOM, DEFAULT_ZOOM, 0);
FREESURFACE(pTmpSurf);
}
#else /* SMALL_SCREEN */
pBgd = load_surf(fileinfoname(get_data_dirs(), "misc/intro.png"));
#endif /* SMALL_SCREEN */
if (pBgd && SDL_GetVideoInfo()->wm_available) {
set_video_mode(pBgd->w, pBgd->h, SDL_SWSURFACE | SDL_ANYFORMAT);
#if 0
/*
* call this for other than X enviroments - currently not supported.
*/
center_main_window_on_screen();
#endif /* 0 */
alphablit(pBgd, NULL, Main.map, NULL);
putframe(Main.map,
0, 0, Main.map->w - 1, Main.map->h - 1,
&(SDL_Color) {
255, 255, 255, 255
});
FREESURFACE(pBgd);
SDL_WM_SetCaption(_("SDL Client for Freeciv"), _("Freeciv"));
} else {
#ifndef SMALL_SCREEN
set_video_mode(640, 480, SDL_SWSURFACE | SDL_ANYFORMAT);
#else /* SMALL_SCREEN */
set_video_mode(320, 240, SDL_SWSURFACE | SDL_ANYFORMAT);
#endif /* SMALL_SCREEN */
if(pBgd) {
blit_entire_src(pBgd, Main.map, (Main.map->w - pBgd->w) / 2,
(Main.map->h - pBgd->h) / 2);
FREESURFACE(pBgd);
} else {
SDL_FillRect(Main.map, NULL, SDL_MapRGB(Main.map->format, 0, 0, 128));
SDL_WM_SetCaption(_("SDL Client for Freeciv"), _("Freeciv"));
}
}
#if 0
/* create label beackground */
pBgd = create_surf_alpha(adj_size(350), adj_size(50), SDL_SWSURFACE);
SDL_FillRect(pBgd, NULL, SDL_MapRGBA(pBgd->format, 255, 255, 255, 128));
putframe(pBgd, 0, 0, pBgd->w - 1, pBgd->h - 1, SDL_MapRGB(pBgd->format, 0, 0, 0));
pInit_String = create_iconlabel(pBgd, Main.gui,
create_str16_from_char(_("Initializing Client"), adj_font(20)),
WF_ICON_CENTER|WF_FREE_THEME);
pInit_String->string16->style |= SF_CENTER;
draw_label(pInit_String,
(Main.screen->w - pInit_String->size.w) / 2,
(Main.screen->h - pInit_String->size.h) / 2);
flush_all();
copy_chars_to_string16(pInit_String->string16,
_("Waiting for the beginning of the game"));
#endif /* 0 */
flush_all();
}
/**************************************************************************
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;
}
/**************************************************************************
Create background image for buttons, iconbuttons and edit fields
then return pointer to this image.
Graphic is taken from pTheme surface and blit to new created image.
Length and height depend of iText_with, iText_high parameters.
Type of image depend of "state" parameter.
state = 0 - normal
state = 1 - selected
state = 2 - pressed
state = 3 - disabled
**************************************************************************/
SDL_Surface *create_bcgnd_surf(SDL_Surface * pTheme, Uint8 state,
Uint16 Width, Uint16 High)
{
bool zoom;
int iTile_width_len_end, iTile_width_len_mid, iTile_count_len_mid;
int iTile_width_high_end, iTile_width_high_mid, iTile_count_high_mid;
int i, j;
SDL_Rect src, des;
SDL_Surface *pBackground = NULL;
int iStart_y = (pTheme->h / 4) * state;
iTile_width_len_end = pTheme->w / 16;
iTile_width_len_mid = pTheme->w - (iTile_width_len_end * 2);
iTile_count_len_mid =
(Width - (iTile_width_len_end * 2)) / iTile_width_len_mid;
/* corrections I */
if (((iTile_count_len_mid *
iTile_width_len_mid) + (iTile_width_len_end * 2)) < Width) {
iTile_count_len_mid++;
}
iTile_width_high_end = pTheme->h / 16;
iTile_width_high_mid = (pTheme->h / 4) - (iTile_width_high_end * 2);
iTile_count_high_mid =
(High - (iTile_width_high_end * 2)) / iTile_width_high_mid;
/* corrections II */
if (((iTile_count_high_mid *
iTile_width_high_mid) + (iTile_width_high_end * 2)) < High) {
iTile_count_high_mid++;
}
i = MAX(iTile_width_len_end * 2, Width);
j = MAX(iTile_width_high_end * 2, High);
zoom = ((i != Width) || (j != High));
/* now allocate memory */
pBackground = create_surf_alpha(i, j, SDL_SWSURFACE);
/* copy left end */
/* copy left top end */
src.x = 0;
src.y = iStart_y;
src.w = iTile_width_len_end;
src.h = iTile_width_high_end;
des.x = 0;
des.y = 0;
alphablit(pTheme, &src, pBackground, &des);
/* copy left middels parts */
src.y = iStart_y + iTile_width_high_end;
src.h = iTile_width_high_mid;
for (i = 0; i < iTile_count_high_mid; i++) {
des.y = iTile_width_high_end + i * iTile_width_high_mid;
alphablit(pTheme, &src, pBackground, &des);
}
/* copy left boton end */
src.y = iStart_y + ((pTheme->h / 4) - iTile_width_high_end);
src.h = iTile_width_high_end;
des.y = pBackground->h - iTile_width_high_end;
clear_surface(pBackground, &des);
alphablit(pTheme, &src, pBackground, &des);
/* copy middle parts without right end part */
src.x = iTile_width_len_end;
src.y = iStart_y;
src.w = iTile_width_len_mid;
for (i = 0; i < iTile_count_len_mid; i++) {
/* top */
des.x = iTile_width_len_end + i * iTile_width_len_mid;
des.y = 0;
src.y = iStart_y;
alphablit(pTheme, &src, pBackground, &des);
/* middels */
src.y = iStart_y + iTile_width_high_end;
src.h = iTile_width_high_mid;
for (j = 0; j < iTile_count_high_mid; j++) {
des.y = iTile_width_high_end + j * iTile_width_high_mid;
alphablit(pTheme, &src, pBackground, &des);
}
/* bottom */
src.y = iStart_y + ((pTheme->h / 4) - iTile_width_high_end);
src.h = iTile_width_high_end;
des.y = pBackground->h - iTile_width_high_end;
clear_surface(pBackground, &des);
alphablit(pTheme, &src, pBackground, &des);
}
/* copy right end */
src.x = pTheme->w - iTile_width_len_end;
src.y = iStart_y;
src.w = iTile_width_len_end;
des.x = pBackground->w - iTile_width_len_end;
des.y = 0;
alphablit(pTheme, &src, pBackground, &des);
/* middels */
src.y = iStart_y + iTile_width_high_end;
src.h = iTile_width_high_mid;
for (i = 0; i < iTile_count_high_mid; i++) {
des.y = iTile_width_high_end + i * iTile_width_high_mid;
alphablit(pTheme, &src, pBackground, &des);
}
/*boton */
src.y = iStart_y + ((pTheme->h / 4) - iTile_width_high_end);
src.h = iTile_width_high_end;
des.y = pBackground->h - iTile_width_high_end;
clear_surface(pBackground, &des);
alphablit(pTheme, &src, pBackground, &des);
if (zoom)
{
SDL_Surface *pZoom = ResizeSurface(pBackground, Width, High, 1);
FREESURFACE(pBackground);
pBackground = pZoom;
}
return pBackground;
}
