/**************************************************************************
Convert Unistring ( Uint16[] ) to UniChar structure.
Memmory alocation -> after all use need call del_chain(...) !
**************************************************************************/
static struct UniChar *text2chain(const Uint16 * pInText)
{
int i, len;
struct UniChar *pOutChain = NULL;
struct UniChar *chr_tmp = NULL;
len = unistrlen(pInText);
if (len == 0) {
return pOutChain;
}
pOutChain = fc_calloc(1, sizeof(struct UniChar));
pOutChain->chr[0] = pInText[0];
pOutChain->chr[1] = 0;
chr_tmp = pOutChain;
for (i = 1; i < len; i++) {
chr_tmp->next = fc_calloc(1, sizeof(struct UniChar));
chr_tmp->next->chr[0] = pInText[i];
chr_tmp->next->chr[1] = 0;
chr_tmp->next->prev = chr_tmp;
chr_tmp = chr_tmp->next;
}
return pOutChain;
}
/**************************************************************************
...
**************************************************************************/
static TTF_Font * load_font(Uint16 ptsize)
{
struct TTF_Font_Chain *Font_TAB_TMP = Font_TAB;
TTF_Font *font_tmp = NULL;
/* find existing font and return pointer to him */
if (Sizeof_Font_TAB) {
while (Font_TAB_TMP) {
if (Font_TAB_TMP->ptsize == ptsize) {
Font_TAB_TMP->count++;
return Font_TAB_TMP->font;
}
Font_TAB_TMP = Font_TAB_TMP->next;
}
}
if(!pFont_with_FullPath) {
const char *path = theme_font_filename(theme);
pFont_with_FullPath = fc_strdup(path);
fc_assert_ret_val(pFont_with_FullPath != NULL, NULL);
}
/* Load Font */
if ((font_tmp = TTF_OpenFont(pFont_with_FullPath, ptsize)) == NULL) {
log_error("load_font: Couldn't load %d pt font from %s: %s",
ptsize, pFont_with_FullPath, SDL_GetError());
return font_tmp;
}
/* add new font to list */
if (Sizeof_Font_TAB == 0) {
Sizeof_Font_TAB++;
Font_TAB_TMP = fc_calloc(1, sizeof(struct TTF_Font_Chain));
Font_TAB = Font_TAB_TMP;
} else {
/* Go to end of chain */
Font_TAB_TMP = Font_TAB;
while (Font_TAB_TMP->next)
Font_TAB_TMP = Font_TAB_TMP->next;
Sizeof_Font_TAB++;
Font_TAB_TMP->next = fc_calloc(1, sizeof(struct TTF_Font_Chain));
Font_TAB_TMP = Font_TAB_TMP->next;
}
Font_TAB_TMP->ptsize = ptsize;
Font_TAB_TMP->count = 1;
Font_TAB_TMP->font = font_tmp;
Font_TAB_TMP->next = NULL;
return font_tmp;
}
int
event_init(struct context *ctx, int size)
{
int status, ep;
struct epoll_event *event;
ASSERT(ctx->ep < 0);
ASSERT(ctx->nevent != 0);
ASSERT(ctx->event == NULL);
ep = epoll_create(size);
if (ep < 0) {
log_error("epoll create of size %d failed: %s", size, strerror(errno));
return -1;
}
event = fc_calloc(ctx->nevent, sizeof(*ctx->event));
if (event == NULL) {
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return -1;
}
ctx->ep = ep;
ctx->event = event;
log_debug(LOG_INFO, "e %d with nevent %d timeout %d", ctx->ep,
ctx->nevent, ctx->timeout);
return 0;
}
/**************************************************************************
Create string16 struct with ptsize font.
Font will be loaded or aliased with existing font of that size.
pInTextString must be allocated in memory (MALLOC/fc_calloc)
**************************************************************************/
SDL_String16 * create_string16(Uint16 *pInTextString,
size_t n_alloc, Uint16 ptsize)
{
SDL_String16 *str = fc_calloc(1, sizeof(SDL_String16));
if (!ptsize) {
str->ptsize = theme_default_font_size(theme);
} else {
str->ptsize = ptsize;
}
if ((str->font = load_font(str->ptsize)) == NULL) {
log_error("create_string16: load_font failed");
FC_FREE(str);
return str;
}
str->style = TTF_STYLE_NORMAL;
str->bgcol = (SDL_Color) {0, 0, 0, 0};
str->fgcol = *get_game_colorRGB(COLOR_THEME_TEXT);
str->render = 2;
/* pInTextString must be allocated in memory (MALLOC/fc_calloc) */
str->text = pInTextString;
str->n_alloc = n_alloc;
return str;
}
/**************************************************************************
...
**************************************************************************/
struct widget *create_checkbox(struct gui_layer *pDest, bool state, Uint32 flags)
{
struct widget *pCBox = widget_new();
struct CHECKBOX *pTmp = fc_calloc(1, sizeof(struct CHECKBOX));
if (state) {
pCBox->theme = pTheme->CBOX_Sell_Icon;
} else {
pCBox->theme = pTheme->CBOX_Unsell_Icon;
}
set_wflag(pCBox, (WF_FREE_STRING | WF_FREE_GFX | WF_FREE_PRIVATE_DATA | flags));
set_wstate(pCBox, FC_WS_DISABLED);
set_wtype(pCBox, WT_CHECKBOX);
pCBox->mod = KMOD_NONE;
pCBox->dst = pDest;
pTmp->state = state;
pTmp->pTRUE_Theme = pTheme->CBOX_Sell_Icon;
pTmp->pFALSE_Theme = pTheme->CBOX_Unsell_Icon;
pCBox->private_data.cbox = pTmp;
checkbox_baseclass_redraw = pCBox->redraw;
pCBox->redraw = redraw_icon;
pCBox->size.w = pCBox->theme->w / 4;
pCBox->size.h = pCBox->theme->h;
return pCBox;
}
int set_new_checkbox_theme(struct widget *pCBox ,
SDL_Surface *pTrue, SDL_Surface *pFalse)
{
struct CHECKBOX *pTmp;
if(!pCBox || (get_wtype(pCBox) != WT_CHECKBOX)) {
return -1;
}
if(!pCBox->private_data.cbox) {
pCBox->private_data.cbox = fc_calloc(1, sizeof(struct CHECKBOX));
set_wflag(pCBox, WF_FREE_PRIVATE_DATA);
pCBox->private_data.cbox->state = FALSE;
}
pTmp = pCBox->private_data.cbox;
pTmp->pTRUE_Theme = pTrue;
pTmp->pFALSE_Theme = pFalse;
if(pTmp->state) {
pCBox->theme = pTrue;
} else {
pCBox->theme = pFalse;
}
return 0;
}
/**********************************************************************
Set city icons sprite value; should only happen after
tileset_load_tiles(tileset).
***********************************************************************/
void tilespec_setup_city_icons(void)
{
struct sprite *pSpr = NULL;
pIcons = ( struct City_Icon *)fc_calloc(1, sizeof( struct City_Icon ));
load_city_icon_surface(pSpr, pBIG_Food_Corr, "city.food_waste");
load_city_icon_surface(pSpr, pBIG_Shield_Corr, "city.shield_waste");
load_city_icon_surface(pSpr, pBIG_Trade_Corr, "city.trade_waste");
load_city_icon_surface(pSpr, pBIG_Food, "city.food");
pIcons->pBIG_Food_Surplus = crop_rect_from_surface(pIcons->pBIG_Food, NULL);
SDL_SetAlpha(pIcons->pBIG_Food_Surplus, SDL_SRCALPHA, 128);
load_city_icon_surface(pSpr, pBIG_Shield, "city.shield");
pIcons->pBIG_Shield_Surplus = crop_rect_from_surface(pIcons->pBIG_Shield, NULL);
SDL_SetAlpha(pIcons->pBIG_Shield_Surplus, SDL_SRCALPHA, 128);
load_city_icon_surface(pSpr, pBIG_Trade, "city.trade");
load_city_icon_surface(pSpr, pBIG_Luxury, "city.lux");
load_city_icon_surface(pSpr, pBIG_Coin, "city.coin");
load_city_icon_surface(pSpr, pBIG_Colb, "city.colb");
load_city_icon_surface(pSpr, pBIG_Face, "city.red_face");
load_city_icon_surface(pSpr, pBIG_Coin_Corr, "city.dark_coin");
load_city_icon_surface(pSpr, pBIG_Coin_UpKeep, "city.unkeep_coin");
/* small icon */
load_city_icon_surface(pSpr, pFood, "city.small_food");
load_city_icon_surface(pSpr, pShield, "city.small_shield");
load_city_icon_surface(pSpr, pTrade, "city.small_trade");
load_city_icon_surface(pSpr, pFace, "city.small_red_face");
load_city_icon_surface(pSpr, pLuxury, "city.small_lux");
load_city_icon_surface(pSpr, pCoin, "city.small_coin");
load_city_icon_surface(pSpr, pColb, "city.small_colb");
load_city_icon_surface(pSpr, pPollution, "city.pollution");
/* ================================================================= */
load_city_icon_surface(pSpr, pPolice, "city.police");
/* ================================================================= */
pIcons->pWorklist = create_surf_alpha(9,9, SDL_SWSURFACE);
SDL_FillRect(pIcons->pWorklist, NULL,
SDL_MapRGB(pIcons->pWorklist->format, 255, 255,255));
putframe(pIcons->pWorklist, 0,0, pIcons->pWorklist->w - 1, pIcons->pWorklist->h - 1,
map_rgba(pIcons->pWorklist->format, *get_game_colorRGB(COLOR_THEME_CITYREP_FRAME)));
putline(pIcons->pWorklist, 3, 2, 5, 2,
map_rgba(pIcons->pWorklist->format, *get_game_colorRGB(COLOR_THEME_CITYREP_FRAME)));
putline(pIcons->pWorklist, 3, 4, 7, 4,
map_rgba(pIcons->pWorklist->format, *get_game_colorRGB(COLOR_THEME_CITYREP_FRAME)));
putline(pIcons->pWorklist, 3, 6, 6, 6,
map_rgba(pIcons->pWorklist->format, *get_game_colorRGB(COLOR_THEME_CITYREP_FRAME)));
/* ================================================================= */
/* force reload citizens icons */
pIcons->style = 999;
}
/**************************************************************************
Initialize player for use with threaded AI.
**************************************************************************/
void tai_player_alloc(struct ai_type *ait, struct player *pplayer)
{
struct tai_plr *player_data = fc_calloc(1, sizeof(struct tai_plr));
player_set_ai_data(pplayer, ait, player_data);
/* Default AI */
dai_data_init(ait, pplayer);
}
/****************************************************************************
Returns the basic structure.
****************************************************************************/
struct vision_site *create_vision_site(int identity, struct tile *location,
struct player *owner)
{
struct vision_site *psite = fc_calloc(1, sizeof(*psite));
psite->identity = identity;
psite->location = location;
psite->owner = owner;
return psite;
}
/****************************************************************************
Allocate new rgbcolor structure.
****************************************************************************/
struct rgbcolor *rgbcolor_new(int r, int g, int b)
{
struct rgbcolor *prgbcolor;
prgbcolor = fc_calloc(1, sizeof(*prgbcolor));
prgbcolor->r = r;
prgbcolor->g = g;
prgbcolor->b = b;
prgbcolor->color = NULL;
return prgbcolor;
}
/***************************************************************************
Initialize a dynamic bitvector of size 'bits'. 'bits' must be greater
than 0 and lower than the maximal size given by MAX_DBV_LENGTH. The
bitvector is set to all clear.
***************************************************************************/
void dbv_init(struct dbv *pdbv, int bits)
{
fc_assert_ret(pdbv->vec == NULL);
fc_assert_ret(pdbv->bits == 0);
fc_assert_ret(bits > 0 && bits < MAX_DBV_LENGTH);
pdbv->bits = bits;
pdbv->vec = fc_calloc(1, _BV_BYTES(pdbv->bits) * sizeof(*pdbv->vec));
dbv_clr_all(pdbv);
}
int aio_init(struct context *ctx){
struct io_event *event;
aio_fd = eventfd(0, EFD_NONBLOCK);
event = fc_calloc(5, sizeof(*ctx->aio_event));
ctx->aio_fd = aio_fd;
ctx->aio_event = event;
return 0;
}
/****************************************************************************
Initialize data structures required for edit mode.
****************************************************************************/
void edithand_init(void)
{
if (NULL != modified_tile_table) {
tile_hash_destroy(modified_tile_table);
}
modified_tile_table = tile_hash_new();
need_continents_reassigned = FALSE;
if (unfogged_players != NULL) {
free(unfogged_players);
}
unfogged_players = fc_calloc(player_slot_count(), sizeof(bool));
}
/*****************************************************************************
Create a lua console.
*****************************************************************************/
void luaconsole_dialog_init(void)
{
fc_assert_ret(luaconsole == NULL);
/* Create a container for the dialog. */
luaconsole = fc_calloc(1, sizeof(*luaconsole));
luaconsole->message_buffer = gtk_text_buffer_new(NULL);
luaconsole->shell = NULL;
luaconsole->history_list = genlist_new();
luaconsole->history_pos = -1;
luaconsole_welcome_message();
}
/**************************************************************************
Convert UniChar structure to Unistring ( Uint16[] ).
WARRING: Do not free UniChar structure but allocate new Unistring.
**************************************************************************/
static Uint16 *chain2text(const struct UniChar *pInChain, size_t len)
{
int i;
Uint16 *pOutText = NULL;
if (!(len && pInChain)) {
return pOutText;
}
pOutText = fc_calloc(len + 1, sizeof(Uint16));
for (i = 0; i < len; i++) {
pOutText[i] = pInChain->chr[0];
pInChain = pInChain->next;
}
return pOutText;
}
/**************************************************************************
...
**************************************************************************/
struct widget *widget_new(void)
{
struct widget *pWidget = fc_calloc(1, sizeof(struct widget));
pWidget->set_area = widget_core_set_area;
pWidget->set_position = widget_core_set_position;
pWidget->resize = widget_core_resize;
pWidget->redraw = widget_core_redraw;
pWidget->draw_frame = widget_core_draw_frame;
pWidget->mark_dirty = widget_core_mark_dirty;
pWidget->flush = widget_core_flush;
pWidget->undraw = widget_core_undraw;
pWidget->select = widget_core_select;
pWidget->unselect = widget_core_unselect;
return pWidget;
}
/**************************************************************************
...
**************************************************************************/
struct widget * create_textcheckbox(struct gui_layer *pDest, bool state,
SDL_String16 *pStr, Uint32 flags)
{
struct widget *pCBox;
struct CHECKBOX *pTmp;
SDL_Surface *pSurf, *pIcon;
struct widget *pTmpWidget;
if (!pStr) {
return create_checkbox(pDest, state, flags);
}
pTmp = fc_calloc(1, sizeof(struct CHECKBOX));
if (state) {
pSurf = pTheme->CBOX_Sell_Icon;
} else {
pSurf = pTheme->CBOX_Unsell_Icon;
}
pIcon = create_icon_from_theme(pSurf, 0);
pCBox = create_iconlabel(pIcon, pDest, pStr, (flags | WF_FREE_PRIVATE_DATA));
pStr->style &= ~SF_CENTER;
pCBox->theme = pSurf;
FREESURFACE(pIcon);
set_wtype(pCBox, WT_TCHECKBOX);
pTmp->state = state;
pTmp->pTRUE_Theme = pTheme->CBOX_Sell_Icon;
pTmp->pFALSE_Theme = pTheme->CBOX_Unsell_Icon;
pCBox->private_data.cbox = pTmp;
pTmpWidget = widget_new();
/* we can't use pCBox->redraw here, because it is of type iconlabel */
textcheckbox_baseclass_redraw = pTmpWidget->redraw;
FREEWIDGET(pTmpWidget);
pCBox->redraw = redraw_textcheckbox;
return pCBox;
}
/*****************************************************************************
Initialize the scripting state.
*****************************************************************************/
struct fc_lua *luascript_new(luascript_log_func_t output_fct)
{
struct fc_lua *fcl = fc_calloc(1, sizeof(*fcl));
fcl->state = luaL_newstate();
if (!fcl->state) {
FC_FREE(fcl);
return NULL;
}
fcl->output_fct = output_fct;
fcl->caller = NULL;
luascript_openlibs(fcl->state, luascript_lualibs);
luascript_traceback_func_save(fcl->state);
luascript_blacklist(fcl->state, luascript_unsafe_symbols);
/* Save the freeciv lua struct in the lua state. */
lua_pushstring(fcl->state, LUASCRIPT_GLOBAL_VAR_NAME);
lua_pushlightuserdata(fcl->state, fcl);
lua_settable(fcl->state, LUA_REGISTRYINDEX);
return fcl;
}
/**************************************************************************
...
**************************************************************************/
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 void show_main_page(void)
{
SDL_Color bg_color = {255, 255, 255, 96};
SDL_Color *line_color = &(SDL_Color) {
128, 128, 128, 255
};
int count = 0;
struct widget *pWidget = NULL, *pWindow = NULL;
SDL_Surface *pBackground;
int h = 0;
SDL_Rect area;
char verbuf[200];
/* create dialog */
pStartMenu = fc_calloc(1, sizeof(struct SMALL_DLG));
pWindow = create_window_skeleton(NULL, NULL, 0);
add_to_gui_list(ID_WINDOW, pWindow);
pStartMenu->pEndWidgetList = pWindow;
area = pWindow->area;
/* Freeciv version */
/* TRANS: Freeciv 2.4.0, gui-sdl client */
fc_snprintf(verbuf, sizeof(verbuf), _("Freeciv %s, %s client"), VERSION_STRING, client_string);
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, verbuf,
adj_font(12),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND|WF_FREE_DATA));
pWidget->string16->style |= SF_CENTER | TTF_STYLE_BOLD;
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
add_to_gui_list(ID_LABEL, pWidget);
/* Start New Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Start New Game"),
adj_font(14),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND|WF_FREE_DATA));
pWidget->action = start_new_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
add_to_gui_list(ID_START_NEW_GAME, pWidget);
/* Load Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Load Game"),
adj_font(14),
(WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND));
pWidget->action = load_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_LOAD_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join Game */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join Game"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = join_game_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join Pubserver */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join Pubserver"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = servers_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_META_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Join LAN Server */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Join LAN Server"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = servers_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_JOIN_GAME, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Options */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Options"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = options_callback;
pWidget->string16->style |= SF_CENTER;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_CLIENT_OPTIONS_BUTTON, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
/* Quit */
pWidget = create_iconlabel_from_chars(NULL, pWindow->dst, _("Quit"),
adj_font(14),
WF_SELLECT_WITHOUT_BAR|WF_RESTORE_BACKGROUND);
pWidget->action = quit_callback;
pWidget->string16->style |= SF_CENTER;
pWidget->key = SDLK_ESCAPE;
set_wstate(pWidget, FC_WS_NORMAL);
add_to_gui_list(ID_QUIT, pWidget);
area.w = MAX(area.w, pWidget->size.w);
h = MAX(h, pWidget->size.h);
count++;
pStartMenu->pBeginWidgetList = pWidget;
/* ------*/
area.w += adj_size(30);
h += adj_size(6);
area.h = MAX(area.h, h * count);
/* ------*/
pBackground = theme_get_background(theme, BACKGROUND_STARTMENU);
if (resize_window(pWindow, pBackground, NULL,
(pWindow->size.w - pWindow->area.w) + area.w,
(pWindow->size.h - pWindow->area.h) + area.h)) {
FREESURFACE(pBackground);
}
area = pWindow->area;
group_set_area(pWidget, pWindow->prev, area);
setup_vertical_widgets_position(1, area.x, area.y, area.w, h, pWidget, pWindow->prev);
area.h = h;
SDL_FillRectAlpha(pWindow->theme, &area, &bg_color);
widget_set_position(pWindow,
(Main.screen->w - pWindow->size.w) - adj_size(20),
(Main.screen->h - pWindow->size.h) - adj_size(20));
draw_intro_gfx();
redraw_group(pStartMenu->pBeginWidgetList, pStartMenu->pEndWidgetList, FALSE);
putline(pWindow->dst->surface,
area.x, area.y + (h - 1),
area.x + area.w - 1, area.y + (h - 1),
line_color);
set_output_window_text(_("SDLClient welcomes you..."));
chat_welcome_message();
meswin_dialog_popup(TRUE);
flush_all();
}
/***************************************************************************
...
***************************************************************************/
struct sprite *load_gfxfile(const char *filename)
{
png_structp pngp;
png_infop infop;
png_int_32 width, height, x, y;
FILE *fp;
int npalette, ntrans;
png_colorp palette;
png_bytep trans;
png_bytep buf, pb;
png_uint_32 stride;
unsigned long *pcolorarray;
bool *ptransarray;
struct sprite *mysprite;
XImage *xi;
int has_mask;
png_byte color_type;
png_byte alpha;
bool pixel, reported;
fp = fc_fopen(filename, "rb");
if (!fp) {
log_fatal("Failed reading PNG file: \"%s\"", filename);
exit(EXIT_FAILURE);
}
pngp = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!pngp) {
log_fatal("Failed creating PNG struct");
exit(EXIT_FAILURE);
}
infop = png_create_info_struct(pngp);
if (!infop) {
log_fatal("Failed creating PNG struct");
exit(EXIT_FAILURE);
}
if (setjmp(png_jmpbuf(pngp))) {
log_fatal("Failed while reading PNG file: \"%s\"", filename);
exit(EXIT_FAILURE);
}
png_init_io(pngp, fp);
png_set_strip_16(pngp);
png_set_packing(pngp);
png_read_info(pngp, infop);
width = png_get_image_width(pngp, infop);
height = png_get_image_height(pngp, infop);
color_type = png_get_color_type(pngp, infop);
if (color_type == PNG_COLOR_TYPE_PALETTE) {
if (png_get_PLTE(pngp, infop, &palette, &npalette)) {
int i;
XColor *mycolors;
pcolorarray = fc_malloc(npalette * sizeof(*pcolorarray));
mycolors = fc_malloc(npalette * sizeof(*mycolors));
for (i = 0; i < npalette; i++) {
mycolors[i].red = palette[i].red << 8;
mycolors[i].green = palette[i].green << 8;
mycolors[i].blue = palette[i].blue << 8;
}
alloc_colors(mycolors, npalette);
for (i = 0; i < npalette; i++) {
pcolorarray[i] = mycolors[i].pixel;
}
free(mycolors);
} else {
log_fatal("PNG file has no palette: \"%s\"", filename);
exit(EXIT_FAILURE);
}
has_mask = png_get_tRNS(pngp, infop, &trans, &ntrans, NULL);
if (has_mask) {
int i;
ptransarray = fc_calloc(npalette, sizeof(*ptransarray));
reported = FALSE;
for (i = 0; i < ntrans; i++) {
if (trans[i] < npalette) {
ptransarray[trans[i]] = TRUE;
} else if (!reported) {
log_verbose("PNG: Transparent array entry is out of palette: "
"\"%s\"", filename);
reported = TRUE;
}
}
} else {
ptransarray = NULL;
}
} else {
pcolorarray = NULL;
ptransarray = NULL;
npalette = 0;
if ((color_type == PNG_COLOR_TYPE_RGB_ALPHA)
|| (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) {
has_mask = 1;
} else {
has_mask = 0;
}
ntrans = 0;
}
png_read_update_info(pngp, infop);
{
png_bytep *row_pointers;
stride = png_get_rowbytes(pngp, infop);
buf = fc_malloc(stride * height);
row_pointers = fc_malloc(height * sizeof(png_bytep));
for (y = 0, pb = buf; y < height; y++, pb += stride) {
row_pointers[y] = pb;
}
png_read_image(pngp, row_pointers);
png_read_end(pngp, infop);
fclose(fp);
free(row_pointers);
if (infop != NULL) {
png_destroy_read_struct(&pngp, &infop, (png_infopp)NULL);
} else {
log_error("PNG info struct is NULL (non-fatal): \"%s\"", filename);
png_destroy_read_struct(&pngp, (png_infopp)NULL, (png_infopp)NULL);
}
}
mysprite = fc_malloc(sizeof(*mysprite));
xi = XCreateImage(display, DefaultVisual(display, screen_number),
display_depth, ZPixmap, 0, NULL, width, height, 32, 0);
xi->data = fc_calloc(xi->bytes_per_line * xi->height, 1);
pb = buf;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
if (pcolorarray) {
XPutPixel(xi, x, y, pcolorarray[pb[x]]);
} else {
if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
XPutPixel(xi, x, y,
(pb[2 * x] << 16) + (pb[2 * x] << 8)
+ pb[2 * x]);
} else {
if (has_mask) {
XPutPixel(xi, x, y,
(pb[4 * x] << 16) + (pb[4 * x + 1] << 8)
+ pb[4 * x + 2]);
} else {
XPutPixel(xi, x, y,
(pb[3 * x] << 16) + (pb[3 * x + 1] << 8)
+ pb[3 * x + 2]);
}
}
}
}
pb += stride;
}
mysprite->pixmap = image2pixmap(xi);
XDestroyImage(xi);
if (has_mask) {
XImage *xm;
xm = XCreateImage(display, DefaultVisual(display, screen_number),
1, XYBitmap, 0, NULL, width, height, 8, 0);
xm->data = fc_calloc(xm->bytes_per_line * xm->height, 1);
pb = buf;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
if (ptransarray) {
XPutPixel(xm, x, y, !ptransarray[pb[x]]);
} else {
if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
alpha = pb[2 * x + 1];
} else {
alpha = pb[4 * x + 3];
}
if (alpha > 204) {
pixel = FALSE;
} else if (alpha > 153) {
if ((y + x * 2) % 4 == 0) {
pixel = TRUE;
} else {
pixel = FALSE;
}
} else if (alpha > 102) {
if ((y + x) % 2 == 0) {
pixel = TRUE;
} else {
pixel = FALSE;
}
} else if (alpha > 51) {
if ((y + x * 2) % 4 == 0) {
pixel = FALSE;
} else {
pixel = TRUE;
}
} else {
pixel = TRUE;
}
XPutPixel(xm, x, y, !pixel);
}
}
pb += stride;
}
mysprite->mask = image2pixmap(xm);
XDestroyImage(xm);
}
mysprite->has_mask = has_mask;
mysprite->width = width;
mysprite->height = height;
mysprite->pcolorarray = pcolorarray;
mysprite->ncols = npalette;
if (ptransarray) {
free(ptransarray);
}
free(buf);
return mysprite;
}
/*
* Alloc and fill Theme struct
*/
void tilespec_setup_theme(void)
{
struct sprite *pBuf = NULL;
pTheme = fc_calloc(1, sizeof(struct Theme));
load_theme_surface(pBuf, FR_Left, "theme.left_frame");
load_theme_surface(pBuf, FR_Right, "theme.right_frame");
load_theme_surface(pBuf, FR_Top, "theme.top_frame");
load_theme_surface(pBuf, FR_Bottom, "theme.bottom_frame");
load_theme_surface(pBuf, Button, "theme.button");
load_theme_surface(pBuf, Edit, "theme.edit");
load_theme_surface(pBuf, CBOX_Sell_Icon, "theme.sbox");
load_theme_surface(pBuf, CBOX_Unsell_Icon, "theme.ubox");
load_theme_surface(pBuf, UP_Icon, "theme.UP_scroll");
load_theme_surface(pBuf, DOWN_Icon, "theme.DOWN_scroll");
#if 0
load_theme_surface(pBuf, LEFT_Icon, "theme.LEFT_scroll");
load_theme_surface(pBuf, RIGHT_Icon, "theme.RIGHT_scroll");
#endif
load_theme_surface(pBuf, Vertic, "theme.vertic_scrollbar");
load_theme_surface(pBuf, Horiz, "theme.horiz_scrollbar");
/* ------------------- */
load_theme_surface(pBuf, OK_PACT_Icon, "theme.pact_ok");
load_theme_surface(pBuf, CANCEL_PACT_Icon, "theme.pact_cancel");
/* ------------------- */
load_theme_surface(pBuf, Small_OK_Icon, "theme.SMALL_OK_button");
load_theme_surface(pBuf, Small_CANCEL_Icon, "theme.SMALL_FAIL_button");
/* ------------------- */
load_theme_surface(pBuf, OK_Icon, "theme.OK_button");
load_theme_surface(pBuf, CANCEL_Icon, "theme.FAIL_button");
load_theme_surface(pBuf, FORWARD_Icon, "theme.NEXT_button");
load_theme_surface(pBuf, BACK_Icon, "theme.BACK_button");
load_theme_surface(pBuf, L_ARROW_Icon, "theme.LEFT_ARROW_button");
load_theme_surface(pBuf, R_ARROW_Icon, "theme.RIGHT_ARROW_button");
load_theme_surface(pBuf, MAP_Icon, "theme.MAP_button");
load_theme_surface(pBuf, FindCity_Icon, "theme.FIND_CITY_button");
load_theme_surface(pBuf, NEW_TURN_Icon, "theme.NEW_TURN_button");
load_theme_surface(pBuf, LOG_Icon, "theme.LOG_button");
load_theme_surface(pBuf, UNITS_Icon, "theme.UNITS_INFO_button");
load_theme_surface(pBuf, Options_Icon, "theme.OPTIONS_button");
load_theme_surface(pBuf, Block, "theme.block");
load_theme_surface(pBuf, INFO_Icon, "theme.INFO_button");
load_theme_surface(pBuf, Army_Icon, "theme.ARMY_button");
load_theme_surface(pBuf, Happy_Icon, "theme.HAPPY_button");
load_theme_surface(pBuf, Support_Icon, "theme.HOME_button");
load_theme_surface(pBuf, Buy_PROD_Icon, "theme.BUY_button");
load_theme_surface(pBuf, PROD_Icon, "theme.PROD_button");
load_theme_surface(pBuf, QPROD_Icon, "theme.WORK_LIST_button");
load_theme_surface(pBuf, CMA_Icon, "theme.CMA_button");
load_theme_surface(pBuf, LOCK_Icon, "theme.LOCK_button");
load_theme_surface(pBuf, UNLOCK_Icon, "theme.UNLOCK_button");
load_theme_surface(pBuf, PLAYERS_Icon, "theme.PLAYERS_button");
load_theme_surface(pBuf, UNITS2_Icon, "theme.UNITS_button");
load_theme_surface(pBuf, SAVE_Icon, "theme.SAVE_button");
load_theme_surface(pBuf, LOAD_Icon, "theme.LOAD_button");
load_theme_surface(pBuf, DELETE_Icon, "theme.DELETE_button");
load_theme_surface(pBuf, BORDERS_Icon, "theme.BORDERS_button");
/* ------------------------------ */
load_theme_surface(pBuf, Tech_Tree_Icon, "theme.tech_tree");
/* ------------------------------ */
load_order_theme_surface(pBuf, Order_Icon, "theme.order_empty");
load_order_theme_surface(pBuf, OAutoAtt_Icon, "theme.order_auto_attack");
load_order_theme_surface(pBuf, OAutoConnect_Icon, "theme.order_auto_connect");
load_order_theme_surface(pBuf, OAutoExp_Icon, "theme.order_auto_explorer");
load_order_theme_surface(pBuf, OAutoSett_Icon, "theme.order_auto_settler");
load_order_theme_surface(pBuf, OBuildCity_Icon, "theme.order_build_city");
load_order_theme_surface(pBuf, OCutDownForest_Icon, "theme.order_cutdown_forest");
load_order_theme_surface(pBuf, OPlantForest_Icon, "theme.order_plant_forest");
load_order_theme_surface(pBuf, OMine_Icon, "theme.order_build_mining");
load_order_theme_surface(pBuf, OIrrigation_Icon, "theme.order_irrigation");
load_order_theme_surface(pBuf, ODone_Icon, "theme.order_done");
load_order_theme_surface(pBuf, ODisband_Icon, "theme.order_disband");
load_order_theme_surface(pBuf, OFortify_Icon, "theme.order_fortify");
load_order_theme_surface(pBuf, OGoto_Icon, "theme.order_goto");
load_order_theme_surface(pBuf, OGotoCity_Icon, "theme.order_goto_city");
load_order_theme_surface(pBuf, OHomeCity_Icon, "theme.order_home");
load_order_theme_surface(pBuf, ONuke_Icon, "theme.order_nuke");
load_order_theme_surface(pBuf, OParaDrop_Icon, "theme.order_paradrop");
load_order_theme_surface(pBuf, OPatrol_Icon, "theme.order_patrol");
load_order_theme_surface(pBuf, OPillage_Icon, "theme.order_pillage");
load_order_theme_surface(pBuf, ORailRoad_Icon, "theme.order_build_railroad");
load_order_theme_surface(pBuf, ORoad_Icon, "theme.order_build_road");
load_order_theme_surface(pBuf, OSentry_Icon, "theme.order_sentry");
load_order_theme_surface(pBuf, OUnload_Icon, "theme.order_unload");
load_order_theme_surface(pBuf, OWait_Icon, "theme.order_wait");
load_order_theme_surface(pBuf, OFortress_Icon, "theme.order_build_fortress");
load_order_theme_surface(pBuf, OFallout_Icon, "theme.order_clean_fallout");
load_order_theme_surface(pBuf, OPollution_Icon, "theme.order_clean_pollution");
load_order_theme_surface(pBuf, OAirBase_Icon, "theme.order_build_airbase");
load_order_theme_surface(pBuf, OTransform_Icon, "theme.order_transform");
load_order_theme_surface(pBuf, OAddCity_Icon, "theme.order_add_to_city");
load_order_theme_surface(pBuf, OWonder_Icon, "theme.order_carravan_wonder");
load_order_theme_surface(pBuf, OTrade_Icon, "theme.order_carravan_traderoute");
load_order_theme_surface(pBuf, OSpy_Icon, "theme.order_spying");
load_order_theme_surface(pBuf, OWakeUp_Icon, "theme.order_wakeup");
load_order_theme_surface(pBuf, OReturn_Icon, "theme.order_return");
load_order_theme_surface(pBuf, OAirLift_Icon, "theme.order_airlift");
load_order_theme_surface(pBuf, OLoad_Icon, "theme.order_load");
/* ------------------------------ */
return;
}
/**************************************************************************
Convert string from local encoding (8 bit char) to
display encoding (16 bit unicode) and resut put in pToUniString.
if pToUniString == NULL then resulting string will be allocate automaticaly.
'ulength' give real sizeof 'pToUniString' array.
Function return (Uint16 *) pointer to (new) pToUniString.
**************************************************************************/
Uint16 *convertcopy_to_utf16(Uint16 *pToUniString, size_t ulength,
const char *pFromString)
{
/* Start Parametrs */
const char *pTocode = get_display_encoding();
const char *pFromcode = get_internal_encoding();
const char *pStart = pFromString;
size_t length = strlen(pFromString) + 1;
Uint16 *pResult = pToUniString;
/* ===== */
iconv_t cd = iconv_open(pTocode, pFromcode);
if (cd == (iconv_t) (-1)) {
if (errno != EINVAL) {
return pToUniString;
}
}
if (!pResult) {
/* From 8 bit code to UTF-16 (16 bit code) */
ulength = length * 2;
pResult = fc_calloc(1, ulength);
}
iconv(cd, NULL, NULL, NULL, NULL); /* return to the initial state */
/* Do the conversion for real. */
{
const char *pInptr = pStart;
size_t Insize = length;
char *pOutptr = (char *)pResult;
size_t Outsize = ulength;
while (Insize > 0 && Outsize > 0) {
size_t Res =
iconv(cd, (ICONV_CONST char **) &pInptr, &Insize, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
if (errno == EINVAL) {
break;
} else {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if (!pToUniString) {
FC_FREE(pResult);
}
return pToUniString;
}
}
}
{
size_t Res = iconv(cd, NULL, NULL, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if (!pToUniString) {
FC_FREE(pResult);
}
return pToUniString;
}
}
}
iconv_close(cd);
return (Uint16 *) pResult;
}
/**************************************************************************
Convert string from display encoding (16 bit unicode) to
local encoding (8 bit char) and resut put in 'pToString'.
if 'pToString' == NULL then resulting string will be allocate automaticaly.
'length' give real sizeof 'pToString' array.
Function return (char *) pointer to (new) pToString.
**************************************************************************/
char *convertcopy_to_chars(char *pToString, size_t length,
const Uint16 * pFromUniString)
{
/* Start Parametrs */
const char *pFromcode = get_display_encoding();
const char *pTocode = get_internal_encoding();
const char *pStart = (char *) pFromUniString;
size_t ulength = (unistrlen(pFromUniString) + 1) * 2;
/* ===== */
char *pResult;
iconv_t cd;
/* ===== */
if (!pStart) {
return pToString;
}
cd = iconv_open(pTocode, pFromcode);
if (cd == (iconv_t) (-1)) {
if (errno != EINVAL) {
return pToString;
}
}
if (pToString) {
pResult = pToString;
} else {
length = ulength * 2; /* UTF-8: up to 4 bytes per char */
pResult = fc_calloc(1, length);
}
iconv(cd, NULL, NULL, NULL, NULL); /* return to the initial state */
/* Do the conversion for real. */
{
const char *pInptr = pStart;
size_t Insize = ulength;
char *pOutptr = pResult;
size_t Outsize = length;
while (Insize > 0 && Outsize > 0) {
size_t Res =
iconv(cd, (ICONV_CONST char **) &pInptr, &Insize, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
log_error("iconv() error: %s", fc_strerror(fc_get_errno()));
if (errno == EINVAL) {
break;
} else {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if(!pToString) {
FC_FREE(pResult);
}
return pToString;
}
}
}
{
size_t Res = iconv(cd, NULL, NULL, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if(!pToString) {
FC_FREE(pResult);
}
return pToString;
}
}
}
iconv_close(cd);
return pResult;
}
/**************************************************************************
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;
}
/**************************************************************************
...
**************************************************************************/
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;
}
/**************************************************************************
Popup (or raise) the spaceship dialog for the given player.
**************************************************************************/
void popup_spaceship_dialog(struct player *pPlayer)
{
struct SMALL_DLG *pSpaceShp;
if(!(pSpaceShp = get_spaceship_dialog(pPlayer))) {
struct widget *pBuf, *pWindow;
SDL_String16 *pStr;
char cBuf[128];
SDL_Rect area;
pSpaceShp = fc_calloc(1, sizeof(struct SMALL_DLG));
fc_snprintf(cBuf, sizeof(cBuf), _("The %s Spaceship"),
nation_adjective_for_player(pPlayer));
pStr = create_str16_from_char(cBuf, adj_font(12));
pStr->style |= TTF_STYLE_BOLD;
pWindow = create_window_skeleton(NULL, pStr, 0);
pWindow->action = space_dialog_window_callback;
set_wstate(pWindow, FC_WS_NORMAL);
pWindow->data.player = pPlayer;
pWindow->private_data.small_dlg = pSpaceShp;
add_to_gui_list(ID_WINDOW, pWindow);
pSpaceShp->pEndWidgetList = pWindow;
area = pWindow->area;
/* ---------- */
/* create 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->data.player = pPlayer;
pBuf->action = exit_space_dialog_callback;
set_wstate(pBuf, FC_WS_NORMAL);
pBuf->key = SDLK_ESCAPE;
area.w = MAX(area.w, (pBuf->size.w + adj_size(10)));
add_to_gui_list(ID_BUTTON, pBuf);
pBuf = create_themeicon_button_from_chars(pTheme->OK_Icon, pWindow->dst,
_("Launch"), adj_font(12), 0);
pBuf->action = launch_spaceship_callback;
area.w = MAX(area.w, pBuf->size.w);
area.h += pBuf->size.h + adj_size(20);
add_to_gui_list(ID_BUTTON, pBuf);
pStr = create_str16_from_char(get_spaceship_descr(NULL), adj_font(12));
pStr->bgcol = (SDL_Color) {
0, 0, 0, 0
};
pBuf = create_iconlabel(NULL, pWindow->dst, pStr, WF_RESTORE_BACKGROUND);
area.w = MAX(area.w, pBuf->size.w);
area.h += pBuf->size.h + adj_size(20);
add_to_gui_list(ID_LABEL, pBuf);
pSpaceShp->pBeginWidgetList = pBuf;
/* -------------------------------------------------------- */
area.w = MAX(area.w, adj_size(300) - (pWindow->size.w - pWindow->area.w));
resize_window(pWindow, NULL, NULL,
(pWindow->size.w - pWindow->area.w) + area.w,
(pWindow->size.h - pWindow->area.h) + area.h);
area = pWindow->area;
widget_set_position(pWindow,
(main_window_width() - pWindow->size.w) / 2,
(main_window_height() - 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);
/* launch button */
pBuf = pBuf->prev;
pBuf->size.x = area.x + (area.w - pBuf->size.w) / 2;
pBuf->size.y = area.y + area.h - pBuf->size.h - adj_size(7);
/* info label */
pBuf = pBuf->prev;
pBuf->size.x = area.x + (area.w - pBuf->size.w) / 2;
pBuf->size.y = area.y + adj_size(7);
dialog_list_prepend(dialog_list, pSpaceShp);
refresh_spaceship_dialog(pPlayer);
} else {
if (sellect_window_group_dialog(pSpaceShp->pBeginWidgetList,
pSpaceShp->pEndWidgetList)) {
widget_flush(pSpaceShp->pEndWidgetList);
}
}
}
/**************************************************************************
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;
}
/**************************************************************************
Popup a dialog giving a player choices when their caravan arrives at
a city (other than its home city). Example:
- Establish trade route.
- Help build wonder.
- Keep moving.
**************************************************************************/
void popup_caravan_dialog(struct unit *pUnit,
struct city *pHomecity, struct city *pDestcity)
{
struct widget *pWindow = NULL, *pBuf = NULL;
SDL_String16 *pStr;
struct CONTAINER *pCont;
char cBuf[128];
SDL_Rect area;
if (pCaravan_Dlg) {
return;
}
caravan_unit_id=pUnit->id;
caravan_city_id=pDestcity->id;
pCont = fc_calloc(1, sizeof(struct CONTAINER));
pCont->id0 = pUnit->id;
pCont->id1 = pDestcity->id;
pCaravan_Dlg = fc_calloc(1, sizeof(struct SMALL_DLG));
is_unit_move_blocked = TRUE;
fc_snprintf(cBuf, sizeof(cBuf), _("Your %s has arrived at %s"),
unit_name_translation(pUnit), city_name(pDestcity));
/* window */
pStr = create_str16_from_char(cBuf, adj_font(12));
pStr->style |= TTF_STYLE_BOLD;
pWindow = create_window_skeleton(NULL, pStr, 0);
pWindow->action = caravan_dlg_window_callback;
set_wstate(pWindow, FC_WS_NORMAL);
add_to_gui_list(ID_CARAVAN_DLG_WINDOW, pWindow);
pCaravan_Dlg->pEndWidgetList = pWindow;
area = pWindow->area;
area.h = MAX(area.h, adj_size(2));
/* ---------- */
if (can_cities_trade(pHomecity, pDestcity))
{
int revenue = get_caravan_enter_city_trade_bonus(pHomecity, pDestcity);
if (can_establish_trade_route(pHomecity, pDestcity)) {
fc_snprintf(cBuf, sizeof(cBuf),
_("Establish Trade route with %s ( %d R&G + %d trade )"),
city_name(pHomecity),
revenue,
trade_between_cities(pHomecity, pDestcity));
} else {
revenue = (revenue + 2) / 3;
fc_snprintf(cBuf, sizeof(cBuf),
_("Enter Marketplace ( %d R&G bonus )"), revenue);
}
create_active_iconlabel(pBuf, pWindow->dst, pStr,
cBuf, caravan_establish_trade_callback);
pBuf->data.cont = pCont;
set_wstate(pBuf, FC_WS_NORMAL);
add_to_gui_list(ID_LABEL, pBuf);
area.w = MAX(area.w, pBuf->size.w);
area.h += pBuf->size.h;
}
/* ---------- */
if (unit_can_help_build_wonder(pUnit, pDestcity)) {
create_active_iconlabel(pBuf, pWindow->dst, pStr,
_("Help build Wonder"), caravan_help_build_wonder_callback);
pBuf->data.cont = pCont;
set_wstate(pBuf, FC_WS_NORMAL);
add_to_gui_list(ID_LABEL, pBuf);
area.w = MAX(area.w, pBuf->size.w);
area.h += pBuf->size.h;
}
/* ---------- */
create_active_iconlabel(pBuf, pWindow->dst, pStr,
_("Keep moving"), exit_caravan_dlg_callback);
pBuf->data.cont = pCont;
set_wstate(pBuf, FC_WS_NORMAL);
set_wflag(pBuf, WF_FREE_DATA);
pBuf->key = SDLK_ESCAPE;
add_to_gui_list(ID_LABEL, pBuf);
area.w = MAX(area.w, pBuf->size.w);
area.h += pBuf->size.h;
/* ---------- */
pCaravan_Dlg->pBeginWidgetList = pBuf;
/* setup window size and start position */
resize_window(pWindow, NULL, NULL,
(pWindow->size.w - pWindow->area.w) + area.w,
(pWindow->size.h - pWindow->area.h) + area.h);
area = pWindow->area;
auto_center_on_focus_unit();
put_window_near_map_tile(pWindow, pWindow->size.w, pWindow->size.h,
unit_tile(pUnit));
/* setup widget size and start position */
pBuf = pWindow->prev;
setup_vertical_widgets_position(1,
area.x,
area.y + 1, area.w, 0,
pCaravan_Dlg->pBeginWidgetList, pBuf);
/* --------------------- */
/* redraw */
redraw_group(pCaravan_Dlg->pBeginWidgetList, pWindow, 0);
widget_flush(pWindow);
}
/****************************************************************
...
*****************************************************************/
void create_races_dialog(struct player *pplayer)
{
int per_row = 5;
int i, j, len, maxracelen, index, nat_count;
char maxracename[MAX_LEN_NAME];
char namebuf[64];
int space;
XtWidgetGeometry geom;
races_player = pplayer;
maxracelen = 0;
nations_iterate(pnation) {
if (is_nation_playable(pnation)) {
len = strlen(nation_adjective_translation(pnation));
maxracelen = MAX(maxracelen, len);
}
} nations_iterate_end;
maxracelen = MIN(maxracelen, MAX_LEN_NAME-1);
fc_snprintf(maxracename, sizeof(maxracename), "%*s", maxracelen+2, "W");
races_dialog_shell = I_T(XtCreatePopupShell("racespopup",
transientShellWidgetClass,
toplevel, NULL, 0));
races_form = XtVaCreateManagedWidget("racesform",
formWidgetClass,
races_dialog_shell, NULL);
races_label = I_L(XtVaCreateManagedWidget("raceslabel",
labelWidgetClass,
races_form, NULL));
races_toggles_viewport =
XtVaCreateManagedWidget("racestogglesviewport",
viewportWidgetClass,
races_form,
XtNfromVert, races_label,
NULL);
races_toggles_form =
XtVaCreateManagedWidget("racestogglesform",
formWidgetClass,
races_toggles_viewport,
NULL);
free(races_toggles);
races_toggles = fc_calloc(nation_count(), sizeof(Widget));
free(races_toggles_to_nations);
races_toggles_to_nations = fc_calloc(nation_count(),
sizeof(struct nation_type *));
i = 0;
j = 0;
index = 0;
nations_iterate(pnation) {
if (!is_nation_playable(pnation)) {
continue;
}
if (j == 0) {
index = i * per_row;
fc_snprintf(namebuf, sizeof(namebuf), "racestoggle%d", index);
if (i == 0) {
races_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_toggles_form,
XtNlabel, maxracename,
NULL);
} else {
races_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_toggles_form,
XtNradioGroup,
races_toggles[index - 1],
XtNfromVert,
races_toggles[index - per_row],
XtNlabel, maxracename,
NULL);
}
} else {
index = i * per_row + j;
fc_snprintf(namebuf, sizeof(namebuf), "racestoggle%d", index);
if (i == 0) {
races_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_toggles_form,
XtNradioGroup,
races_toggles[index - 1],
XtNfromHoriz,
races_toggles[index - 1],
XtNlabel, maxracename,
NULL);
} else {
races_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_toggles_form,
XtNradioGroup,
races_toggles[index - 1],
XtNfromVert,
races_toggles[index - per_row],
XtNfromHoriz,
races_toggles[index - 1],
XtNlabel, maxracename,
NULL);
}
}
races_toggles_to_nations[index] = pnation;
j++;
if (j >= per_row) {
j = 0;
i++;
}
} nations_iterate_end;
nat_count = index + 1;
races_leader_form =
XtVaCreateManagedWidget("racesleaderform",
formWidgetClass,
races_form,
XtNfromVert, races_toggles_viewport,
/* XtNfromHoriz, races_toggles_viewport,*/
NULL);
XtVaGetValues(races_leader_form, XtNdefaultDistance, &space, NULL);
XtQueryGeometry(races_toggles[0], NULL, &geom);
races_leader =
XtVaCreateManagedWidget("racesleader",
asciiTextWidgetClass,
races_leader_form,
XtNeditType, XawtextEdit,
XtNwidth,
space + 2*(geom.width + geom.border_width),
XtNstring, "",
NULL);
races_leader_pick_popupmenu = 0;
races_leader_pick_menubutton =
I_L(XtVaCreateManagedWidget("racesleaderpickmenubutton",
menuButtonWidgetClass,
races_leader_form,
/* XtNfromVert, races_leader,*/
XtNfromHoriz, races_leader,
NULL));
races_sex_label = I_L(XtVaCreateManagedWidget("racessexlabel",
labelWidgetClass,
races_form,
XtNfromVert, races_leader_form,
NULL));
races_sex_form = XtVaCreateManagedWidget("racessexform",
formWidgetClass,
races_form,
XtNfromVert, races_sex_label,
NULL);
races_sex_toggles[0] =
I_L(XtVaCreateManagedWidget("racessextoggle0",
toggleWidgetClass,
races_sex_form,
NULL));
races_sex_toggles[1] =
I_L(XtVaCreateManagedWidget("racessextoggle1",
toggleWidgetClass,
races_sex_form,
XtNfromHoriz,
(XtArgVal)races_sex_toggles[0],
XtNradioGroup,
races_sex_toggles[0],
NULL));
/* find out styles that can be used at the game beginning */
/* Limit of 64 city_styles should be deleted. -ev */
for (i = 0, b_s_num = 0; i < game.control.styles_count && i < 64; i++) {
if (!city_style_has_requirements(&city_styles[i])) {
city_style_idx[b_s_num] = i;
city_style_ridx[i] = b_s_num;
b_s_num++;
}
}
races_style_label =
I_L(XtVaCreateManagedWidget("racesstylelabel",
labelWidgetClass,
races_form,
XtNfromVert, races_sex_form,
/* XtNfromHoriz, races_toggles_viewport,*/
NULL));
races_style_form =
XtVaCreateManagedWidget("racesstyleform",
formWidgetClass,
races_form,
XtNfromVert, races_style_label,
/* XtNfromHoriz, races_toggles_viewport,*/
NULL);
free(races_style_toggles);
races_style_toggles = fc_calloc(b_s_num,sizeof(Widget));
for( i = 0; i < ((b_s_num-1)/per_row)+1; i++) {
index = i * per_row;
fc_snprintf(namebuf, sizeof(namebuf), "racesstyle%d", index);
if( i == 0 ) {
races_style_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_style_form,
XtNlabel, maxracename,
NULL);
} else {
races_style_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_style_form,
XtNradioGroup,
races_style_toggles[index-1],
XtNfromVert,
races_style_toggles[index-per_row],
XtNlabel, maxracename,
NULL);
}
for( j = 1; j < per_row; j++) {
index = i * per_row + j;
if( index >= b_s_num ) break;
fc_snprintf(namebuf, sizeof(namebuf), "racesstyle%d", index);
if( i == 0 ) {
races_style_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_style_form,
XtNradioGroup,
races_style_toggles[index-1],
XtNfromHoriz,
races_style_toggles[index-1],
XtNlabel, maxracename,
NULL);
} else {
races_style_toggles[index] =
XtVaCreateManagedWidget(namebuf,
toggleWidgetClass,
races_style_form,
XtNradioGroup,
races_style_toggles[index-1],
XtNfromVert,
races_style_toggles[index-per_row],
XtNfromHoriz,
races_style_toggles[index-1],
XtNlabel, maxracename,
NULL);
}
}
}
races_action_form = XtVaCreateManagedWidget("racesactionform",
formWidgetClass,
races_form,
XtNfromVert, races_style_form,
NULL);
races_ok_command =
I_L(XtVaCreateManagedWidget("racesokcommand",
commandWidgetClass,
races_action_form,
NULL));
races_random_command =
I_L(XtVaCreateManagedWidget("racesdisconnectcommand",
commandWidgetClass,
races_action_form,
XtNfromHoriz, races_ok_command,
NULL));
races_quit_command =
I_L(XtVaCreateManagedWidget("racesquitcommand",
commandWidgetClass,
races_action_form,
XtNfromHoriz, races_random_command,
NULL));
XtAddCallback(races_random_command, XtNcallback,
races_random_command_callback, NULL);
XtAddCallback(races_quit_command, XtNcallback,
races_quit_command_callback, NULL);
for (i = 0; i < nation_count(); i++) {
if (races_toggles[i]) {
XtAddCallback(races_toggles[i], XtNcallback,
races_toggles_callback, INT_TO_XTPOINTER(i));
}
}
XtAddCallback(races_ok_command, XtNcallback,
races_ok_command_callback, NULL);
XtSetKeyboardFocus(races_form, races_leader);
XtRealizeWidget(races_dialog_shell);
/* for(i=0; i<game.control.playable_nation_count; i++) {
races_toggles_to_nations[i] = i;
}
*/
qsort(races_toggles_to_nations, nat_count,
sizeof(struct nation_type *), races_indirect_compare);
/* Build nation_to_race_toggle */
free(nation_idx_to_race_toggle);
nation_idx_to_race_toggle =
fc_calloc(nation_count(), sizeof(int));
for (i = 0; i < nation_count(); i++) {
nation_idx_to_race_toggle[i] = -1;
}
for (i = 0; i < nation_count(); i++) {
if (races_toggles_to_nations[i]) {
nation_idx_to_race_toggle[nation_index(races_toggles_to_nations[i])] = i;
}
}
for (i = 0; i < nation_count(); i++) {
if (races_toggles[i]) {
XtVaSetValues(races_toggles[i],
XtNlabel,
(XtArgVal)nation_adjective_translation(races_toggles_to_nations[i]),
NULL);
}
}
for(i=0; i<b_s_num; i++) {
XtVaSetValues(races_style_toggles[i], XtNlabel,
(XtArgVal)city_style_name_translation(city_style_idx[i]), NULL);
}
select_random_race();
}