Freeciv-3.3
Loading...
Searching...
No Matches
pages.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18#include <stdio.h>
19#include <time.h>
20
21#include <sys/stat.h>
22
23#include <gtk/gtk.h>
24
25/* utility */
26#include "fcintl.h"
27#include "log.h"
28#include "mem.h"
29#include "shared.h"
30#include "support.h"
31
32/* common */
33#include "dataio.h"
34#include "game.h"
35#include "mapimg.h"
36#include "version.h"
37
38/* client */
39#include "client_main.h"
40#include "climisc.h"
41#include "clinet.h"
42#include "connectdlg_common.h"
43#include "packhand.h"
44#include "servers.h"
45#include "update_queue.h"
46
47/* client/gui-gtk-3.22 */
48#include "chatline.h"
49#include "connectdlg.h"
50#include "dialogs.h"
51#include "graphics.h"
52#include "gui_main.h"
53#include "gui_stuff.h"
54#include "mapview.h"
55#include "optiondlg.h"
56#include "plrdlg.h" /* get_flag() */
57#include "repodlgs.h"
58#include "voteinfo_bar.h"
59
60#include "pages.h"
61
62
67
69
72
75
76/* This is the current page. Invalid value at start, to be sure that it won't
77 * be catch throught a switch() statement. */
78static enum client_pages current_page = -1;
79
85
86static struct server_scan_timer_data meta_scan = { NULL, 0 };
87static struct server_scan_timer_data lan_scan = { NULL, 0 };
88
92
94
96
97static void connection_state_reset(void);
98
99/**********************************************************************/
103{
104 if (!is_server_running()) {
106
107 /* Saved settings are sent in client/options.c
108 * resend_desired_settable_options() */
109 }
110}
111
112/**********************************************************************/
116{
117 output_window_append(ftc_client, _("Compiling scenario list."));
119}
120
121/**********************************************************************/
128
129/**********************************************************************/
137
138/**********************************************************************/
141static void open_settings(void)
142{
143 option_dialog_popup(_("Set local options"), client_optset);
144}
145
146/**********************************************************************/
149static void main_callback(GtkWidget *w, gpointer data)
150{
151 enum client_pages page = PAGE_MAIN;
152
153 if (client.conn.used) {
155 }
156 if (page != get_client_page()) {
157 set_client_page(page);
158 }
159}
160
161/**********************************************************************/
165{
166 static PangoLayout *layout;
167 static int width, height;
168 static bool left = FALSE;
170 struct sprite *intro = (struct sprite *)data;
171
172 cairo_set_source_surface(cr, intro->surface, 0, 0);
173 cairo_paint(cr);
174
175 if (!layout) {
176 char msgbuf[128];
177 const char *rev_ver;
178
181 pango_font_description_from_string("Sans Bold 10"));
182
184
185 if (rev_ver == NULL) {
186 /* TRANS: "version 2.6.0, gui-gtk-3.22 client" */
187 fc_snprintf(msgbuf, sizeof(msgbuf), _("%s%s, %s client"),
189 } else {
190 /* TRANS: "version 2.6.0
191 * commit: [modified] <git commit id>
192 * gui-gtk-3.22 client" */
193 fc_snprintf(msgbuf, sizeof(msgbuf), _("%s%s\ncommit: %s\n%s client"),
195 left = TRUE;
196 }
198
200 }
202
203 cairo_set_source_rgb(cr, 0, 0, 0);
204 cairo_move_to(cr, left ? 4 : allocation.width - width - 3,
205 allocation.height - height - 3);
207
208 cairo_set_source_rgb(cr, 1, 1, 1);
209 cairo_move_to(cr, left ? 3 : allocation.width - width - 4,
210 allocation.height - height - 4);
212
213 return TRUE;
214}
215
216/**********************************************************************/
219static void intro_free(GtkWidget *w, gpointer *data)
220{
221 struct sprite *intro = (struct sprite *)data;
222
224}
225
226/**********************************************************************/
230{
231 GtkWidget *widget, *vbox, *frame, *darea, *button, *table;
233 struct sprite *intro_in, *intro;
234 int width, height;
235 int sh;
236 int space_needed;
237
239
240 vbox = gtk_grid_new();
243 widget = vbox;
244
245 frame = gtk_frame_new(NULL);
246 g_object_set(frame, "margin", 18, NULL);
249 gtk_container_add(GTK_CONTAINER(vbox), frame);
250
253 sh = screen_height();
254
255 if (sh <= 0) {
256 /* Assume some minimum height */
257 sh = 600;
258 }
259
260 space_needed = 250;
261#if IS_BETA_VERSION || IS_DEVEL_VERSION
262 /* Alpha or Beta notice takes extra space */
263 space_needed += 50;
264#endif
265
266 if (sh - height < space_needed) {
267 float scale;
268
269 if (sh < (space_needed + 0.2 * height)) {
270 /* Screen is simply too small, use minimum scale */
271 scale = 0.2;
272 } else {
273 scale = (double)(sh - space_needed) / height;
274 }
275 height *= scale;
276 width *= scale;
279 } else {
280 intro = intro_in;
281 }
282 darea = gtk_drawing_area_new();
284 g_signal_connect(darea, "draw",
286 g_signal_connect(widget, "destroy",
288 gtk_container_add(GTK_CONTAINER(frame), darea);
289
290#if IS_BETA_VERSION || IS_DEVEL_VERSION
291 {
292 GtkWidget *label;
293
295 gtk_widget_set_name(label, "beta_label");
299 gtk_container_add(GTK_CONTAINER(vbox), label);
300 }
301#endif /* IS_BETA_VERSION || IS_DEVEL_VERSION */
302
304 g_object_set(table, "margin", 12, NULL);
309
313
314 button = gtk_button_new_with_mnemonic(_("Start _New Game"));
316 gtk_grid_attach(GTK_GRID(table), button, 0, 0, 1, 1);
318 _("Launches local server, and connects to it for a single-player game."));
319 g_signal_connect(button, "clicked",
321
322 button = gtk_button_new_with_mnemonic(_("Start _Scenario Game"));
324 gtk_grid_attach(GTK_GRID(table), button, 0, 1, 1, 1);
326 _("Loads one of the scenarios for a single-player game. "
327 "Tutorial is one of the scenarios."));
328 g_signal_connect(button, "clicked",
330
331 button = gtk_button_new_with_mnemonic(_("_Load Saved Game"));
333 gtk_grid_attach(GTK_GRID(table), button, 0, 2, 1, 1);
335 _("Continues previously saved single-player game."));
336 g_signal_connect(button, "clicked",
338
339 button = gtk_button_new_with_mnemonic(_("C_onnect to Network Game"));
341 gtk_grid_attach(GTK_GRID(table), button, 1, 0, 1, 1);
343 _("Connects to outside server. "
344 "Sometimes you want to launch a separate server even for local games."));
345 g_signal_connect(button, "clicked",
347
348 button = gtk_button_new_with_mnemonic(_("Client Settings"));
350 gtk_grid_attach(GTK_GRID(table), button, 1, 1, 1, 1);
352 _("Adjusting client-side options."));
353 g_signal_connect(button, "clicked", open_settings, NULL);
354
355 button = icon_label_button_new("application-exit", _("E_xit"));
358 gtk_grid_attach(GTK_GRID(table), button, 1, 2, 1, 1);
360 _("Gives you a break from playing freeciv."));
361 g_signal_connect(button, "clicked",
363
364 return widget;
365}
366
367/****************************************************************************
368 GENERIC SAVE DIALOG
369****************************************************************************/
370typedef void (*save_dialog_action_fn_t) (const char *filename);
371typedef struct fileinfo_list * (*save_dialog_files_fn_t) (void);
372
380
387
393
394/**********************************************************************/
398{
400 G_TYPE_STRING, /* SD_COL_PRETTY_NAME */
401 G_TYPE_STRING); /* SD_COL_FULL_PATH */
402}
403
404/**********************************************************************/
408 const struct fileinfo_list *files)
409{
411
415 gtk_list_store_set(store, &iter,
417 SD_COL_FULL_PATH, pfile->fullname,
418 -1);
420}
421
422/**********************************************************************/
425static void save_dialog_update(struct save_dialog *pdialog)
426{
427 struct fileinfo_list *files;
428
429 fc_assert_ret(NULL != pdialog);
430
431 /* Update the store. */
432 files = pdialog->files();
435 files);
437}
438
439/**********************************************************************/
443 gint response, gpointer data)
444{
445 if (response == GTK_RESPONSE_OK) {
449 -1, NULL, NULL, NULL);
450
451 if (NULL != filename) {
452 action(filename);
453 g_free(filename);
454 }
455 }
457}
458
459/**********************************************************************/
483
484/**********************************************************************/
488 gpointer data)
489{
490 struct save_dialog *pdialog = data;
491
492 switch (response) {
493 case SD_RES_BROWSE:
494 save_dialog_file_chooser_popup(_("Select Location to Save"),
496 pdialog->action);
497 break;
498 case SD_RES_DELETE:
499 {
500 GtkTreeSelection *selection;
501 GtkTreeModel *model;
503 const gchar *full_path;
504
505 selection = gtk_tree_view_get_selection(pdialog->tree_view);
506 if (!gtk_tree_selection_get_selected(selection, &model, &iter)) {
507 return;
508 }
509
512 save_dialog_update(pdialog);
513 }
514 return;
515 case SD_RES_SAVE:
516 {
517 const char *text = gtk_entry_get_text(pdialog->entry);
518 gchar *filename = g_filename_from_utf8(text, -1, NULL, NULL, NULL);
519
520 if (NULL == filename) {
521 return;
522 }
523 pdialog->action(filename);
524 g_free(filename);
525 }
526 break;
527 default:
528 break;
529 }
531}
532
533/**********************************************************************/
543
544/**********************************************************************/
551
552/**********************************************************************/
556 gpointer data)
557{
558 struct save_dialog *pdialog = data;
559 GtkTreeModel *model;
561 const gchar *filename;
562
563 if (!gtk_tree_selection_get_selected(selection, &model, &iter)) {
565 return;
566 }
567
569 gtk_tree_model_get(model, &iter, SD_COL_PRETTY_NAME, &filename, -1);
570 gtk_entry_set_text(pdialog->entry, filename);
571}
572
573/**********************************************************************/
576static GtkWidget *save_dialog_new(const char *title, const char *savelabel,
577 const char *savefilelabel,
580{
581 GtkWidget *shell, *sbox, *sw, *label, *view, *entry;
582 GtkContainer *vbox;
583 GtkListStore *store;
585 GtkTreeSelection *selection;
586 struct save_dialog *pdialog;
587
590
591 /* Save dialog structure. */
592 pdialog = fc_malloc(sizeof(*pdialog));
593 pdialog->action = action;
594 pdialog->files = files;
595
596 /* Shell. */
598 _("_Browse..."), SD_RES_BROWSE,
599 _("_Delete"), SD_RES_DELETE,
600 _("_Cancel"), GTK_RESPONSE_CANCEL,
601 _("_Save"), SD_RES_SAVE,
602 NULL);
603 g_object_set_data_full(G_OBJECT(shell), "save_dialog", pdialog,
608 g_signal_connect(shell, "response",
610 pdialog->shell = GTK_DIALOG(shell);
612
613 /* Tree view. */
614 store = save_dialog_store_new();
618 g_object_unref(store);
620 g_signal_connect(view, "row-activated",
622 pdialog->tree_view = GTK_TREE_VIEW(view);
623
624 sbox = gtk_grid_new();
628 gtk_container_add(vbox, sbox);
629
631 "use-underline", TRUE,
632 "mnemonic-widget", view,
633 "label", savelabel,
634 "xalign", 0.0,
635 "yalign", 0.5,
636 NULL);
638
648
651 g_signal_connect(selection, "changed",
653
656 -1, NULL, rend, "text",
658
659 /* Entry. */
662 g_signal_connect(entry, "activate",
664 pdialog->entry = GTK_ENTRY(entry);
665
666 sbox = gtk_grid_new();
667 g_object_set(sbox, "margin", 12, NULL);
671
673 "use-underline", TRUE,
674 "mnemonic-widget", entry,
675 "label", savefilelabel,
676 "xalign", 0.0,
677 "yalign", 0.5,
678 NULL);
680
682 gtk_container_add(vbox, sbox);
683
684 save_dialog_update(pdialog);
687 return shell;
688}
689
690/****************************************************************************
691 NETWORK PAGE
692****************************************************************************/
698
699/**********************************************************************/
703 const struct server_list *list)
704{
707 GtkTreeIter it;
708 GtkListStore *store;
709 const gchar *host, *portstr;
710 int port;
711
712 switch (sstype) {
715 break;
718 break;
719 default:
720 break;
721 }
722
723 if (!sel) {
724 return;
725 }
726
730
731 if (!list) {
732 return;
733 }
734
737 port = atoi(portstr);
738
740 char buf[35];
741
742 if (pserver->humans >= 0) {
743 fc_snprintf(buf, sizeof(buf), "%d", pserver->humans);
744 } else {
745 sz_strlcpy(buf, _("Unknown"));
746 }
747 gtk_list_store_append(store, &it);
748 gtk_list_store_set(store, &it,
749 0, pserver->host,
750 1, pserver->port,
751 2, pserver->version,
752 3, _(pserver->state),
753 4, pserver->nplayers,
754 5, buf,
755 6, pserver->message,
756 -1);
757 if (strcmp(host, pserver->host) == 0 && port == pserver->port) {
759 }
761}
762
763/**********************************************************************/
767{
768 if (meta_scan.scan) {
771 }
772 if (meta_scan.timer != 0) {
774 meta_scan.timer = 0;
775 }
776 if (lan_scan.scan) {
779 }
780 if (lan_scan.timer != 0) {
782 lan_scan.timer = 0;
783 }
784}
785
786/**********************************************************************/
790{
791 struct server_scan_timer_data *scan_data = data;
792 struct server_scan *scan = scan_data->scan;
794
795 if (!scan) {
796 return FALSE;
797 }
798
799 stat = server_scan_poll(scan);
800 if (stat >= SCAN_STATUS_PARTIAL) {
802 struct srv_list *srvrs;
803
805 srvrs = server_scan_get_list(scan);
806 fc_mutex_allocate(&srvrs->mutex);
810 fc_mutex_release(&srvrs->mutex);
811 }
812
814 scan_data->timer = 0;
815 return FALSE;
816 }
817 return TRUE;
818}
819
820/**********************************************************************/
823static void server_scan_error(struct server_scan *scan,
824 const char *message)
825{
827 log_error("%s", message);
828
829 /* Main thread will finalize the scan later (or even concurrently) -
830 * do not do anything here to cause double free or raze condition. */
831}
832
833/**********************************************************************/
846
847/**************************************************************************
848 Network connection state defines.
849**************************************************************************/
856
858
859/**********************************************************************/
863{
865 char *txt;
866
869 free(txt);
870 }
871
872 return TRUE;
873}
874
875/**********************************************************************/
878static void clear_network_statusbar(void)
879{
881 char *txt;
882
884 free(txt);
885 }
887}
888
889/**********************************************************************/
892void append_network_statusbar(const char *text, bool force)
893{
895 if (force) {
898 } else {
900 }
901 }
902}
903
904/**********************************************************************/
924
925/**********************************************************************/
929{
930 switch (state) {
931 case LOGIN_TYPE:
933
936
945 break;
950
959
961 break;
966
975
977 break;
978 case WAITING_TYPE:
980
987 break;
988 }
989
990 connection_status = state;
991}
992
993/**********************************************************************/
1000
1001/**********************************************************************/
1006 const char *message)
1007{
1009
1010 switch (type) {
1011 case AUTH_NEWUSER_FIRST:
1012 case AUTH_NEWUSER_RETRY:
1014 return;
1015 case AUTH_LOGIN_FIRST:
1016 /* if we magically have a password already present in 'fc_password'
1017 * then, use that and skip the password entry dialog */
1018 if (fc_password[0] != '\0') {
1020
1021 sz_strlcpy(reply.password, fc_password);
1023 return;
1024 } else {
1026 }
1027 return;
1028 case AUTH_LOGIN_RETRY:
1030 return;
1031 }
1032
1033 log_error("Unsupported authentication type %d: %s.", type, message);
1034}
1035
1036/**********************************************************************/
1042{
1043 char errbuf [512];
1045
1046 switch (connection_status) {
1047 case LOGIN_TYPE:
1051
1053 errbuf, sizeof(errbuf)) != -1) {
1054 } else {
1056
1058 }
1059 return;
1060 case NEW_PASSWORD_TYPE:
1061 if (w != network_password) {
1064 sz_strlcpy(reply.password,
1066 if (!fc_strncmp(reply.password, fc_password, MAX_LEN_NAME)) {
1067 fc_password[0] = '\0';
1069
1071 } else {
1072 append_network_statusbar(_("Passwords don't match, enter password."),
1073 TRUE);
1074
1076 }
1077 }
1078 return;
1080 sz_strlcpy(reply.password,
1083
1085 return;
1086 case WAITING_TYPE:
1087 return;
1088 }
1089
1090 log_error("Unsupported connection status: %d", connection_status);
1091}
1092
1093/**********************************************************************/
1099 gpointer data)
1100{
1101 connect_callback(NULL, data);
1102}
1103
1104/**********************************************************************/
1108static void update_server_playerlist(const struct server *pserver)
1109{
1110 GtkListStore *store;
1112 int n, i;
1113
1115 fc_assert_ret(store != NULL);
1116
1117 gtk_list_store_clear(store);
1118 if (!pserver || !pserver->players) {
1119 return;
1120 }
1121
1122 n = pserver->nplayers;
1123 for (i = 0; i < n; i++) {
1124 gtk_list_store_append(store, &iter);
1125 gtk_list_store_set(store, &iter,
1126 0, pserver->players[i].name,
1127 1, pserver->players[i].type,
1128 2, pserver->players[i].host,
1129 3, pserver->players[i].nation,
1130 -1);
1131 }
1132}
1133
1134/**********************************************************************/
1138{
1139 GtkTreeModel *model;
1140 GtkTreeIter it;
1141 const char *host;
1142 int port;
1143 char portstr[32];
1144 const struct server *pserver = NULL;
1145
1146 if (!gtk_tree_selection_get_selected(select, &model, &it)) {
1147 return;
1148 }
1149
1150 if (select == meta_selection) {
1151 GtkTreePath *path;
1152 struct srv_list *srvrs;
1153
1155 path = gtk_tree_model_get_path(model, &it);
1157 /* We are not yet inside mutex protected block */
1158 fc_mutex_allocate(&srvrs->mutex);
1159 }
1160 if (srvrs->servers && path) {
1162
1164 }
1166 /* We are not yet inside mutex protected block */
1167 fc_mutex_release(&srvrs->mutex);
1168 }
1169 gtk_tree_path_free(path);
1170 }
1172
1173 gtk_tree_model_get(model, &it, 0, &host, 1, &port, -1);
1174
1176 fc_snprintf(portstr, sizeof(portstr), "%d", port);
1178}
1179
1180/**********************************************************************/
1195
1196/**********************************************************************/
1200{
1201 GtkWidget *box, *sbox, *bbox, *hbox, *notebook;
1202 GtkWidget *button, *label, *view, *sw, *table;
1203 GtkTreeSelection *selection;
1204 GtkListStore *store;
1205
1206 box = gtk_grid_new();
1210
1211 notebook = gtk_notebook_new();
1212 gtk_container_add(GTK_CONTAINER(box), notebook);
1213
1214 /* LAN pane. */
1216 G_TYPE_INT, /* port */
1217 G_TYPE_STRING, /* version */
1218 G_TYPE_STRING, /* state */
1219 G_TYPE_INT, /* nplayers */
1220 G_TYPE_STRING, /* humans */
1221 G_TYPE_STRING); /* message */
1222
1228
1230 lan_selection = selection;
1232 g_signal_connect(view, "focus",
1234 g_signal_connect(view, "row-activated",
1236 g_signal_connect(selection, "changed",
1238
1239 add_treeview_column(view, _("Server Name"), G_TYPE_STRING, 0);
1240 add_treeview_column(view, _("Port"), G_TYPE_INT, 1);
1241 add_treeview_column(view, _("Version"), G_TYPE_STRING, 2);
1242 add_treeview_column(view, _("Status"), G_TYPE_STRING, 3);
1243 add_treeview_column(view, _("Players"), G_TYPE_INT, 4);
1244 add_treeview_column(view, _("Humans"), G_TYPE_STRING, 5);
1245 add_treeview_column(view, _("Comment"), G_TYPE_STRING, 6);
1246
1247 label = gtk_label_new_with_mnemonic(_("Local _Area Network"));
1248
1256 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, label);
1257
1258
1259 /* Metaserver pane. */
1261 G_TYPE_INT, /* port */
1262 G_TYPE_STRING, /* version */
1263 G_TYPE_STRING, /* state */
1264 G_TYPE_INT, /* nplayers */
1265 G_TYPE_STRING, /* humans */
1266 G_TYPE_STRING); /* message */
1267
1273
1275 meta_selection = selection;
1277 g_signal_connect(view, "focus",
1279 g_signal_connect(view, "row-activated",
1281 g_signal_connect(selection, "changed",
1283
1284 add_treeview_column(view, _("Server Name"), G_TYPE_STRING, 0);
1285 add_treeview_column(view, _("Port"), G_TYPE_INT, 1);
1286 add_treeview_column(view, _("Version"), G_TYPE_STRING, 2);
1287 add_treeview_column(view, _("Status"), G_TYPE_STRING, 3);
1288 add_treeview_column(view, _("Players"), G_TYPE_INT, 4);
1289 add_treeview_column(view, _("Humans"), G_TYPE_STRING, 5);
1290 add_treeview_column(view, _("Comment"), G_TYPE_STRING, 6);
1291
1292 label = gtk_label_new_with_mnemonic(_("Internet _Metaserver"));
1293
1302 gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook), sw, label);
1303 } else {
1304 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, label);
1305 }
1306
1307 /* Bottom part of the page, outside the inner notebook. */
1308 sbox = gtk_grid_new();
1312
1313 hbox = gtk_grid_new();
1315 g_object_set(hbox, "margin", 8, NULL);
1317
1318 table = gtk_grid_new();
1322
1324 g_signal_connect(network_host, "activate",
1327
1329 "use-underline", TRUE,
1330 "mnemonic-widget", network_host,
1331 "label", _("_Host:"),
1332 "xalign", 0.0,
1333 "yalign", 0.5,
1334 NULL);
1335 network_host_label = label;
1336 gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
1337
1339 g_signal_connect(network_port, "activate",
1342
1344 "use-underline", TRUE,
1345 "mnemonic-widget", network_port,
1346 "label", _("_Port:"),
1347 "xalign", 0.0,
1348 "yalign", 0.5,
1349 NULL);
1350 network_port_label = label;
1351 gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);
1352
1355 g_signal_connect(network_login, "activate",
1358
1360 "use-underline", TRUE,
1361 "mnemonic-widget", network_login,
1362 "label", _("_Login:"),
1363 "xalign", 0.0,
1364 "yalign", 0.5,
1365 NULL);
1366 gtk_widget_set_margin_top(label, 10);
1367 network_login_label = label;
1368 gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);
1369
1375
1377 "use-underline", TRUE,
1378 "mnemonic-widget", network_password,
1379 "label", _("Pass_word:"),
1380 "xalign", 0.0,
1381 "yalign", 0.5,
1382 NULL);
1383 network_password_label = label;
1384 gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);
1385
1391
1393 "use-underline", TRUE,
1394 "mnemonic-widget", network_confirm_password,
1395 "label", _("Conf_irm Password:"),
1396 "xalign", 0.0,
1397 "yalign", 0.5,
1398 NULL);
1400 gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);
1401
1402 /* Server player list. */
1408
1414 add_treeview_column(view, _("Nation"), G_TYPE_STRING, 3);
1416
1424
1425
1427 g_object_set(bbox, "margin", 2, NULL);
1431
1432 button = gtk_button_new_from_icon_name("view-refresh", GTK_ICON_SIZE_BUTTON);
1435 g_signal_connect(button, "clicked",
1437
1438 button = gtk_button_new_with_mnemonic(_("_Cancel"));
1440 g_signal_connect(button, "clicked",
1442
1443 button = gtk_button_new_with_mnemonic(_("C_onnect"));
1445 g_signal_connect(button, "clicked",
1447
1448 return box;
1449}
1450
1451
1452/****************************************************************************
1453 START PAGE
1454****************************************************************************/
1456
1463
1464
1465/* NB: Must match creation arguments in connection_list_store_new(). */
1482
1483/**********************************************************************/
1487{
1489 G_TYPE_INT, /* CL_COL_PLAYER_NUMBER */
1490 G_TYPE_STRING, /* CL_COL_USER_NAME */
1491 G_TYPE_BOOLEAN, /* CL_COL_READY_STATE */
1492 G_TYPE_STRING, /* CL_COL_PLAYER_NAME */
1493 GDK_TYPE_PIXBUF, /* CL_COL_FLAG */
1494 GDK_TYPE_PIXBUF, /* CL_COL_COLOR */
1495 G_TYPE_STRING, /* CL_COL_NATION */
1496 G_TYPE_STRING, /* CL_COL_TEAM */
1497 G_TYPE_INT, /* CL_COL_CONN_ID */
1498 G_TYPE_INT, /* CL_COL_STYLE */
1499 G_TYPE_INT, /* CL_COL_WEIGHT */
1500 G_TYPE_BOOLEAN); /* CL_COL_COLLAPSED */
1501}
1502
1503/**********************************************************************/
1507static void client_aitoggle_player(void *data)
1508{
1509 struct player *pplayer = player_by_number(FC_PTR_TO_INT(data));
1510
1511 if (NULL != pplayer
1512 && pplayer == client_player()
1513 && !is_human(pplayer)) {
1514 send_chat("/away");
1515 }
1516}
1517
1518/**********************************************************************/
1521static void client_take_player(struct player *pplayer)
1522{
1523 int request_id = send_chat_printf("/take \"%s\"", player_name(pplayer));
1524 void *data = FC_INT_TO_PTR(player_number(pplayer));
1525
1528}
1529
1530/**********************************************************************/
1533static void object_put(GObject *object, struct player *pplayer,
1534 struct connection *pconn)
1535{
1536 /* Note that passing -1 to GINT_TO_POINTER() is buggy with some versions
1537 * of gcc. player_slot_count() is not a valid player number. 0 is not
1538 * a valid connection id (see comment in server/sernet.c:
1539 * makeup_connection_name()). */
1540 g_object_set_data(object, "player_id",
1541 GINT_TO_POINTER(NULL != pplayer
1542 ? player_number(pplayer)
1543 : player_slot_count()));
1544 g_object_set_data(object, "connection_id",
1545 GINT_TO_POINTER(NULL != pconn ? pconn->id : 0));
1546}
1547
1548/**********************************************************************/
1552static bool object_extract(GObject *object, struct player **ppplayer,
1553 struct connection **ppconn)
1554{
1555 bool ret = FALSE;
1556 int id;
1557
1558 if (NULL != ppplayer) {
1559 id = GPOINTER_TO_INT(g_object_get_data(object, "player_id"));
1561 if (NULL != *ppplayer) {
1562 ret = TRUE;
1563 }
1564 }
1565 if (NULL != ppconn) {
1566 id = GPOINTER_TO_INT(g_object_get_data(object, "connection_id"));
1567 *ppconn = conn_by_number(id);
1568 if (NULL != *ppconn) {
1569 ret = TRUE;
1570 }
1571 }
1572
1573 return ret;
1574}
1575
1576/**********************************************************************/
1580{
1581 option_dialog_popup(_("Game Settings"), server_optset);
1582}
1583
1584/**********************************************************************/
1588{
1589 enum ai_level *levels = (enum ai_level *)data;
1590 const char *name;
1591 int i;
1592
1594
1595 if (i != -1) {
1596 enum ai_level level = levels[i];
1597
1598 /* Suppress changes provoked by server rather than local user */
1599 if (server_ai_level() != level) {
1601 send_chat_printf("/%s", name);
1602 }
1603 }
1604}
1605
1606/* HACK: sometimes when creating the ruleset combo the value is set without
1607 * the user's control. In this case we don't want to do a /read. */
1609
1610/**********************************************************************/
1613static void ruleset_selected(const char *name)
1614{
1615 if (name && name[0] != '\0' && !no_ruleset_callback) {
1617 }
1618}
1619
1620/**********************************************************************/
1626{
1627 const char *name = NULL;
1628
1630
1631 if (name != NULL) {
1633 }
1634}
1635
1636/**********************************************************************/
1647
1648/**********************************************************************/
1652{
1653 if (start_aifill_spin) {
1655
1656 /* Suppress callback from this change to avoid a loop. */
1658 /* HACK: this GUI control doesn't have quite the same semantics as the
1659 * server 'aifill' option, in that it claims to represent the minimum
1660 * number of players _including humans_. The GUI control has a minimum
1661 * value of 1, so aifill == 0 will not be represented correctly.
1662 * But there's generally exactly one human player because the control
1663 * only shows up for a locally spawned server, so we more or less
1664 * get away with this. */
1667 }
1668}
1669
1670/**********************************************************************/
1674{
1676}
1677
1678/**********************************************************************/
1681static void conn_menu_team_chosen(GObject *object, gpointer data)
1682{
1683 struct player *pplayer;
1684 struct team_slot *tslot = data;
1685
1686 if (object_extract(object, &pplayer, NULL)
1687 && NULL != tslot
1688 && team_slot_index(tslot) != team_number(pplayer->team)) {
1689 send_chat_printf("/team \"%s\" \"%s\"",
1690 player_name(pplayer),
1692 }
1693}
1694
1695/**********************************************************************/
1698static void conn_menu_ready_chosen(GObject *object, gpointer data)
1699{
1700 struct player *pplayer;
1701
1702 if (object_extract(object, &pplayer, NULL)) {
1704 player_number(pplayer), !pplayer->is_ready);
1705 }
1706}
1707
1708/**********************************************************************/
1711static void conn_menu_nation_chosen(GObject *object, gpointer data)
1712{
1713 struct player *pplayer;
1714
1715 if (object_extract(object, &pplayer, NULL)) {
1716 popup_races_dialog(pplayer);
1717 }
1718}
1719
1720/**********************************************************************/
1725{
1726 struct player *pplayer;
1727
1728 if (object_extract(object, &pplayer, NULL)) {
1729 send_chat_printf("/%s \"%s\"",
1730 (char *) g_object_get_data(G_OBJECT(data), "command"),
1731 player_name(pplayer));
1732 }
1733}
1734
1735/**********************************************************************/
1738static void conn_menu_player_take(GObject *object, gpointer data)
1739{
1740 struct player *pplayer;
1741
1742 if (object_extract(object, &pplayer, NULL)) {
1743 client_take_player(pplayer);
1744 }
1745}
1746
1747/**********************************************************************/
1752{
1753 struct connection *pconn;
1754
1755 if (object_extract(object, NULL, &pconn)) {
1756 send_chat_printf("/%s \"%s\"",
1757 (char *) g_object_get_data(G_OBJECT(data), "command"),
1758 pconn->username);
1759 }
1760}
1761
1762/**********************************************************************/
1765static void show_conn_popup(struct player *pplayer, struct connection *pconn)
1766{
1768 char buf[4096] = "";
1769
1770 if (pconn) {
1771 cat_snprintf(buf, sizeof(buf), _("Connection name: %s"),
1772 pconn->username);
1773 } else {
1774 cat_snprintf(buf, sizeof(buf), _("Player name: %s"),
1775 player_name(pplayer));
1776 }
1777 cat_snprintf(buf, sizeof(buf), "\n");
1778 if (pconn) {
1779 cat_snprintf(buf, sizeof(buf), _("Host: %s"), pconn->addr);
1780 }
1781 cat_snprintf(buf, sizeof(buf), "\n");
1782
1783 /* Show popup. */
1786 "%s", buf);
1787 gtk_window_set_title(GTK_WINDOW(popup), _("Player/conn info"));
1791}
1792
1793/**********************************************************************/
1796static void conn_menu_info_chosen(GObject *object, gpointer data)
1797{
1798 struct player *pplayer;
1799 struct connection *pconn;
1800
1801 if (object_extract(object, &pplayer, &pconn)) {
1802 show_conn_popup(pplayer, pconn);
1803 }
1804}
1805
1806/**********************************************************************/
1810static GtkWidget *create_conn_menu(struct player *pplayer,
1811 struct connection *pconn)
1812{
1813 GtkWidget *menu;
1814 GtkWidget *item;
1815 gchar *buf;
1816
1817 menu = gtk_menu_new();
1818 object_put(G_OBJECT(menu), pplayer, pconn);
1819
1820 buf = g_strdup_printf(_("%s info"),
1821 pconn ? pconn->username : player_name(pplayer));
1823 g_free(buf);
1825 g_signal_connect_swapped(item, "activate",
1827
1828 if (NULL != pplayer) {
1829 item = gtk_menu_item_new_with_label(_("Toggle player ready"));
1832 g_signal_connect_swapped(item, "activate",
1834
1835 item = gtk_menu_item_new_with_label(_("Pick nation"));
1838 pplayer));
1840 g_signal_connect_swapped(item, "activate",
1842
1843 item = gtk_menu_item_new_with_label(_("Observe this player"));
1845 g_object_set_data_full(G_OBJECT(item), "command", g_strdup("observe"),
1847 g_signal_connect_swapped(item, "activate",
1849
1850 item = gtk_menu_item_new_with_label(_("Take this player"));
1852 g_signal_connect_swapped(item, "activate",
1854 }
1855
1857 && (pconn->id != client.conn.id || NULL != pplayer)) {
1860
1861 if (pconn->id != client.conn.id) {
1862 item = gtk_menu_item_new_with_label(_("Cut connection"));
1864 g_object_set_data_full(G_OBJECT(item), "command", g_strdup("cut"),
1866 g_signal_connect_swapped(item, "activate",
1868 menu);
1869 }
1870 }
1871
1872 if (ALLOW_CTRL <= client.conn.access_level && NULL != pplayer) {
1873 item = gtk_menu_item_new_with_label(_("Aitoggle player"));
1875 g_object_set_data_full(G_OBJECT(item), "command", g_strdup("aitoggle"),
1877 g_signal_connect_swapped(item, "activate",
1879
1880 if (pplayer != client.conn.playing && game.info.is_new_game) {
1881 item = gtk_menu_item_new_with_label(_("Remove player"));
1883 g_object_set_data_full(G_OBJECT(item), "command", g_strdup("remove"),
1885 g_signal_connect_swapped(item, "activate",
1887 }
1888 }
1889
1891 && pconn->id != client.conn.id) {
1892 enum cmdlevel level;
1893
1894 /* No item for hack access; that would be a serious security hole. */
1896 /* TRANS: Give access level to a connection. */
1897 buf = g_strdup_printf(_("Give %s access"),
1900 g_free(buf);
1903 g_strdup_printf("cmdlevel %s",
1906 g_signal_connect_swapped(item, "activate",
1908 menu);
1909 }
1910 }
1911
1913 && NULL != pplayer && is_ai(pplayer)) {
1914 enum ai_level level;
1915
1918
1919 for (level = 0; level < AI_LEVEL_COUNT; level++) {
1922 const char *level_cmd = ai_level_cmd(level);
1923
1928 g_signal_connect_swapped(item, "activate",
1930 }
1931 }
1932 }
1933
1934 if (pplayer && game.info.is_new_game) {
1935 const int count = pplayer->team
1936 ? player_list_size(team_members(pplayer->team)) : 0;
1937 bool need_empty_team = (count != 1);
1938
1941
1942 /* Can't use team_iterate here since it skips empty teams. */
1944 if (!team_slot_is_used(tslot)) {
1945 if (!need_empty_team) {
1946 continue;
1947 }
1949 }
1950
1951 /* TRANS: e.g., "Put on Team 5" */
1952 buf = g_strdup_printf(_("Put on %s"),
1955 g_free(buf);
1957 object_put(G_OBJECT(item), pplayer, NULL);
1959 tslot);
1961 }
1962
1963 gtk_widget_show_all(menu);
1964
1965 return menu;
1966}
1967
1968/**********************************************************************/
1972{
1973 if (NULL != connection_list_view) {
1974 GtkTreeSelection *selection =
1976 GtkTreePath *path = data;
1977
1978 gtk_tree_selection_unselect_path(selection, path);
1979 gtk_tree_path_free(path);
1980 }
1981 return FALSE;
1982}
1983
1984/**********************************************************************/
1989 gpointer data)
1990{
1992 GtkTreePath *path = NULL;
1994 gboolean ret = FALSE;
1995
1996 if ((1 != event->button && 3 != event->button)
1997 || GDK_BUTTON_PRESS != event->type
1999 event->x, event->y,
2000 &path, NULL, NULL, NULL)) {
2001 return FALSE;
2002 }
2003
2004 if (1 == event->button) {
2005 if (gtk_tree_selection_path_is_selected(selection, path)) {
2006 /* Need to delay to avoid problem with the expander. */
2008 return FALSE; /* Return now, don't free the path. */
2009 }
2010 } else if (3 == event->button) {
2013 GtkWidget *menu;
2014 int player_no, conn_id;
2015 struct player *pplayer;
2016 struct connection *pconn;
2017
2018 if (!gtk_tree_selection_path_is_selected(selection, path)) {
2019 gtk_tree_selection_select_path(selection, path);
2020 }
2021 gtk_tree_model_get_iter(model, &iter, path);
2022
2023 gtk_tree_model_get(model, &iter, CL_COL_PLAYER_NUMBER, &player_no, -1);
2024 pplayer = player_by_number(player_no);
2025
2026 gtk_tree_model_get(model, &iter, CL_COL_CONN_ID, &conn_id, -1);
2027 pconn = conn_by_number(conn_id);
2028
2029 menu = create_conn_menu(pplayer, pconn);
2031 ret = TRUE;
2032 }
2033
2034 gtk_tree_path_free(path);
2035 return ret;
2036}
2037
2038/**********************************************************************/
2043 GtkTreePath *path,
2044 gpointer data)
2045{
2047
2048 gtk_tree_store_set(store, iter,
2050}
2051
2052/**********************************************************************/
2057 struct connection **ppconn)
2058{
2059 if (NULL != connection_list_view) {
2061 GtkTreeModel *model;
2062 GtkTreeSelection *selection =
2064
2065 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
2066 int id;
2067
2068 if (NULL != ppplayer) {
2069 gtk_tree_model_get(model, &iter, CL_COL_PLAYER_NUMBER, &id, -1);
2071 }
2072 if (NULL != ppconn) {
2073 gtk_tree_model_get(model, &iter, CL_COL_CONN_ID, &id, -1);
2074 *ppconn = conn_by_number(id);
2075 }
2076 return TRUE;
2077 }
2078 }
2079
2080 if (NULL != ppplayer) {
2081 *ppplayer = NULL;
2082 }
2083 if (NULL != ppconn) {
2084 *ppconn = NULL;
2085 }
2086 return FALSE;
2087}
2088
2089/**********************************************************************/
2093{
2094 GtkTreeModel *model;
2095 GtkTreeIter parent, child, *iter = NULL;
2096 GtkTreeSelection *selection;
2097 gboolean valid;
2098 const int search_id = pconn->id;
2099 int id;
2100
2101 if (NULL == connection_list_view) {
2102 return;
2103 }
2104
2107
2108 /* Main iteration. */
2109 valid = gtk_tree_model_get_iter_first(model, &parent);
2110 while (valid && NULL == iter) {
2111 gtk_tree_model_get(model, &parent, CL_COL_CONN_ID, &id, -1);
2112 if (search_id == id) {
2113 iter = &parent;
2114 break;
2115 }
2116
2117 /* Node children iteration. */
2118 valid = gtk_tree_model_iter_children(model, &child, &parent);
2119 while (valid && NULL == iter) {
2120 gtk_tree_model_get(model, &child, CL_COL_CONN_ID, &id, -1);
2121 if (search_id == id) {
2122 iter = &child;
2123 break;
2124 }
2125 valid = gtk_tree_model_iter_next(model, &child);
2126 }
2127
2128 valid = gtk_tree_model_iter_next(model, &parent);
2129 }
2130
2131 /* Select iterator. */
2132 if (NULL != iter) {
2134 } else {
2135 log_error("%s(): connection %s not found.",
2137 }
2138}
2139
2140/**********************************************************************/
2144{
2145 if (can_client_control()) {
2148 !client_player()->is_ready);
2149 } else {
2151 }
2152}
2153
2154/**********************************************************************/
2158{
2159 struct player *selected_plr;
2160 bool row_selected = conn_list_selection(&selected_plr, NULL);
2161
2162 if (row_selected && NULL != selected_plr) {
2163 /* "Take <player_name>" */
2165 } else if (can_client_control()) {
2166 /* "Pick Nation" */
2168 } else {
2169 /* "Take a Player" */
2170 send_chat("/take -");
2171 }
2172}
2173
2174/**********************************************************************/
2178{
2179 struct player *selected_plr;
2180 bool row_selected = conn_list_selection(&selected_plr, NULL);
2181
2182 if (row_selected && NULL != selected_plr) {
2183 /* "Observe <player_name>" */
2184 send_chat_printf("/observe \"%s\"", player_name(selected_plr));
2185 } else if (!client_is_global_observer()) {
2186 /* "Observe" */
2187 send_chat("/observe");
2188 } else {
2189 /* "Do not observe" */
2190 send_chat("/detach");
2191 }
2192}
2193
2194/**********************************************************************/
2198{
2199 char buf[2 * MAX_LEN_NAME];
2200 const char *text;
2201 struct player *selected_plr;
2202 bool row_selected = conn_list_selection(&selected_plr, NULL);
2203 bool sensitive;
2204
2205 /*** Ready button. ***/
2206 if (can_client_control()) {
2207 sensitive = client_player()->is_alive;
2208 if (client_player()->is_ready) {
2209 text = _("Not _ready");
2210 } else {
2211 int num_unready = 0;
2212
2213 players_iterate_alive(pplayer) {
2214 if (is_human(pplayer) && !pplayer->is_ready) {
2215 num_unready++;
2216 }
2218
2219 if (num_unready > 1) {
2220 text = _("_Ready");
2221 } else {
2222 /* We are the last unready player so clicking here will
2223 * immediately start the game. */
2224 text = _("_Start");
2225 }
2226 }
2227 } else {
2228 text = _("_Start");
2229 if (can_client_access_hack()) {
2230 sensitive = TRUE;
2232 if (is_human(plr)) {
2233 /* There's human controlled player(s) in game, so it's their
2234 * job to start the game. */
2235 sensitive = FALSE;
2236 break;
2237 }
2239 } else {
2240 sensitive = FALSE;
2241 }
2242 }
2245
2246 /*** Nation button. ***/
2247 if (row_selected && NULL != selected_plr) {
2248 fc_snprintf(buf, sizeof(buf), _("_Take %s"), player_name(selected_plr));
2249 text = buf;
2251 } else if (can_client_control()) {
2252 text = _("Pick _Nation");
2254 } else {
2255 text = _("_Take a Player");
2257 }
2260
2261 /*** Observe button. ***/
2262 if (row_selected && NULL != selected_plr) {
2263 fc_snprintf(buf, sizeof(buf), _("_Observe %s"),
2265 text = buf;
2267 } else if (!client_is_global_observer()) {
2268 text = _("_Observe");
2269 sensitive = TRUE;
2270 } else {
2271 text = _("Do not _observe");
2272 sensitive = TRUE;
2273 }
2276}
2277
2278/**********************************************************************/
2284 GtkTreeIter *start,
2285 const struct player *pplayer)
2286{
2287 const int search_id = player_number(pplayer);
2288 int id;
2289
2290 if (NULL != start) {
2291 *iter = *start;
2292 if (!gtk_tree_model_iter_next(model, iter)) {
2293 return FALSE;
2294 }
2295 } else if (!gtk_tree_model_get_iter_first(model, iter)) {
2296 return FALSE;
2297 }
2298
2299 do {
2301 if (id == search_id) {
2302 return TRUE;
2303 }
2304 } while (gtk_tree_model_iter_next(model, iter));
2305
2306 return FALSE;
2307}
2308
2309/**********************************************************************/
2315 const struct connection *pconn)
2316{
2317 const int search_id = pconn->id;
2318 int id;
2319
2320 if (NULL != start) {
2321 *iter = *start;
2322 if (!gtk_tree_model_iter_next(model, iter)) {
2323 return FALSE;
2324 }
2325 } else if (!gtk_tree_model_iter_children(model, iter, parent)) {
2326 return FALSE;
2327 }
2328
2329 do {
2330 gtk_tree_model_get(model, iter, CL_COL_CONN_ID, &id, -1);
2331 if (id == search_id) {
2332 return TRUE;
2333 }
2334 } while (gtk_tree_model_iter_next(model, iter));
2335
2336 return FALSE;
2337}
2338
2339/**********************************************************************/
2343{
2348 GtkTreeModel *model = GTK_TREE_MODEL(store);
2349 GtkTreePath *path;
2352 GdkPixbuf *flag, *color;
2354 struct player *pselected_player;
2355 struct connection *pselected_conn;
2356 bool is_ready;
2357 const char *nation, *plr_name, *team;
2358 char name[MAX_LEN_NAME + 8];
2360 int conn_id;
2361
2362 /* Refresh the AI skill level control */
2363 if (ai_lvl_combobox) {
2364 enum ai_level new_level = server_ai_level(), level;
2365 int i = 0;
2366
2367 for (level = 0; level < AI_LEVEL_COUNT; level++) {
2369 if (level == new_level) {
2371 break;
2372 }
2373 i++;
2374 }
2375 }
2376 if (level == AI_LEVEL_COUNT) {
2377 /* Probably ai_level_invalid() */
2379 }
2380 }
2381
2382 /* Save the selected connection. */
2384
2385 /* Insert players into the connection list. */
2386 players_iterate(pplayer) {
2387 if (!player_has_flag(pplayer, PLRF_SCENARIO_RESERVED)) {
2388 conn_id = -1;
2390 flag = pplayer->nation ? get_flag(pplayer->nation) : NULL;
2391 color = create_player_icon(pplayer);
2392
2393 conn_list_iterate(pplayer->connections, pconn) {
2394 if (pconn->playing == pplayer && !pconn->observer) {
2395 conn_id = pconn->id;
2396 access_level = pconn->access_level;
2397 break;
2398 }
2400
2401 if (is_ai(pplayer) && !pplayer->was_created
2402 && !pplayer->is_connected) {
2403 /* TRANS: "<Novice AI>" */
2404 fc_snprintf(name, sizeof(name), _("<%s AI>"),
2405 ai_level_translated_name(pplayer->ai_common.skill_level));
2406 } else {
2407 sz_strlcpy(name, pplayer->username);
2408 if (access_level > ALLOW_BASIC) {
2409 sz_strlcat(name, "*");
2410 }
2411 }
2412
2413 is_ready = !is_human(pplayer) ? TRUE : pplayer->is_ready;
2414
2415 if (pplayer->nation == NO_NATION_SELECTED) {
2416 nation = _("Random");
2417 if (pplayer->was_created) {
2418 plr_name = player_name(pplayer);
2419 } else {
2420 plr_name = "";
2421 }
2422 } else {
2423 nation = nation_adjective_for_player(pplayer);
2424 plr_name = player_name(pplayer);
2425 }
2426
2427 team = pplayer->team ? team_name_translation(pplayer->team) : "";
2428
2429 if (model_get_player_iter(model, &parent, pprev_parent, pplayer)) {
2431 } else {
2433 }
2434
2435 gtk_tree_store_set(store, &parent,
2438 CL_COL_READY_STATE, is_ready,
2440 CL_COL_FLAG, flag,
2442 CL_COL_NATION, nation,
2444 CL_COL_CONN_ID, conn_id,
2447 -1);
2448
2449 /* Insert observers of this player as child nodes. */
2450 pprev_child = NULL;
2451 conn_list_iterate(pplayer->connections, pconn) {
2452 if (pconn->id == conn_id) {
2453 continue;
2454 }
2455 if (model_get_conn_iter(model, &child, &parent,
2456 pprev_child, pconn)) {
2457 gtk_tree_store_move_after(store, &child, pprev_child);
2458 } else {
2460 }
2461
2462 gtk_tree_store_set(store, &child,
2464 CL_COL_USER_NAME, pconn->username,
2465 CL_COL_TEAM, _("Observer"),
2466 CL_COL_CONN_ID, pconn->id,
2469 -1);
2470
2471 prev_child = child;
2474
2475 /* Expand node? */
2476 if (NULL != pprev_child) {
2478 if (!collapsed) {
2479 path = gtk_tree_model_get_path(model, &parent);
2481 path, FALSE);
2482 gtk_tree_path_free(path);
2483 }
2484 }
2485
2486 /* Remove trailing rows. */
2487 if (NULL != pprev_child) {
2488 child = prev_child;
2489 if (gtk_tree_model_iter_next(model, &child)) {
2490 while (gtk_tree_store_remove(store, &child)) {
2491 /* Do nothing more. */
2492 }
2493 }
2494 } else if (gtk_tree_model_iter_children(model, &child, &parent)) {
2495 while (gtk_tree_store_remove(store, &child)) {
2496 /* Do nothing more. */
2497 }
2498 }
2499
2502 if (flag) {
2503 g_object_unref(flag);
2504 }
2505 if (color) {
2507 }
2508 }
2510
2511 /* Finally, insert global observers... */
2513 if (NULL != pconn->playing || !pconn->observer) {
2514 continue;
2515 }
2516
2519 } else {
2521 }
2522
2523 gtk_tree_store_set(store, &parent,
2525 CL_COL_USER_NAME, pconn->username,
2526 CL_COL_TEAM, _("Observer"),
2527 CL_COL_CONN_ID, pconn->id,
2530 -1);
2531
2535
2536 /* ...and detached connections. */
2538 if (NULL != pconn->playing || pconn->observer) {
2539 continue;
2540 }
2541
2544 } else {
2546 }
2547
2548 gtk_tree_store_set(store, &parent,
2550 CL_COL_USER_NAME, pconn->username,
2551 CL_COL_TEAM, _("Detached"),
2552 CL_COL_CONN_ID, pconn->id,
2555 -1);
2556
2560
2561 /* Remove trailing rows. */
2562 if (NULL != pprev_parent) {
2564 if (gtk_tree_model_iter_next(model, &parent)) {
2565 while (gtk_tree_store_remove(store, &parent)) {
2566 /* Do nothing more. */
2567 }
2568 }
2569 } else {
2570 gtk_tree_store_clear(store);
2571 }
2572
2573 /* If we were selecting a single connection, let's try to reselect it. */
2576 }
2577 }
2578
2580}
2581
2582/**********************************************************************/
2588 const char *title, int colnum, const char *key)
2589{
2592
2593 if (gtype == G_TYPE_BOOLEAN) {
2596 "active", colnum, NULL);
2597 } else if (gtype == GDK_TYPE_PIXBUF) {
2600 "pixbuf", colnum, NULL);
2601 } else {
2604 "text", colnum,
2605 "style", CL_COL_STYLE,
2606 "weight", CL_COL_WEIGHT,
2607 NULL);
2608 }
2609
2612
2613 if (key != NULL) {
2615 }
2616}
2617
2618/**********************************************************************/
2622{
2623 GtkWidget *box, *sbox, *table, *vbox;
2624 GtkWidget *view, *sw, *text, *toolkit_view, *button, *spin;
2625 GtkWidget *label;
2626 GtkTreeSelection *selection;
2627 enum ai_level level;
2628 /* There's less than AI_LEVEL_COUNT entries as not all levels have
2629 entries (that's the whole point of this array: index != value),
2630 but this is set safely to the max */
2631 static enum ai_level levels[AI_LEVEL_COUNT];
2632 int i = 0;
2633
2634 box = gtk_grid_new();
2639
2640 sbox = gtk_grid_new();
2643
2644 vbox = gtk_grid_new();
2645 g_object_set(vbox, "margin", 12, NULL);
2652
2653 table = gtk_grid_new();
2658
2664 if (server_optset != NULL) {
2666 if (paifill) {
2669 } /* else it'll be updated later */
2670 }
2671 g_signal_connect_after(spin, "value_changed",
2673
2674 gtk_grid_attach(GTK_GRID(table), spin, 1, 0, 1, 1);
2675
2677 "use-underline", TRUE,
2678 "mnemonic-widget", spin,
2679 /* TRANS: Keep individual lines short */
2680 "label", _("Number of _Players\n(including AI):"),
2681 "xalign", 0.0,
2682 "yalign", 0.5,
2683 NULL);
2684 gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
2685
2687
2688 for (level = 0; level < AI_LEVEL_COUNT; level++) {
2691
2693 levels[i] = level;
2694 i++;
2695 }
2696 }
2699 G_CALLBACK(ai_skill_callback), levels);
2700
2702
2704 "use-underline", TRUE,
2705 "mnemonic-widget", ai_lvl_combobox,
2706 "label", _("AI Skill _Level:"),
2707 "xalign", 0.0,
2708 "yalign", 0.5,
2709 NULL);
2710 gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);
2711
2715
2717
2719 "use-underline", TRUE,
2720 "mnemonic-widget", GTK_COMBO_BOX_TEXT(ruleset_combo),
2721 "label", _("Ruleset:"),
2722 "xalign", 0.0,
2723 "yalign", 0.5,
2724 NULL);
2725 gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);
2726
2727 button = icon_label_button_new("preferences-system",
2728 _("_More Game Options..."));
2729 g_object_set(button, "margin", 8, NULL);
2732 g_signal_connect(button, "clicked",
2734 gtk_container_add(GTK_CONTAINER(vbox), button);
2735
2742
2745 g_signal_connect(selection, "changed",
2747
2748 add_tree_col(view, G_TYPE_STRING, _("Name"),
2750 add_tree_col(view, G_TYPE_BOOLEAN, _("Ready"),
2752 add_tree_col(view, G_TYPE_STRING, Q_("?player:Leader"),
2755 CL_COL_FLAG, NULL);
2756 add_tree_col(view, GDK_TYPE_PIXBUF, _("Border"),
2758 add_tree_col(view, G_TYPE_STRING, _("Nation"),
2760 add_tree_col(view, G_TYPE_STRING, _("Team"),
2761 CL_COL_TEAM, NULL);
2762
2763 g_signal_connect(view, "button-press-event",
2765 g_signal_connect(view, "row-collapsed",
2768 g_signal_connect(view, "row-expanded",
2771
2781
2782
2790
2794 start_message_area = text;
2795 gtk_widget_set_name(text, "chatline");
2800
2801
2802 /* Vote widgets. */
2803 if (pregame_votebar == NULL) {
2805 }
2807
2808
2811
2812 button = gtk_button_new_with_mnemonic(_("_Cancel"));
2814 g_signal_connect(button, "clicked", G_CALLBACK(main_callback), NULL);
2815
2816 nation_button = icon_label_button_new("document-properties",
2817 _("Pick _Nation"));
2821
2822 observe_button = icon_label_button_new("zoom-in", _("_Observe"));
2826
2827 ready_button = icon_label_button_new("system-run", _("_Ready"));
2829 g_signal_connect(ready_button, "clicked",
2831
2832 return box;
2833}
2834
2835
2836/**********************************************************************/
2839void handle_game_load(bool load_successful, const char *filename)
2840{
2841 if (load_successful) {
2843
2844 if (game.info.is_new_game) {
2845 /* It's pregame. Create a player and connect to it */
2846 send_chat("/take -");
2847 }
2848 }
2849}
2850
2851/**********************************************************************/
2854static void load_filename(const char *filename)
2855{
2856 send_chat_printf("/load %s", filename);
2857}
2858
2859/**********************************************************************/
2862static void load_callback(void)
2863{
2864 GtkTreeIter it;
2865 const gchar *filename;
2866
2868 return;
2869 }
2870
2872 SD_COL_FULL_PATH, &filename, -1);
2873 load_filename(filename);
2874}
2875
2876/**********************************************************************/
2880{
2881 save_dialog_file_chooser_popup(_("Choose Saved Game to Load"),
2884}
2885
2886/**********************************************************************/
2889static void update_load_page(void)
2890{
2891 /* Search for user saved games. */
2893 ".sav", FALSE);
2894
2896 fileinfo_list_destroy(files);
2897}
2898
2899/**********************************************************************/
2903{
2904 GtkWidget *box, *sbox, *bbox;
2905
2906 GtkWidget *button, *label, *view, *sw;
2908
2909 box = gtk_grid_new();
2914
2919
2922 -1, NULL, rend, "text", 0, NULL);
2923
2926
2928
2929 g_signal_connect(view, "row-activated",
2931
2932 sbox = gtk_grid_new();
2938
2940 "use-underline", TRUE,
2941 "mnemonic-widget", view,
2942 "label", _("Choose Saved Game to _Load:"),
2943 "xalign", 0.0,
2944 "yalign", 0.5,
2945 NULL);
2947
2956
2962
2963 button = gtk_button_new_with_mnemonic(_("_Browse..."));
2966 g_signal_connect(button, "clicked",
2968
2969 button = gtk_button_new_with_mnemonic(_("_Cancel"));
2971 g_signal_connect(button, "clicked",
2973
2974 button = gtk_button_new_with_mnemonic(_("_OK"));
2976 g_signal_connect(button, "clicked",
2978
2979 return box;
2980}
2981
2982/**********************************************************************/
2985static void scenario_list_callback(void)
2986{
2987 GtkTreeIter it;
2988 GtkTextBuffer *buffer;
2989 char *description;
2990 char *authors;
2991 char *filename;
2992 int ver;
2993 char vername[50];
2994
2997 2, &description, -1);
2999 3, &authors, -1);
3001 1, &filename, -1);
3003 4, &ver, -1);
3004 filename = skip_to_basename(filename);
3005 if (ver > 0) {
3006 int maj;
3007 int min;
3008
3009 maj = ver / 1000000;
3010 ver %= 1000000;
3011 min = ver / 10000;
3012 ver %= 10000;
3013 if (ver >= 9000) {
3014 /* Development version, have '+' */
3015 fc_snprintf(vername, sizeof(vername), "%d.%d+", maj, min);
3016 } else {
3017 fc_snprintf(vername, sizeof(vername), "%d.%d", maj, min);
3018 }
3019 } else {
3020 /* TRANS: Old scenario format version */
3021 fc_snprintf(vername, sizeof(vername), _("pre-2.6"));
3022 }
3023 } else {
3024 description = "";
3025 authors = "";
3026 filename = "";
3027 vername[0] = '\0';
3028 }
3029
3031 gtk_text_buffer_set_text(buffer, description, -1);
3033 gtk_text_buffer_set_text(buffer, authors, -1);
3036}
3037
3038/**********************************************************************/
3041static void scenario_callback(void)
3042{
3043 GtkTreeIter it;
3044 char *filename;
3045
3047 return;
3048 }
3049
3050 gtk_tree_model_get(GTK_TREE_MODEL(scenario_store), &it, 1, &filename, -1);
3051 load_filename(filename);
3052}
3053
3054/**********************************************************************/
3058{
3059 save_dialog_file_chooser_popup(_("Choose a Scenario"),
3062}
3063
3064/**********************************************************************/
3067static void update_scenario_page(void)
3068{
3069 struct fileinfo_list *files;
3070
3072
3073 /* search for scenario files. */
3074 files = fileinfolist_infix(get_scenario_dirs(), ".sav", TRUE);
3076 struct section_file *sf;
3077
3078 if ((sf = secfile_load_section(pfile->fullname, "scenario", TRUE))
3079 && secfile_lookup_bool_default(sf, TRUE, "scenario.is_scenario")) {
3080 const char *sname, *sdescription, *sauthors;
3081 int fcver;
3082 int fcdev;
3083 int current_ver = MAJOR_VERSION * 1000000 + MINOR_VERSION * 10000;
3084 int current_dev;
3085
3087 if (PATCH_VERSION >= 90) {
3088 /* Patch level matters on development versions */
3089 current_dev += PATCH_VERSION * 100;
3090 }
3091
3092 fcver = secfile_lookup_int_default(sf, 0, "scenario.game_version");
3093 if (fcver < 30000) {
3094 /* Pre-3.0 versions stored version number without emergency version
3095 * part in the end. To get comparable version number stored,
3096 * multiply by 100. */
3097 fcver *= 100;
3098 }
3099 if (fcver % 10000 >= 9000) {
3100 fcdev = fcver - (fcver % 100); /* Emergency version does not count. */
3101 } else {
3102 fcdev = fcver - (fcver % 10000); /* Patch version does not count. */
3103 }
3104 sname = secfile_lookup_str_default(sf, NULL, "scenario.name");
3106 "scenario.description");
3107 sauthors = secfile_lookup_str_default(sf, NULL, "scenario.authors");
3108 log_debug("scenario file: %s from %s", sname, pfile->fullname);
3109
3110 /* Ignore scenarios for newer freeciv versions than we are. */
3111 if (fcdev <= current_dev) {
3112 bool add_new = TRUE;
3113
3114 if (sname != NULL) {
3115 GtkTreeIter it;
3116 bool valid;
3117
3119 while (valid) {
3120 char *oname;
3121
3123 0, &oname, -1);
3124
3125 if (!strcmp(sname, oname)) {
3126 /* Already listed scenario has the same name as the one we just found */
3127 int existing;
3128
3130 4, &existing, -1);
3131 log_debug("Duplicate %s (%d vs %d)", sname, existing, fcver);
3132
3133 if (existing > fcver) {
3134 /* Already listed one has higher version number */
3135 add_new = FALSE;
3136 } else if (existing < fcver) {
3137 /* New one has higher version number */
3138 add_new = FALSE;
3139
3141 0, sname && strlen(sname) ? Q_(sname) : pfile->name,
3142 1, pfile->fullname,
3143 2, (NULL != sdescription && '\0' != sdescription[0]
3144 ? Q_(sdescription) : ""),
3145 3, (NULL != sauthors && sauthors[0] != '\0'
3146 ? Q_(sauthors) : ""),
3147 4, fcver,
3148 -1);
3149 } else {
3150 /* Same version number -> list both */
3151 }
3152 }
3154 }
3155 }
3156
3157 if (add_new) {
3158 GtkTreeIter it;
3159
3162 0, sname && strlen(sname) ? Q_(sname) : pfile->name,
3163 1, pfile->fullname,
3164 2, (NULL != sdescription && '\0' != sdescription[0]
3165 ? Q_(sdescription) : ""),
3166 3, (NULL != sauthors && sauthors[0] != '\0'
3167 ? Q_(sauthors) : ""),
3168 4, fcver,
3169 -1);
3170 }
3171 }
3172
3173 secfile_destroy(sf);
3174 }
3176
3177 fileinfo_list_destroy(files);
3178}
3179
3180/**********************************************************************/
3184{
3185 GtkWidget *vbox, *hbox, *sbox, *bbox, *filenamebox, *descbox;
3187 GtkWidget *button, *label, *view, *sw, *swa, *text;
3189
3190 vbox = gtk_grid_new();
3195
3200 G_TYPE_INT);
3205
3208 -1, NULL, rend, "text", 0, NULL);
3209
3214
3216
3217 g_signal_connect(view, "row-activated",
3219
3221 "use-underline", TRUE,
3222 "mnemonic-widget", view,
3223 "label", _("Choose a _Scenario:"),
3224 "xalign", 0.0,
3225 "yalign", 0.5,
3226 NULL);
3227 gtk_container_add(GTK_CONTAINER(vbox), label);
3228
3229 sbox = gtk_grid_new();
3236
3237 hbox = gtk_grid_new();
3240
3247 gtk_grid_attach(GTK_GRID(sbox), sw, 0, 0, 1, 2);
3248
3249 text = gtk_text_view_new();
3255 scenario_description = text;
3256
3263
3264 text = gtk_text_view_new();
3270 scenario_authors = text;
3271
3278
3279 text = gtk_label_new(_("Filename:"));
3284
3287 g_object_set(filenamebox, "margin", 5, NULL);
3288
3291
3292 /* TRANS: Scenario format version */
3293 vertext = gtk_label_new(_("Format:"));
3298
3301 g_object_set(versionbox, "margin", 5, NULL);
3302
3305
3314 gtk_grid_attach(GTK_GRID(sbox), descbox, 1, 0, 1, 2);
3315
3320
3321 button = gtk_button_new_with_mnemonic(_("_Browse..."));
3324 g_signal_connect(button, "clicked",
3326
3327 button = gtk_button_new_with_mnemonic(_("_Cancel"));
3329 g_signal_connect(button, "clicked",
3331
3332 button = gtk_button_new_with_mnemonic(_("_OK"));
3334 g_signal_connect(button, "clicked",
3336
3337 return vbox;
3338}
3339
3340/**********************************************************************/
3344{
3345 return current_page;
3346}
3347
3348/**********************************************************************/
3352{
3353 /* Don't use current_page directly here because maybe it could be modified
3354 * before we reach the end of this function. */
3356
3357 /* If the page remains the same, don't do anything. */
3358 if (old_page == new_page) {
3359 return;
3360 }
3361
3362 log_debug("Switching client page from %s to %s.",
3363 -1 == old_page ? "(no page)" : client_pages_name(old_page),
3365
3367
3368 switch (old_page) {
3369 case PAGE_SCENARIO:
3370 case PAGE_LOAD:
3371 break;
3372 case PAGE_GAME:
3373 {
3375
3377 if (vmode == NULL) {
3379 }
3380 }
3381 break;
3382 default:
3383 break;
3384 }
3385
3386 switch (new_page) {
3387 case PAGE_MAIN:
3388 case PAGE_START:
3389 if (is_server_running()) {
3390 if (game.info.is_new_game) {
3392 } else {
3394 }
3396 } else {
3398 }
3402 break;
3403 case PAGE_GAME:
3404 {
3406
3409 if (vmode == NULL) {
3411 }
3414 }
3415 break;
3416 case PAGE_LOAD:
3418 break;
3419 case PAGE_SCENARIO:
3421 break;
3422 case PAGE_NETWORK:
3424 break;
3425 }
3426
3427 /* hide/show statusbar. */
3428 if (new_page == PAGE_START || new_page == PAGE_GAME) {
3431 } else {
3433 }
3434
3436
3437 /* Update the GUI. */
3438 while (gtk_events_pending()) {
3440 }
3441
3442 switch (new_page) {
3443 case PAGE_MAIN:
3444 break;
3445 case PAGE_START:
3448 break;
3449 case PAGE_LOAD:
3451 break;
3452 case PAGE_SCENARIO:
3454 break;
3455 case PAGE_GAME:
3459 mapview_thaw();
3460 break;
3461 case PAGE_NETWORK:
3466 break;
3467 }
3468}
3469
3470/****************************************************************************
3471 SAVE GAME DIALOGs
3472****************************************************************************/
3473
3474/**********************************************************************/
3478{
3479 return fileinfolist_infix(get_save_dirs(), ".sav", FALSE);
3480}
3481
3482/**********************************************************************/
3486{
3487 static GtkWidget *shell = NULL;
3488
3489 if (NULL != shell) {
3490 return;
3491 }
3492
3493 shell = save_dialog_new(_("Save Game"), _("Saved _Games:"),
3494 _("Save _Filename:"), send_save_game,
3497 &shell);
3499}
3500
3501/**********************************************************************/
3504static void save_dialog_save_scenario(const char *filename)
3505{
3507}
3508
3509/**********************************************************************/
3513{
3514 return fileinfolist_infix(get_scenario_dirs(), ".sav", FALSE);
3515}
3516
3517/**********************************************************************/
3521{
3522 static GtkWidget *shell = NULL;
3523
3524 if (NULL != shell) {
3525 return;
3526 }
3527
3528 shell = save_dialog_new(_("Save Scenario"), _("Saved Sce_narios:"),
3529 _("Save Sc_enario:"), save_dialog_save_scenario,
3532 &shell);
3534}
3535
3536/**********************************************************************/
3542{
3543 return fileinfolist_infix(get_save_dirs(), ".map", FALSE);
3544}
3545
3546/**********************************************************************/
3550{
3551 static GtkWidget *shell = NULL;
3552
3553 if (NULL != shell) {
3554 return;
3555 }
3556
3557 shell = save_dialog_new(_("Save Map Image"), _("Saved Map _Images:"),
3558 _("Save _Map Images:"), mapimg_client_save,
3561 &shell);
3563}
3564
3565/**********************************************************************/
3568void mapimg_client_save(const char *filename)
3569{
3570 if (!mapimg_client_createmap(filename)) {
3571 char msg[512];
3572
3573 fc_snprintf(msg, sizeof(msg), "(%s)", mapimg_error());
3574 popup_notify_dialog(_("Error"),
3575 _("Error Creating the Map Image!"), msg);
3576 }
3577}
3578
3579/**********************************************************************/
3584void set_rulesets(int num_rulesets, char **rulesets)
3585{
3586 int i;
3587 int def_idx = -1;
3588
3590 for (i = 0; i < num_rulesets; i++) {
3591
3593 if (!strcmp("default", rulesets[i])) {
3594 def_idx = i;
3595 }
3596 }
3597
3599
3600 /* HACK: server should tell us the current ruleset. */
3602
3604}
#define n
Definition astring.c:77
struct canvas int int struct sprite int int int int height
Definition canvas_g.h:44
struct canvas int int struct sprite int int int width
Definition canvas_g.h:44
int send_chat_printf(const char *format,...)
int send_chat(const char *message)
void output_window_append(const struct ft_color color, const char *featured_text)
bool can_client_control(void)
bool client_is_global_observer(void)
bool client_is_observer(void)
char user_name[512]
char server_host[512]
struct civclient client
enum client_states client_state(void)
char fc_password[MAX_LEN_PASSWORD]
int server_port
#define client_player()
@ C_S_PREPARING
Definition client_main.h:46
enum ai_level server_ai_level(void)
Definition climisc.c:1508
bool mapimg_client_createmap(const char *filename)
Definition climisc.c:1455
void center_on_something(void)
Definition climisc.c:430
static struct fc_sockaddr_list * list
Definition clinet.c:102
int connect_to_server(const char *username, const char *hostname, int port, char *errbuf, int errbufsize)
Definition clinet.c:249
void disconnect_from_server(bool leaving_sound)
Definition clinet.c:306
char * incite_cost
Definition comments.c:74
authentication_type
Definition conn_types.h:41
@ AUTH_NEWUSER_RETRY
Definition conn_types.h:45
@ AUTH_NEWUSER_FIRST
Definition conn_types.h:43
@ AUTH_LOGIN_RETRY
Definition conn_types.h:44
@ AUTH_LOGIN_FIRST
Definition conn_types.h:42
void send_save_game(const char *filename)
void set_ruleset(const char *ruleset)
bool is_server_running(void)
bool client_start_server(void)
bool can_client_access_hack(void)
const char * conn_description(const struct connection *pconn)
Definition connection.c:474
struct connection * conn_by_number(int id)
Definition connection.c:421
#define conn_list_iterate(connlist, pconn)
Definition connection.h:108
#define conn_list_iterate_end
Definition connection.h:110
popup_notify_dialog
Definition dialogs_g.h:37
int int id
Definition editgui_g.h:28
enum event_type event
Definition events.c:81
#define MAX_NUM_PLAYERS
Definition fc_types.h:36
#define MAX_LEN_NAME
Definition fc_types.h:66
#define Q_(String)
Definition fcintl.h:70
#define _(String)
Definition fcintl.h:67
void fc_mutex_allocate(fc_mutex *mutex)
void fc_mutex_release(fc_mutex *mutex)
const struct ft_color ftc_client
struct civ_game game
Definition game.c:61
static PangoLayout * layout
Definition canvas.c:325
void inputline_toolkit_view_append_button(GtkWidget *toolkit_view, GtkWidget *button)
Definition chatline.c:1293
GtkWidget * inputline_toolkit_view_new(void)
Definition chatline.c:1271
void inputline_grab_focus(void)
Definition chatline.c:80
void chatline_scroll_to_bottom(bool delayed)
Definition chatline.c:1007
void popup_races_dialog(struct player *pplayer)
Definition dialogs.c:1215
static struct tile * pos
Definition finddlg.c:53
const char * client_string
Definition gui_main.c:105
GtkTextBuffer * message_buffer
Definition gui_main.c:178
struct video_mode * resolution_request_get(void)
Definition gui_main.c:2634
void enable_menus(bool enable)
Definition gui_main.c:1075
void refresh_chat_buttons(void)
Definition gui_main.c:2532
void reset_unit_table(void)
Definition gui_main.c:1046
GtkWidget * toplevel
Definition gui_main.c:125
void quit_gtk_main(void)
Definition gui_main.c:2360
static struct video_mode vmode
Definition gui_main.c:191
GtkWidget * toplevel_tabs
Definition gui_main.c:127
int screen_height(void)
Definition gui_main.c:2616
#define GUI_GTK_OPTION(optname)
Definition gui_main.h:25
void gtk_tree_view_focus(GtkTreeView *view)
Definition gui_stuff.c:236
void gtk_stockbutton_set_label(GtkWidget *button, const gchar *label_text)
Definition gui_stuff.c:96
GtkWidget * icon_label_button_new(const gchar *icon_name, const gchar *label_text)
Definition gui_stuff.c:76
GtkTreeViewColumn * add_treeview_column(GtkWidget *view, const char *title, GType gtype, int model_index)
Definition gui_stuff.c:1123
void setup_dialog(GtkWidget *shell, GtkWidget *parent)
Definition gui_stuff.c:287
void mapview_freeze(void)
Definition mapview.c:373
void overview_size_changed(void)
Definition mapview.c:326
void mapview_thaw(void)
Definition mapview.c:381
static struct gui_dialog * shell
Definition messagedlg.c:39
void option_dialog_popup(const char *name, const struct option_set *poptset)
Definition optiondlg.c:972
static GtkListStore * load_store
Definition pages.c:68
static void update_network_page(void)
Definition pages.c:1183
void handle_game_load(bool load_successful, const char *filename)
Definition pages.c:2839
GtkWidget * create_start_page(void)
Definition pages.c:2621
GtkWidget * create_network_page(void)
Definition pages.c:1199
static void client_aitoggle_player(void *data)
Definition pages.c:1507
static GtkWidget * nation_button
Definition pages.c:1458
static void update_server_list(enum server_scan_type sstype, const struct server_list *list)
Definition pages.c:702
static void start_scenario_callback(GtkWidget *w, gpointer data)
Definition pages.c:115
static GtkTreeSelection * scenario_selection
Definition pages.c:73
static void update_start_page_buttons(void)
Definition pages.c:2197
static void save_dialog_response_callback(GtkWidget *w, gint response, gpointer data)
Definition pages.c:487
GtkWidget * create_scenario_page(void)
Definition pages.c:3183
static void show_conn_popup(struct player *pplayer, struct connection *pconn)
Definition pages.c:1765
static GtkWidget * network_confirm_password_label
Definition pages.c:697
void save_mapimg_dialog_popup(void)
Definition pages.c:3549
static void ruleset_selected(const char *name)
Definition pages.c:1613
static void ready_button_callback(GtkWidget *w, gpointer data)
Definition pages.c:2143
static bool conn_list_selection(struct player **ppplayer, struct connection **ppconn)
Definition pages.c:2056
static struct server_scan_timer_data meta_scan
Definition pages.c:86
static void update_network_lists(void)
Definition pages.c:836
static GtkWidget * statusbar
Definition pages.c:89
static GtkWidget * server_playerlist_view
Definition pages.c:71
static GtkListStore * save_dialog_store_new(void)
Definition pages.c:397
void append_network_statusbar(const char *text, bool force)
Definition pages.c:892
static gboolean update_network_statusbar(gpointer data)
Definition pages.c:862
void set_rulesets(int num_rulesets, char **rulesets)
Definition pages.c:3584
void mapimg_client_save(const char *filename)
Definition pages.c:3568
static void conn_menu_player_command(GObject *object, gpointer data)
Definition pages.c:1724
static void load_filename(const char *filename)
Definition pages.c:2854
static void conn_menu_nation_chosen(GObject *object, gpointer data)
Definition pages.c:1711
static GtkWidget * scenario_description
Definition pages.c:63
void save_game_dialog_popup(void)
Definition pages.c:3485
enum client_pages get_current_client_page(void)
Definition pages.c:3343
static GtkListStore * lan_store
Definition pages.c:68
static enum connection_state connection_status
Definition pages.c:857
save_dialog_columns
Definition pages.c:381
@ SD_COL_NUM
Definition pages.c:385
@ SD_COL_FULL_PATH
Definition pages.c:383
@ SD_COL_PRETTY_NAME
Definition pages.c:382
static struct server_scan_timer_data lan_scan
Definition pages.c:87
static void save_dialog_list_callback(GtkTreeSelection *selection, gpointer data)
Definition pages.c:555
static void connect_network_game_callback(GtkWidget *w, gpointer data)
Definition pages.c:132
static GtkTreeView * connection_list_view
Definition pages.c:1460
static GtkWidget * network_login
Definition pages.c:693
static GtkWidget * network_login_label
Definition pages.c:693
connection_state
Definition pages.c:850
@ LOGIN_TYPE
Definition pages.c:851
@ NEW_PASSWORD_TYPE
Definition pages.c:852
@ WAITING_TYPE
Definition pages.c:854
@ ENTER_PASSWORD_TYPE
Definition pages.c:853
static void connect_callback(GtkWidget *w, gpointer data)
Definition pages.c:1041
static void scenario_browse_callback(GtkWidget *w, gpointer data)
Definition pages.c:3057
static GtkListStore * meta_store
Definition pages.c:68
connection_list_columns
Definition pages.c:1466
@ CL_COL_STYLE
Definition pages.c:1476
@ CL_COL_USER_NAME
Definition pages.c:1468
@ CL_COL_READY_STATE
Definition pages.c:1469
@ CL_COL_WEIGHT
Definition pages.c:1477
@ CL_COL_PLAYER_NAME
Definition pages.c:1470
@ CL_COL_NATION
Definition pages.c:1473
@ CL_COL_CONN_ID
Definition pages.c:1475
@ CL_COL_PLAYER_NUMBER
Definition pages.c:1467
@ CL_NUM_COLUMNS
Definition pages.c:1480
@ CL_COL_TEAM
Definition pages.c:1474
@ CL_COL_COLOR
Definition pages.c:1472
@ CL_COL_COLLAPSED
Definition pages.c:1478
@ CL_COL_FLAG
Definition pages.c:1471
static void update_load_page(void)
Definition pages.c:2889
static void save_dialog_update(struct save_dialog *pdialog)
Definition pages.c:425
static GtkWidget * scenario_authors
Definition pages.c:64
static GtkWidget * start_aifill_spin
Definition pages.c:1461
static void ruleset_entry_changed(GtkWidget *w, gpointer data)
Definition pages.c:1625
void(* save_dialog_action_fn_t)(const char *filename)
Definition pages.c:370
static void open_settings(void)
Definition pages.c:141
static void set_connection_state(enum connection_state state)
Definition pages.c:928
static GtkWidget * ruleset_combo
Definition pages.c:93
static void observe_button_callback(GtkWidget *w, gpointer data)
Definition pages.c:2177
static void conn_menu_ready_chosen(GObject *object, gpointer data)
Definition pages.c:1698
static void server_scan_error(struct server_scan *scan, const char *message)
Definition pages.c:823
static void load_callback(void)
Definition pages.c:2862
static void save_dialog_file_chooser_callback(GtkWidget *widget, gint response, gpointer data)
Definition pages.c:442
static void network_list_callback(GtkTreeSelection *select, gpointer data)
Definition pages.c:1137
static GtkListStore * server_playerlist_store
Definition pages.c:70
static void nation_button_callback(GtkWidget *w, gpointer data)
Definition pages.c:2157
void real_set_client_page(enum client_pages new_page)
Definition pages.c:3351
static void conn_menu_connection_command(GObject *object, gpointer data)
Definition pages.c:1751
static void scenario_list_callback(void)
Definition pages.c:2985
static gboolean intro_expose(GtkWidget *w, cairo_t *cr, gpointer *data)
Definition pages.c:164
static void load_browse_callback(GtkWidget *w, gpointer data)
Definition pages.c:2879
static void network_activate_callback(GtkTreeView *view, GtkTreePath *arg1, GtkTreeViewColumn *arg2, gpointer data)
Definition pages.c:1096
static struct fileinfo_list * save_dialog_scenario_list(void)
Definition pages.c:3512
static void connection_state_reset(void)
Definition pages.c:996
void real_conn_list_dialog_update(void *unused)
Definition pages.c:2342
static gboolean connection_list_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
Definition pages.c:1987
static bool holding_srv_list_mutex
Definition pages.c:95
static GtkTreeStore * connection_list_store
Definition pages.c:1459
static struct fileinfo_list * save_dialog_savegame_list(void)
Definition pages.c:3477
static void start_new_game_callback(GtkWidget *w, gpointer data)
Definition pages.c:102
void destroy_server_scans(void)
Definition pages.c:766
void save_scenario_dialog_popup(void)
Definition pages.c:3520
static GtkTreeSelection * lan_selection
Definition pages.c:74
static void save_dialog_save_scenario(const char *filename)
Definition pages.c:3504
struct fileinfo_list *(* save_dialog_files_fn_t)(void)
Definition pages.c:371
static gboolean check_server_scan(gpointer data)
Definition pages.c:789
static void save_dialog_store_update(GtkListStore *store, const struct fileinfo_list *files)
Definition pages.c:407
static void ai_fill_changed_by_user(GtkWidget *w, gpointer data)
Definition pages.c:1640
static gboolean delayed_unselect_path(gpointer data)
Definition pages.c:1971
static void conn_menu_player_take(GObject *object, gpointer data)
Definition pages.c:1738
static void conn_menu_info_chosen(GObject *object, gpointer data)
Definition pages.c:1796
static bool model_get_player_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *start, const struct player *pplayer)
Definition pages.c:2282
static GtkTreeSelection * load_selection
Definition pages.c:73
static void ai_skill_callback(GtkWidget *w, gpointer data)
Definition pages.c:1587
static enum client_pages current_page
Definition pages.c:78
static GtkWidget * statusbar_frame
Definition pages.c:89
static GtkWidget * network_confirm_password
Definition pages.c:697
static void client_take_player(struct player *pplayer)
Definition pages.c:1521
static void clear_network_statusbar(void)
Definition pages.c:878
static GtkTreeSelection * meta_selection
Definition pages.c:74
static void save_dialog_row_callback(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer data)
Definition pages.c:536
static void connection_list_row_callback(GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer data)
Definition pages.c:2041
save_dialog_response
Definition pages.c:388
@ SD_RES_DELETE
Definition pages.c:390
@ SD_RES_SAVE
Definition pages.c:391
@ SD_RES_BROWSE
Definition pages.c:389
GtkWidget * create_load_page(void)
Definition pages.c:2902
static GtkWidget * ai_lvl_combobox
Definition pages.c:1462
static GtkWidget * network_password_label
Definition pages.c:696
static GtkWidget * save_dialog_new(const char *title, const char *savelabel, const char *savefilelabel, save_dialog_action_fn_t action, save_dialog_files_fn_t files)
Definition pages.c:576
static void intro_free(GtkWidget *w, gpointer *data)
Definition pages.c:219
static GtkWidget * network_password
Definition pages.c:696
static GtkWidget * network_host
Definition pages.c:694
void handle_authentication_req(enum authentication_type type, const char *message)
Definition pages.c:1005
static GtkTreeStore * connection_list_store_new(void)
Definition pages.c:1486
static bool send_new_aifill_to_server
Definition pages.c:1639
static void save_dialog_file_chooser_popup(const char *title, GtkFileChooserAction action, save_dialog_action_fn_t cb)
Definition pages.c:462
static GtkWidget * network_port
Definition pages.c:695
static void add_tree_col(GtkWidget *treeview, GType gtype, const char *title, int colnum, const char *key)
Definition pages.c:2587
static void save_dialog_entry_callback(GtkEntry *entry, gpointer data)
Definition pages.c:547
static void main_callback(GtkWidget *w, gpointer data)
Definition pages.c:149
void update_start_page(void)
Definition pages.c:1673
static void scenario_callback(void)
Definition pages.c:3041
static GtkWidget * start_options_table
Definition pages.c:1457
static bool no_ruleset_callback
Definition pages.c:1608
void ai_fill_changed_by_server(int aifill)
Definition pages.c:1651
static void update_server_playerlist(const struct server *pserver)
Definition pages.c:1108
static GtkWidget * observe_button
Definition pages.c:1458
static GtkWidget * scenario_version
Definition pages.c:66
GtkWidget * create_statusbar(void)
Definition pages.c:907
static void game_options_callback(GtkWidget *w, gpointer data)
Definition pages.c:1579
static GtkListStore * scenario_store
Definition pages.c:68
static GtkWidget * network_host_label
Definition pages.c:694
static bool model_get_conn_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *parent, GtkTreeIter *start, const struct connection *pconn)
Definition pages.c:2313
static GQueue * statusbar_queue
Definition pages.c:90
GtkWidget * start_message_area
Definition pages.c:1455
static GtkWidget * network_port_label
Definition pages.c:695
static void update_scenario_page(void)
Definition pages.c:3067
static GtkWidget * scenario_filename
Definition pages.c:65
static void conn_menu_team_chosen(GObject *object, gpointer data)
Definition pages.c:1681
static GtkWidget * create_conn_menu(struct player *pplayer, struct connection *pconn)
Definition pages.c:1810
static void load_saved_game_callback(GtkWidget *w, gpointer data)
Definition pages.c:124
static guint statusbar_timer
Definition pages.c:91
static bool object_extract(GObject *object, struct player **ppplayer, struct connection **ppconn)
Definition pages.c:1552
static void object_put(GObject *object, struct player *pplayer, struct connection *pconn)
Definition pages.c:1533
static struct fileinfo_list * save_dialog_mapimg_list(void)
Definition pages.c:3541
GtkWidget * create_main_page(void)
Definition pages.c:229
static void conn_list_select_conn(struct connection *pconn)
Definition pages.c:2092
static GtkWidget * ready_button
Definition pages.c:1458
GdkPixbuf * create_player_icon(const struct player *plr)
Definition plrdlg.c:117
GdkPixbuf * get_flag(const struct nation_type *nation)
Definition plrdlg.c:607
const char * title
Definition repodlgs.c:1314
GType type
Definition repodlgs.c:1313
void free_sprite(struct sprite *s)
Definition sprite.c:278
struct sprite * sprite_scale(struct sprite *src, int new_w, int new_h)
Definition sprite.c:291
struct sprite * load_gfxfile(const char *filename, bool svgflag)
Definition sprite.c:170
void voteinfo_gui_update(void)
GtkWidget * voteinfo_bar_new(bool split_bar)
GtkWidget * pregame_votebar
void(* save_dialog_action_fn_t)(const char *filename)
Definition pages.c:379
struct fileinfo_list *(* save_dialog_files_fn_t)(void)
Definition pages.c:380
static struct server_list * server_list
Definition connectdlg.c:61
static enum client_pages old_page
Definition pages.c:46
void conn_list_dialog_update(void)
const char * name
Definition inputfile.c:127
#define fc_assert_ret(condition)
Definition log.h:191
#define fc_assert_ret_val(condition, val)
Definition log.h:194
#define log_debug(message,...)
Definition log.h:115
#define log_error(message,...)
Definition log.h:103
const char * mapimg_error(void)
Definition mapimg.c:759
#define fc_strdup(str)
Definition mem.h:43
#define fc_malloc(sz)
Definition mem.h:34
const char * nation_adjective_for_player(const struct player *pplayer)
Definition nation.c:169
bool can_conn_edit_players_nation(const struct connection *pconn, const struct player *pplayer)
Definition nation.c:1187
#define NO_NATION_SELECTED
Definition nation.h:30
const struct option_set * server_optset
Definition options.c:4281
const struct option_set * client_optset
Definition options.c:1315
int option_int_get(const struct option *poption)
Definition options.c:869
struct option * optset_option_by_name(const struct option_set *poptset, const char *name)
Definition options.c:466
bool option_int_set(struct option *poption, int val)
Definition options.c:913
int send_packet_authentication_reply(struct connection *pc, const struct packet_authentication_reply *packet)
int dsend_packet_save_scenario(struct connection *pc, const char *name)
int dsend_packet_player_ready(struct connection *pc, int player_no, bool is_ready)
bool is_settable_ai_level(enum ai_level level)
Definition player.c:1925
struct player * player_by_number(const int player_id)
Definition player.c:849
int player_slot_count(void)
Definition player.c:418
int player_number(const struct player *pplayer)
Definition player.c:837
const char * player_name(const struct player *pplayer)
Definition player.c:895
bool player_has_flag(const struct player *pplayer, enum plr_flag_id flag)
Definition player.c:1996
#define ai_level_cmd(_level_)
Definition player.h:569
#define players_iterate_end
Definition player.h:539
#define players_iterate(_pplayer)
Definition player.h:534
#define is_ai(plr)
Definition player.h:232
#define players_iterate_alive_end
Definition player.h:549
#define is_human(plr)
Definition player.h:231
#define players_iterate_alive(_pplayer)
Definition player.h:544
void secfile_destroy(struct section_file *secfile)
struct section_file * secfile_load_section(const char *filename, const char *section, bool allow_duplicates)
bool secfile_lookup_bool_default(const struct section_file *secfile, bool def, const char *path,...)
int secfile_lookup_int_default(const struct section_file *secfile, int def, const char *path,...)
const char * secfile_lookup_str_default(const struct section_file *secfile, const char *def, const char *path,...)
struct srv_list * server_scan_get_list(struct server_scan *scan)
Definition servers.c:866
void server_scan_finish(struct server_scan *scan)
Definition servers.c:879
struct server_scan * server_scan_begin(enum server_scan_type type, ServerScanErrorFunc error_func)
Definition servers.c:755
enum server_scan_type server_scan_get_type(const struct server_scan *scan)
Definition servers.c:809
enum server_scan_status server_scan_poll(struct server_scan *scan)
Definition servers.c:832
#define server_list_iterate_end
Definition servers.h:57
server_scan_status
Definition servers.h:79
@ SCAN_STATUS_PARTIAL
Definition servers.h:82
@ SCAN_STATUS_ERROR
Definition servers.h:80
@ SCAN_STATUS_DONE
Definition servers.h:83
#define server_list_iterate(serverlist, pserver)
Definition servers.h:55
server_scan_type
Definition servers.h:67
@ SERVER_SCAN_LOCAL
Definition servers.h:68
@ SERVER_SCAN_GLOBAL
Definition servers.h:69
struct setting_list * level[OLEVELS_NUM]
Definition settings.c:190
const struct strvec * get_scenario_dirs(void)
Definition shared.c:971
const struct strvec * get_save_dirs(void)
Definition shared.c:934
char * skip_to_basename(char *filepath)
Definition shared.c:1750
struct fileinfo_list * fileinfolist_infix(const struct strvec *dirs, const char *infix, bool nodups)
Definition shared.c:1204
#define fileinfo_list_iterate(list, pnode)
Definition shared.h:182
#define FC_PTR_TO_INT(p)
Definition shared.h:95
#define fileinfo_list_iterate_end
Definition shared.h:184
#define FC_INT_TO_PTR(i)
Definition shared.h:94
size_t size
Definition specvec.h:72
struct sprite int int int int struct sprite int int float scale
Definition sprite_g.h:33
struct sprite int int int int struct sprite int int float bool smooth get_sprite_dimensions
Definition sprite_g.h:36
const char * aifill(int amount)
Definition srv_main.c:2505
struct conn_list * est_connections
Definition game.h:97
struct packet_game_info info
Definition game.h:89
struct connection conn
Definition client_main.h:96
Definition colors.h:21
struct player * playing
Definition connection.h:151
enum cmdlevel access_level
Definition connection.h:177
Definition climisc.h:80
struct team * team
Definition player.h:261
bool is_ready
Definition player.h:262
save_dialog_action_fn_t action
Definition pages.c:377
GtkEntry * entry
Definition pages.c:376
GtkTreeView * tree_view
Definition pages.c:375
GtkDialog * shell
Definition pages.c:374
save_dialog_files_fn_t files
Definition pages.c:378
struct server_scan * scan
Definition pages.c:82
fc_mutex mutex
Definition servers.h:64
struct server_list * servers
Definition servers.h:63
Definition team.c:40
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:960
int cat_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:986
int fc_remove(const char *filename)
Definition support.c:555
#define sz_strlcpy(dest, src)
Definition support.h:189
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
#define sz_strlcat(dest, src)
Definition support.h:190
#define fc_strncmp(_s1_, _s2_, _len_)
Definition support.h:154
const char * team_name_translation(const struct team *pteam)
Definition team.c:420
const char * team_slot_name_translation(const struct team_slot *tslot)
Definition team.c:253
int team_number(const struct team *pteam)
Definition team.c:391
int team_slot_index(const struct team_slot *tslot)
Definition team.c:138
const struct player_list * team_members(const struct team *pteam)
Definition team.c:456
bool team_slot_is_used(const struct team_slot *tslot)
Definition team.c:162
const char * team_slot_rule_name(const struct team_slot *tslot)
Definition team.c:233
#define team_slots_iterate_end
Definition team.h:77
#define team_slots_iterate(_tslot)
Definition team.h:72
const char * tileset_main_intro_filename(const struct tileset *t)
Definition tilespec.c:948
void client_start_server_and_set_page(enum client_pages page)
void set_client_page(enum client_pages page)
void update_queue_connect_processing_finished(int request_id, uq_callback_t callback, void *data)
enum client_pages get_client_page(void)
const char * fc_git_revision(void)
Definition version.c:75
const char * unstable_message(void)
Definition version.c:160
const char * word_version(void)
Definition version.c:62