/**************************************************************************
Creates and popups the bribe dialog
**************************************************************************/
void popup_bribe_dialog(struct unit *punit, int cost)
{
char tbuf[128], buf[128];
fc_snprintf(tbuf, ARRAY_SIZE(tbuf), PL_("Treasury contains %d gold.",
"Treasury contains %d gold.",
client_player()->economic.gold),
client_player()->economic.gold);
if (cost <= client_player()->economic.gold) {
fc_snprintf(buf, sizeof(buf),
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Bribe unit for %d gold?\n%s",
"Bribe unit for %d gold?\n%s", cost), cost, tbuf);
popup_message_dialog(toplevel, "diplomatbribedialog", buf,
diplomat_bribe_yes_callback, 0, 0,
diplomat_bribe_no_callback, 0, 0,
NULL);
} else {
fc_snprintf(buf, sizeof(buf),
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Bribing the unit costs %d gold.\n%s",
"Bribing the unit costs %d gold.\n%s", cost), cost, tbuf);
popup_message_dialog(toplevel, "diplomatnogolddialog", buf,
diplomat_bribe_no_callback, 0, 0,
NULL);
}
}
/**************************************************************************
Popup the yes/no dialog for inciting, since we know the cost now
**************************************************************************/
void popup_incite_dialog(struct city *pcity, int cost)
{
char tbuf[128], buf[128];
fc_snprintf(tbuf, ARRAY_SIZE(tbuf), PL_("Treasury contains %d gold.",
"Treasury contains %d gold.",
client_player()->economic.gold),
client_player()->economic.gold);
if (INCITE_IMPOSSIBLE_COST == cost) {
fc_snprintf(buf, sizeof(buf), _("You can't incite a revolt in %s."),
city_name(pcity));
popup_message_dialog(toplevel, "diplomatnogolddialog", buf,
diplomat_incite_no_callback, 0, 0, NULL);
} else if (cost <= client_player()->economic.gold) {
fc_snprintf(buf, sizeof(buf),
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Incite a revolt for %d gold?\n%s",
"Incite a revolt for %d gold?\n%s", cost), cost, tbuf);
diplomat_target_id = pcity->id;
popup_message_dialog(toplevel, "diplomatrevoltdialog", buf,
diplomat_incite_yes_callback, 0, 0,
diplomat_incite_no_callback, 0, 0,
NULL);
} else {
fc_snprintf(buf, sizeof(buf),
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Inciting a revolt costs %d gold.\n%s",
"Inciting a revolt costs %d gold.\n%s", cost), cost, tbuf);
popup_message_dialog(toplevel, "diplomatnogolddialog", buf,
diplomat_incite_no_callback, 0, 0,
NULL);
}
}
/**************************************************************************
Load ai module from file.
**************************************************************************/
bool load_ai_module(const char *modname)
{
struct ai_type *ai = ai_type_alloc();
bool setup_success;
lt_dlhandle handle;
bool (*setup_func)(struct ai_type *ai);
const char *(*capstr_func)(void);
const char *capstr;
char buffer[2048];
char filename[1024];
if (ai == NULL) {
return FALSE;
}
init_ai(ai);
fc_snprintf(filename, sizeof(filename), "fc_ai_%s", modname);
fc_snprintf(buffer, sizeof(buffer), "%s", filename);
handle = lt_dlopenext(buffer);
if (handle == NULL) {
log_error(_("Cannot open AI module %s (%s)"), filename, fc_module_error());
return FALSE;
}
fc_snprintf(buffer, sizeof(buffer), "%s_capstr", filename);
capstr_func = lt_dlsym(handle, buffer);
if (capstr_func == NULL) {
log_error(_("Cannot find capstr function from ai module %s (%s)"),
filename, fc_module_error());
return FALSE;
}
capstr = capstr_func();
if (strcmp(FC_AI_MOD_CAPSTR, capstr)) {
log_error(_("Incompatible ai module %s:"), filename);
log_error(_(" Module options: %s"), capstr);
log_error(_(" Supported options: %s"), FC_AI_MOD_CAPSTR);
return FALSE;
}
fc_snprintf(buffer, sizeof(buffer), "%s_setup", filename);
setup_func = lt_dlsym(handle, buffer);
if (setup_func == NULL) {
log_error(_("Cannot find setup function from ai module %s (%s)"),
filename, fc_module_error());
return FALSE;
}
setup_success = setup_func(ai);
if (!setup_success) {
log_error(_("Setup of ai module %s failed."), filename);
return FALSE;
}
return TRUE;
}
/**************************************************************************
Update the information label which gives info on the current unit and the
square under the current unit, for specified unit. Note that in practice
punit is almost always (or maybe strictly always?) the focus unit.
Clears label if punit is NULL.
Also updates the cursor for the map_canvas (this is related because the
info label includes a "select destination" prompt etc).
Also calls update_unit_pix_label() to update the icons for units on this
square.
**************************************************************************/
void update_unit_info_label(struct unit_list *punitlist)
{
char buffer[512];
fc_snprintf(buffer, sizeof(buffer), "%s\n%s",
get_unit_info_label_text1(punitlist),
get_unit_info_label_text2(punitlist, 0));
xaw_set_label(unit_info_label, buffer);
if (punitlist && unit_list_size(punitlist) > 0) {
switch (hover_state) {
case HOVER_NONE:
XUndefineCursor(display, XtWindow(map_canvas));
break;
case HOVER_PATROL:
XDefineCursor(display, XtWindow(map_canvas), cursors[CURSOR_PATROL]);
break;
case HOVER_GOTO:
case HOVER_CONNECT:
XDefineCursor(display, XtWindow(map_canvas), cursors[CURSOR_GOTO]);
break;
case HOVER_NUKE:
XDefineCursor(display, XtWindow(map_canvas), cursors[CURSOR_NUKE]);
break;
case HOVER_PARADROP:
XDefineCursor(display, XtWindow(map_canvas), cursors[CURSOR_PARADROP]);
break;
}
} else {
xaw_set_label(unit_info_label, "");
XUndefineCursor(display, XtWindow(map_canvas));
}
update_unit_pix_label(punitlist);
}
/****************************************************************************
Convert a hex string into a rgb color
****************************************************************************/
bool rgbcolor_from_hex(struct rgbcolor **prgbcolor, const char *hex)
{
int rgb, r, g, b;
char hex2[16];
fc_assert_ret_val(*prgbcolor == NULL, FALSE);
fc_assert_ret_val(hex != NULL, FALSE);
if (hex[0] == '#') {
hex++;
}
if (strlen(hex) != 6) {
return FALSE;
}
fc_snprintf(hex2, sizeof(hex2), "0x%s", hex);
if (!sscanf(hex2, "%x", &rgb)) {
return FALSE;
}
r = rgb / 256 / 256;
g = (rgb - r * 256 * 256) / 256;
b = rgb % 256;
*prgbcolor = rgbcolor_new(r, g, b);
return TRUE;
}
/****************************************************************
Popup unit bribe dialog
*****************************************************************/
void popup_bribe_dialog(struct unit *punit, int cost)
{
GtkWidget *shell;
char buf[1024];
fc_snprintf(buf, ARRAY_SIZE(buf), PL_("Treasury contains %d gold.",
"Treasury contains %d gold.",
client_player()->economic.gold),
client_player()->economic.gold);
if (cost <= client_player()->economic.gold) {
shell = gtk_message_dialog_new(NULL, 0,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Bribe unit for %d gold?\n%s",
"Bribe unit for %d gold?\n%s", cost), cost, buf);
gtk_window_set_title(GTK_WINDOW(shell), _("Bribe Enemy Unit"));
setup_dialog(shell, toplevel);
} else {
shell = gtk_message_dialog_new(NULL, 0,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Bribing the unit costs %d gold.\n%s",
"Bribing the unit costs %d gold.\n%s", cost), cost, buf);
gtk_window_set_title(GTK_WINDOW(shell), _("Traitors Demand Too Much!"));
setup_dialog(shell, toplevel);
}
gtk_window_present(GTK_WINDOW(shell));
g_signal_connect(shell, "response", G_CALLBACK(bribe_response), NULL);
}
/**************************************************************************
Log city messages, they will appear like this
2: Polish Romenna(5,35) [s1 d106 u11 g1] must have Archers ...
**************************************************************************/
void real_city_log(const char *file, const char *function, int line,
enum log_level level, bool notify,
const struct city *pcity, const char *msg, ...)
{
char buffer[500];
char buffer2[500];
va_list ap;
char aibuf[500] = "\0";
CALL_PLR_AI_FUNC(log_fragment_city, city_owner(pcity), aibuf, sizeof(aibuf), pcity);
fc_snprintf(buffer, sizeof(buffer), "%s %s(%d,%d) [s%d] {%s} ",
nation_rule_name(nation_of_city(pcity)),
city_name(pcity),
TILE_XY(pcity->tile), city_size_get(pcity),
aibuf);
va_start(ap, msg);
fc_vsnprintf(buffer2, sizeof(buffer2), msg, ap);
va_end(ap);
cat_snprintf(buffer, sizeof(buffer), "%s", buffer2);
if (notify) {
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buffer);
}
do_log(file, function, line, FALSE, level, "%s", buffer);
}
/*****************************************************************************
Main backtrace callback called from logging code.
*****************************************************************************/
static void backtrace_log(enum log_level level, bool print_from_where,
const char *where, const char *msg)
{
if (previous != NULL) {
/* Call chained callback first */
previous(level, print_from_where, where, msg);
}
if (level <= LOG_ERROR) {
void *buffer[MAX_NUM_FRAMES];
int frames;
char **names;
frames = backtrace(buffer, sizeof(buffer));
names = backtrace_symbols(buffer, frames);
if (names == NULL) {
write_backtrace_line(LOG_BACKTRACE, FALSE, NULL, "No backtrace");
} else {
int i;
write_backtrace_line(LOG_BACKTRACE, FALSE, NULL, "Backtrace:");
for (i = 0; i < MIN(frames, MAX_NUM_FRAMES); i++) {
char linestr[256];
fc_snprintf(linestr, sizeof(linestr), "%5d: %s", i, names[i]);
write_backtrace_line(LOG_BACKTRACE, FALSE, NULL, linestr);
}
free(names);
}
}
}
/**************************************************************************
Log player tech messages.
**************************************************************************/
void real_tech_log(const char *file, const char *function, int line,
enum log_level level, bool notify,
const struct player *pplayer, struct advance *padvance,
const char *msg, ...)
{
char buffer[500];
char buffer2[500];
va_list ap;
if (!valid_advance(padvance) || advance_by_number(A_NONE) == padvance) {
return;
}
fc_snprintf(buffer, sizeof(buffer), "%s::%s (want %d, dist %d) ",
player_name(pplayer),
advance_name_by_player(pplayer, advance_number(padvance)),
pplayer->ai_common.tech_want[advance_index(padvance)],
num_unknown_techs_for_goal(pplayer, advance_number(padvance)));
va_start(ap, msg);
fc_vsnprintf(buffer2, sizeof(buffer2), msg, ap);
va_end(ap);
cat_snprintf(buffer, sizeof(buffer), "%s", buffer2);
if (notify) {
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buffer);
}
do_log(file, function, line, FALSE, level, "%s", buffer);
}
/**********************************************************************
Return the BETA message.
If returns NULL, not a beta version.
***********************************************************************/
const char *beta_message(void)
{
#if IS_BETA_VERSION
static char msgbuf[128];
static const char *month[] =
{
NULL,
N_("January"),
N_("February"),
N_("March"),
N_("April"),
N_("May"),
N_("June"),
N_("July"),
N_("August"),
N_("September"),
N_("October"),
N_("November"),
N_("December")
};
fc_snprintf (msgbuf, sizeof (msgbuf),
/* TRANS: No full stop after the URL, could cause confusion. */
_("THIS IS A BETA VERSION\n"
"Freeciv %s will be released in %s, at %s"),
NEXT_STABLE_VERSION, _(NEXT_RELEASE_MONTH), WIKI_URL);
return msgbuf;
#else
return NULL;
#endif
}
/****************************************************************
...
*****************************************************************/
void popup_caravan_dialog(struct unit *punit,
struct city *phomecity, struct city *pdestcity)
{
char buf[128];
fc_snprintf(buf, sizeof(buf),
_("Your %s from %s reaches the city of %s.\nWhat now?"),
unit_name_translation(punit),
city_name(phomecity), city_name(pdestcity));
caravan_city_id=pdestcity->id; /* callbacks need these */
caravan_unit_id=punit->id;
caravan_dialog=popup_message_dialog(toplevel, "caravandialog",
buf,
caravan_establish_trade_callback, 0, 0,
caravan_help_build_wonder_callback, 0, 0,
caravan_keep_moving_callback, 0, 0,
NULL);
if (!can_cities_trade(phomecity, pdestcity))
XtSetSensitive(XtNameToWidget(caravan_dialog, "*button0"), FALSE);
if(!unit_can_help_build_wonder(punit, pdestcity))
XtSetSensitive(XtNameToWidget(caravan_dialog, "*button1"), FALSE);
}
/****************************************************************
Popup rates dialog
*****************************************************************/
void popup_rates_dialog(void)
{
char buf[64];
if (!can_client_issue_orders()) {
return;
}
if (!rates_dialog_shell) {
rates_dialog_shell = create_rates_dialog();
}
if (!rates_dialog_shell) {
return;
}
fc_snprintf(buf, sizeof(buf), _("%s max rate: %d%%"),
government_name_for_player(client.conn.playing),
get_player_bonus(client.conn.playing, EFT_MAX_RATES));
gtk_label_set_text(GTK_LABEL(rates_gov_label), buf);
gtk_range_set_fill_level(GTK_RANGE(rates_tax_scale),
get_player_bonus(client.conn.playing,
EFT_MAX_RATES)/10);
gtk_range_set_fill_level(GTK_RANGE(rates_lux_scale),
get_player_bonus(client.conn.playing,
EFT_MAX_RATES)/10);
gtk_range_set_fill_level(GTK_RANGE(rates_sci_scale),
get_player_bonus(client.conn.playing,
EFT_MAX_RATES)/10);
gtk_window_present(GTK_WINDOW(rates_dialog_shell));
}
/**************************************************************************
Called when the return key is pressed.
**************************************************************************/
static void inputline_return(GtkEntry *w, gpointer data)
{
const char *theinput;
theinput = gtk_entry_get_text(w);
if (*theinput) {
if (client_state() == C_S_RUNNING && gui_gtk2_allied_chat_only
&& is_plain_public_message(theinput)) {
char buf[MAX_LEN_MSG];
fc_snprintf(buf, sizeof(buf), ". %s", theinput);
send_chat(buf);
} else {
send_chat(theinput);
}
if (genlist_size(history_list) >= MAX_CHATLINE_HISTORY) {
void *data;
data = genlist_get(history_list, -1);
genlist_remove(history_list, data);
free(data);
}
genlist_prepend(history_list, fc_strdup(theinput));
history_pos=-1;
}
gtk_entry_set_text(w, "");
}
/****************************************************************************
Update a font option which is not attached to a widget.
****************************************************************************/
void gui_update_font_full(const char *font_name, const char *font_value,
GtkStyle **pstyle)
{
GtkSettings *settings;
GdkScreen *screen;
GtkStyle *style;
char buf[64];
gui_update_font(font_name, font_value);
screen = gdk_screen_get_default();
settings = gtk_settings_get_for_screen(screen);
fc_snprintf(buf, sizeof(buf), "Freeciv*.%s", font_name);
style = gtk_rc_get_style_by_paths(settings, buf, NULL, G_TYPE_NONE);
if (style) {
g_object_ref(style);
} else {
style = gtk_style_new();
}
if (*pstyle) {
g_object_unref(*pstyle);
}
*pstyle = style;
}
/****************************************************************
Fills the buf with proper text which should be displayed on
the helpbuild wonder button.
*****************************************************************/
static void get_help_build_wonder_button_label(char* buf, int bufsize,
bool* help_build_possible)
{
struct city* destcity = game_city_by_number(caravan_city_id);
struct unit* caravan = game_unit_by_number(caravan_unit_id);
if (destcity && caravan
&& unit_can_help_build_wonder(caravan, destcity)) {
fc_snprintf(buf, bufsize, _("Help build _Wonder (%d remaining)"),
impr_build_shield_cost(destcity->production.value.building)
- destcity->shield_stock);
*help_build_possible = TRUE;
} else {
fc_snprintf(buf, bufsize, _("Help build _Wonder"));
*help_build_possible = FALSE;
}
}
/**********************************************************************
...
***********************************************************************/
const char *freeciv_name_version(void)
{
static char msgbuf[128];
#if IS_BETA_VERSION
fc_snprintf(msgbuf, sizeof (msgbuf), _("Freeciv version %s %s"),
VERSION_STRING, _("(beta version)"));
#elif defined(SVNREV) && !defined(FC_SVNREV_OFF)
fc_snprintf(msgbuf, sizeof (msgbuf), _("Freeciv version %s (%s)"),
VERSION_STRING, fc_svn_revision());
#else
fc_snprintf(msgbuf, sizeof (msgbuf), _("Freeciv version %s"),
VERSION_STRING);
#endif
return msgbuf;
}
/**************************************************************************
Called by the GUI code when the user sets the ruleset. The ruleset
passed in here should match one of the strings given to gui_set_rulesets.
**************************************************************************/
void set_ruleset(const char *ruleset)
{
char buf[4096];
fc_snprintf(buf, sizeof(buf), "/read %s%s", ruleset, RULESET_SUFFIX);
log_debug("Executing '%s'", buf);
send_chat(buf);
}
/****************************************************************
...
*****************************************************************/
void popup_caravan_dialog(struct unit *punit,
struct city *phomecity, struct city *pdestcity)
{
char title_buf[128], buf[128], wonder[128];
bool can_establish, can_trade, can_wonder;
fc_snprintf(title_buf, sizeof(title_buf),
/* TRANS: %s is a unit type */
_("Your %s Has Arrived"), unit_name_translation(punit));
fc_snprintf(buf, sizeof(buf),
_("Your %s from %s reaches the city of %s.\nWhat now?"),
unit_name_translation(punit),
city_name(phomecity), city_name(pdestcity));
caravan_city_id=pdestcity->id; /* callbacks need these */
caravan_unit_id=punit->id;
get_help_build_wonder_button_label(wonder, sizeof(wonder), &can_wonder);
can_trade = can_cities_trade(phomecity, pdestcity);
can_establish = can_trade
&& can_establish_trade_route(phomecity, pdestcity);
caravan_dialog = popup_choice_dialog(GTK_WINDOW(toplevel),
title_buf, buf,
(can_establish ? _("Establish _Trade route") :
_("Enter Marketplace")),caravan_establish_trade_callback, NULL,
wonder,caravan_help_build_wonder_callback, NULL,
_("_Keep moving"), NULL, NULL,
NULL);
g_signal_connect(caravan_dialog, "destroy",
G_CALLBACK(caravan_destroy_callback), NULL);
if (!can_trade) {
choice_dialog_button_set_sensitive(caravan_dialog, 0, FALSE);
}
if (!can_wonder) {
choice_dialog_button_set_sensitive(caravan_dialog, 1, FALSE);
}
}
/****************************************************************
Get nth button widget from dialog
*****************************************************************/
static GtkWidget* choice_dialog_get_nth_button(GtkWidget *cd,
int button)
{
char button_name[512];
GtkWidget *b;
fc_snprintf(button_name, sizeof(button_name), "button%d", button);
b = g_object_get_data(G_OBJECT(cd), button_name);
return b;
}
/***************************************************************************
Look up the service at hostname:port using getaddrinfo().
***************************************************************************/
static struct fc_sockaddr_list *net_lookup_getaddrinfo(const char *name,
int port,
enum fc_addr_family family)
{
struct addrinfo hints;
struct addrinfo *res;
int err;
char servname[8];
int gafam;
struct fc_sockaddr_list *addrs = fc_sockaddr_list_new();
switch (family) {
case FC_ADDR_IPV4:
gafam = AF_INET;
break;
case FC_ADDR_IPV6:
gafam = AF_INET6;
break;
case FC_ADDR_ANY:
gafam = AF_UNSPEC;
break;
default:
fc_assert(FALSE);
return addrs;
}
/* Convert port to string for getaddrinfo() */
fc_snprintf(servname, sizeof(servname), "%d", port);
/* Use getaddrinfo() to lookup IPv6 addresses */
memset(&hints, 0, sizeof(hints));
hints.ai_family = gafam;
hints.ai_socktype = SOCK_DGRAM; /* any type that uses sin6_port */
hints.ai_flags = AI_PASSIVE | FC_AI_NUMERICSERV;
err = getaddrinfo(name, servname, &hints, &res);
if (err == 0) {
struct addrinfo *current = res;
while (current != NULL) {
union fc_sockaddr *caddr = fc_malloc(sizeof(*caddr));
memcpy(caddr, current->ai_addr, MIN(sizeof(*caddr), current->ai_addrlen));
fc_sockaddr_list_append(addrs, caddr);
current = current->ai_next;
}
}
return addrs;
}
/****************************************************************
Parameters after named parameters should be in triplets:
- callback, callback_data, fixed_width
*****************************************************************/
Widget popup_message_dialog(Widget parent, const char *dialogname,
const char *text, ...)
{
va_list args;
Widget dshell, dform, button;
Position x, y;
Dimension width, height;
void (*fcb)(Widget, XtPointer, XtPointer);
XtPointer client_data;
char button_name[512];
int i, fixed_width;
XtSetSensitive(parent, FALSE);
I_T(dshell=XtCreatePopupShell(dialogname, transientShellWidgetClass,
parent, NULL, 0));
dform=XtVaCreateManagedWidget("dform", formWidgetClass, dshell, NULL);
/* caller should i18n text as desired */
XtVaCreateManagedWidget("dlabel", labelWidgetClass, dform,
XtNlabel, (XtArgVal)text,
NULL);
i=0;
va_start(args, text);
while((fcb=((void(*)(Widget, XtPointer, XtPointer))(va_arg(args, void *))))) {
client_data=va_arg(args, XtPointer);
fixed_width=va_arg(args, int);
fc_snprintf(button_name, sizeof(button_name), "button%d", i++);
button=XtVaCreateManagedWidget(button_name, commandWidgetClass,
dform, NULL);
if (fixed_width) {
I_LW(button);
} else {
I_L(button);
}
XtAddCallback(button, XtNcallback, fcb, client_data);
}
va_end(args);
XtVaGetValues(parent, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(parent, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(dshell, XtNx, x, XtNy, y, NULL);
XtPopup(dshell, XtGrabNone);
return dshell;
}
/******************************************************************
Returns a string telling how many turns the player has been idle.
*******************************************************************/
static const char *col_idle(const struct player *plr)
{
int idle;
static char buf[100];
if (plr->nturns_idle > 3) {
idle = plr->nturns_idle - 1;
} else {
idle = 0;
}
fc_snprintf(buf, sizeof(buf), "%d", idle);
return buf;
}
/**************************************************************************
Updates a gui font style.
**************************************************************************/
void gui_update_font(const char *font_name, const char *font_value)
{
char str[512];
fc_snprintf(str, sizeof(str),
"style \"ext-%s\" {\n"
" font_name = \"%s\"\n"
"}\n"
"\n"
"widget \"Freeciv*.%s\" style \"ext-%s\"",
font_name, font_value, font_name, font_name);
gtk_rc_parse_string(str);
}
/*****************************************************************************
The number of citizens for the player in the city.
*****************************************************************************/
static const char *col_citizens(const struct city *pcity,
const struct player_slot *pslot)
{
citizens nationality = citizens_nation_get(pcity, pslot);
if (nationality == 0) {
return "-";
} else {
static char buf[8];
fc_snprintf(buf, sizeof(buf), "%d", nationality);
return buf;
}
}
/****************************************************************************
Convert a rgb color to a hex string (like 0xff0000 for red [255, 0, 0]).
****************************************************************************/
bool rgbcolor_to_hex(const struct rgbcolor *prgbcolor, char *hex,
size_t hex_len)
{
fc_assert_ret_val(prgbcolor != NULL, FALSE);
/* Needs a length greater than 7 ('#' + 6 hex digites and '\0'). */
fc_assert_ret_val(hex_len > 7, FALSE);
fc_assert_ret_val(0 <= prgbcolor->r && prgbcolor->r <= 255, FALSE);
fc_assert_ret_val(0 <= prgbcolor->g && prgbcolor->g <= 255, FALSE);
fc_assert_ret_val(0 <= prgbcolor->b && prgbcolor->b <= 255, FALSE);
fc_snprintf(hex, hex_len, "#%06x",
(prgbcolor->r * 256 + prgbcolor->g) * 256 + prgbcolor->b);
return TRUE;
}
/****************************************************************
Confirm that the user wants to remove the selected preset.
*****************************************************************/
static void remove_preset(Widget w, XtPointer list,
XtPointer call_data)
{
XawListReturnStruct *ret = XawListShowCurrent(preset_list);
char buf[256];
if (ret->list_index != XAW_LIST_NONE && cmafec_preset_num()) {
fc_snprintf(buf, sizeof(buf),
_("Do you really want to remove %s?"),
cmafec_preset_get_descr(ret->list_index));
popup_message_dialog(cma_dialog, "cmaremovepreset",
buf, remove_preset_yes,
INT_TO_XTPOINTER(ret->list_index), 0,
remove_preset_no, 0, 0,
NULL);
}
}
/******************************************************************
Returns a translated string giving the diplomatic status
("war" or "ceasefire (5)").
*******************************************************************/
static const char *col_diplstate(const struct player *player)
{
static char buf[100];
const struct player_diplstate *pds;
if (NULL == client.conn.playing || player == client.conn.playing) {
return "-";
} else {
pds = player_diplstate_get(client.conn.playing, player);
if (pds->type == DS_CEASEFIRE || pds->type == DS_ARMISTICE) {
fc_snprintf(buf, sizeof(buf), "%s (%d)",
diplstate_text(pds->type), pds->turns_left);
return buf;
} else {
return diplstate_text(pds->type);
}
}
}
/**************************************************************************
Writes the supplied string into the file defined by the variable
'default_chat_logfile'.
**************************************************************************/
void write_chatline_content(const char *txt)
{
FILE *fp = fc_fopen(default_chat_logfile, "w");
char buf[512];
fc_snprintf(buf, sizeof(buf), _("Exporting output window to '%s' ..."),
default_chat_logfile);
output_window_append(ftc_client, buf);
if (fp) {
fputs(txt, fp);
fclose(fp);
output_window_append(ftc_client, _("Export complete."));
} else {
output_window_append(ftc_client,
_("Export failed, couldn't write to file."));
}
}
/****************************************************************************
Initialize events.
Now also initialise sorted_events[].
****************************************************************************/
void events_init(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(event_to_index); i++) {
event_to_index[i] = 0;
}
for (i = 0; events[i].enum_name; i++) {
int j;
if (E_S_XYZZY > events[i].esn) {
const char *event_format = Q_(event_sections[events[i].esn]);
int l = 1 + strlen(event_format) + strlen(_(events[i].descr_orig));
events[i].full_descr = fc_malloc(l);
fc_snprintf(events[i].full_descr, l, event_format,
_(events[i].descr_orig));
} else {
/* No section part */
events[i].full_descr = _(events[i].descr_orig);
}
event_to_index[events[i].event] = i;
events[i].tag_name = fc_strdup(events[i].enum_name);
for (j = 0; j < strlen(events[i].tag_name); j++) {
events[i].tag_name[j] = fc_tolower(events[i].tag_name[j]);
}
log_debug("event[%d]=%d: name='%s' / '%s'\n"
"\tdescr_orig='%s'\n"
"\tdescr='%s'",
i, events[i].event, events[i].enum_name, events[i].tag_name,
events[i].descr_orig, events[i].full_descr);
}
for (i = 0; i < E_LAST; i++) {
sorted_events[i] = i;
}
qsort(sorted_events, E_LAST, sizeof(*sorted_events),
compar_event_message_texts);
}
/****************************************************************
Popup the yes/no dialog for inciting, since we know the cost now
*****************************************************************/
void popup_incite_dialog(struct city *pcity, int cost)
{
GtkWidget *shell;
char buf[1024];
fc_snprintf(buf, ARRAY_SIZE(buf), PL_("Treasury contains %d gold.",
"Treasury contains %d gold.",
client_player()->economic.gold),
client_player()->economic.gold);
if (INCITE_IMPOSSIBLE_COST == cost) {
shell = gtk_message_dialog_new(NULL,
0,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
_("You can't incite a revolt in %s."),
city_name(pcity));
gtk_window_set_title(GTK_WINDOW(shell), _("City can't be incited!"));
setup_dialog(shell, toplevel);
} else if (cost <= client_player()->economic.gold) {
shell = gtk_message_dialog_new(NULL, 0,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Incite a revolt for %d gold?\n%s",
"Incite a revolt for %d gold?\n%s", cost), cost, buf);
gtk_window_set_title(GTK_WINDOW(shell), _("Incite a Revolt!"));
setup_dialog(shell, toplevel);
} else {
shell = gtk_message_dialog_new(NULL,
0,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
/* TRANS: %s is pre-pluralised "Treasury contains %d gold." */
PL_("Inciting a revolt costs %d gold.\n%s",
"Inciting a revolt costs %d gold.\n%s", cost), cost, buf);
gtk_window_set_title(GTK_WINDOW(shell), _("Traitors Demand Too Much!"));
setup_dialog(shell, toplevel);
}
gtk_window_present(GTK_WINDOW(shell));
g_signal_connect(shell, "response", G_CALLBACK(incite_response), NULL);
}
