Freeciv-3.1: /fast/freeciv/nightly/S3_1/client/gui-gtk-4.0/cityrep.c Source File

Freeciv-3.1

Loading...
Searching...
No Matches
cityrep.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 <stdlib.h>
20#include <string.h>
21
22#include <gtk/gtk.h>
23#include <gdk/gdkkeysyms.h>
24
25/* utility */
26#include "fcintl.h"
27#include "log.h"
28#include "shared.h"
29#include "support.h"
30
31/* common */
32#include "city.h"
33#include "game.h"
34#include "packets.h"
35#include "unit.h"
36
37/* client/agents */
38#include "cma_fec.h"
39
40/* client */
41#include "citydlg_common.h"
42#include "cityrepdata.h"
43#include "client_main.h"
44#include "climisc.h"
45#include "global_worklist.h"
46#include "mapctrl_common.h" /* is_city_hilited() */
47#include "mapview_common.h"
48#include "options.h"
49
50/* client/gui-gtk-4.0 */
51#include "chatline.h"
52#include "citydlg.h"
53#include "gui_main.h"
54#include "gui_stuff.h"
55#include "mapview.h"
56#include "optiondlg.h"
57#include "repodlgs.h"
58
59#include "cityrep.h"
60
61#define NEG_VAL(x) ((x)<0 ? (x) : (-x))
62
63/* Some versions of gcc have problems with negative values here (PR#39722). */
64#define CMA_NONE (10000)
65#define CMA_CUSTOM (10001)
66
67struct sell_data {
68 int count; /* Number of cities. */
69 int gold; /* Amount of gold. */
70 const struct impr_type *target; /* The target for selling. */
71};
72
73 enum city_operation_type {
74 CO_CHANGE, CO_LAST, CO_NEXT, CO_FIRST, CO_NEXT_TO_LAST, CO_SELL, CO_NONE
75};
76
77/******************************************************************/
78static void create_city_report_dialog(bool make_modal);
79
80static void city_activated_callback(GtkTreeView *view, GtkTreePath *path,
81 GtkTreeViewColumn *col, gpointer data);
82
83static void city_command_callback(struct gui_dialog *dlg, int response,
84 gpointer data);
85
86static void city_selection_changed_callback(GtkTreeSelection *selection);
87static void city_clear_worklist_callback(GSimpleAction *action, GVariant *parameter,
88 gpointer data);
89static void update_total_buy_cost(void);
90
91static GMenu *create_production_menu(GActionGroup *group);
92static GMenu *create_select_menu(GActionGroup *group);
93
94static GMenu *create_change_menu(GActionGroup *group, const char *mname,
95 const char *human_mname,
96 enum city_operation_type oper);
97
98 static struct gui_dialog *city_dialog_shell = NULL;
99
100enum {
101 CITY_CENTER = 1, CITY_POPUP, CITY_BUY
102};
103
104 static GtkWidget *city_view;
105 static GtkTreeSelection *city_selection;
106 static GtkListStore *city_model;
107#define CRD_COL_CITY_ID (0 + NUM_CREPORT_COLS)
108
109#ifdef MENUS_GTK3
110static void popup_select_menu(GtkMenuShell *menu, gpointer data);
111#endif /* MENUS_GTK3 */
112
113static void recreate_production_menu(GActionGroup *group);
114static void recreate_select_menu(GActionGroup *group);
115static void recreate_sell_menu(GActionGroup *group);
116
117 static GtkWidget *city_center_command;
118 static GtkWidget *city_popup_command;
119 static GtkWidget *city_buy_command;
120#ifdef MENUS_GTK3
121static GtkWidget *city_sell_command;
122#endif /* MENUS_GTK3 */
123 static GtkWidget *city_total_buy_cost_label;
124
125 static GMenu *prod_menu = NULL;
126 static GMenu *change_menu;
127 static GMenu *add_first_menu;
128 static GMenu *add_last_menu;
129 static GMenu *add_next_menu;
130 static GMenu *add_2ndlast_menu;
131 static GMenu *wl_set_menu;
132 static GMenu *wl_append_menu;
133
134 static GMenu *select_menu;
135 static GMenu *unit_b_select_menu = NULL;
136 static GMenu *impr_b_select_menu;
137 static GMenu *wndr_b_select_menu;
138 static GMenu *unit_s_select_menu;
139 static GMenu *unit_p_select_menu;
140 static GMenu *impr_p_select_menu;
141 static GMenu *wndr_p_select_menu;
142 static GMenu *unit_a_select_menu;
143 static GMenu *impr_a_select_menu;
144 static GMenu *wndr_a_select_menu;
145 static GMenu *governor_select_menu;
146
147 static int city_dialog_shell_is_modal;
148
149 static GMenu *cityrep_menu;
150 static GActionGroup *cityrep_group;
151 static GMenu *display_menu;
152
153/************************************************************************/
156 static void get_city_table_header(char **text, int n)
157{
158 struct city_report_spec *spec;
159 int i;
160
161 for (i = 0, spec = city_report_specs; i < NUM_CREPORT_COLS; i++, spec++) {
162 fc_snprintf(text[i], n, "%*s\n%*s",
163 NEG_VAL(spec->width), spec->title1 ? spec->title1 : "",
164 NEG_VAL(spec->width), spec->title2 ? spec->title2 : "");
165 }
166}
167
168/****************************************************************************
169 CITY REPORT DIALOG
170****************************************************************************/
171
172/************************************************************************/
175 static GtkListStore *city_report_dialog_store_new(void)
176{
177 GType model_types[NUM_CREPORT_COLS + 1];
178 gint i;
179
180 /* City report data. */
181 for (i = 0; i < NUM_CREPORT_COLS; i++) {
182 model_types[i] = G_TYPE_STRING;
183 }
184
185 /* Specific gtk client data. */
186 model_types[i++] = G_TYPE_INT; /* CRD_COL_CITY_ID */
187
188 return gtk_list_store_newv(i, model_types);
189}
190
191/************************************************************************/
194 static void city_model_set(GtkListStore *store, GtkTreeIter *iter,
195 struct city *pcity)
196{
197 struct city_report_spec *spec;
198 char buf[64];
199 gint i;
200
201 for (i = 0; i < NUM_CREPORT_COLS; i++) {
202 spec = city_report_specs + i;
203 fc_snprintf(buf, sizeof(buf), "%*s", NEG_VAL(spec->width),
204 spec->func(pcity, spec->data));
205 gtk_list_store_set(store, iter, i, buf, -1);
206 }
207 gtk_list_store_set(store, iter, CRD_COL_CITY_ID, pcity->id, -1);
208}
209
210/************************************************************************/
213 static struct city *city_model_get(GtkTreeModel *model, GtkTreeIter *iter)
214{
215 struct city *pcity;
216 int id;
217
218 gtk_tree_model_get(model, iter, CRD_COL_CITY_ID, &id, -1);
219 pcity = game_city_by_number(id);
220 return ((NULL != pcity
221 && client_has_player()
222 && city_owner(pcity) != client_player())
223 ? NULL : pcity);
224}
225
226/************************************************************************/
229 static gboolean city_model_find(GtkTreeModel *model, GtkTreeIter *iter,
230 const struct city *pcity)
231{
232 const int searched = pcity->id;
233 int id;
234
235 if (gtk_tree_model_get_iter_first(model, iter)) {
236 do {
237 gtk_tree_model_get(model, iter, CRD_COL_CITY_ID, &id, -1);
238 if (searched == id) {
239 return TRUE;
240 }
241 } while (gtk_tree_model_iter_next(model, iter));
242 }
243 return FALSE;
244}
245
246/************************************************************************/
249 static void city_model_fill(GtkListStore *store,
250 GtkTreeSelection *selection, GHashTable *select)
251{
252 GtkTreeIter iter;
253
254 if (client_has_player()) {
255 city_list_iterate(client_player()->cities, pcity) {
256 gtk_list_store_append(store, &iter);
257 city_model_set(store, &iter, pcity);
258 if (NULL != select
259 && g_hash_table_remove(select, GINT_TO_POINTER(pcity->id))) {
260 gtk_tree_selection_select_iter(selection, &iter);
261 }
262 } city_list_iterate_end;
263 } else {
264 /* Global observer case. */
265 cities_iterate(pcity) {
266 gtk_list_store_append(store, &iter);
267 city_model_set(store, &iter, pcity);
268 if (NULL != select
269 && g_hash_table_remove(select, GINT_TO_POINTER(pcity->id))) {
270 gtk_tree_selection_select_iter(selection, &iter);
271 }
272 } cities_iterate_end;
273 }
274}
275
276/************************************************************************/
279 void city_report_dialog_popup(bool raise)
280{
281 if (!city_dialog_shell) {
282 city_dialog_shell_is_modal = FALSE;
283
284 create_city_report_dialog(FALSE);
285 }
286
287 gui_dialog_present(city_dialog_shell);
288 hilite_cities_from_canvas();
289 if (raise) {
290 gui_dialog_raise(city_dialog_shell);
291 }
292}
293
294/************************************************************************/
297 void city_report_dialog_popdown(void)
298{
299 if (city_dialog_shell) {
300 gui_dialog_destroy(city_dialog_shell);
301 }
302}
303
304/************************************************************************/
307 static void append_impr_or_unit_to_menu(GMenu *menu,
308 GActionGroup *act_group,
309 const char *act_pfx,
310 const char *act_pfx2,
311 bool append_units,
312 bool append_wonders,
313 enum city_operation_type
314 city_operation,
315 TestCityFunc test_func,
316 GCallback callback,
317 int size)
318{
319 struct universal targets[MAX_NUM_PRODUCTION_TARGETS];
320 struct item items[MAX_NUM_PRODUCTION_TARGETS];
321 int i, item, targets_used;
322 char *row[4];
323 char buf[4][64];
324
325 GtkSizeGroup *size_group[3];
326
327#ifdef MENUS_GTK3
328 const char *markup[3] = {
329 "weight=\"bold\"",
330 "",
331 ""
332 };
333#endif
334
335 if (city_operation != CO_NONE) {
336 GPtrArray *selected;
337 ITree it;
338 int num_selected = 0;
339 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
340 struct city **data;
341
342 selected = g_ptr_array_sized_new(size);
343
344 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
345 struct city *pcity;
346
347 if (!itree_is_selected(city_selection, &it)
348 || !(pcity = city_model_get(model, TREE_ITER_PTR(it)))) {
349 continue;
350 }
351
352 g_ptr_array_add(selected, pcity);
353 num_selected++;
354 }
355
356 data = (struct city **)g_ptr_array_free(selected, FALSE);
357 targets_used
358 = collect_production_targets(targets, data, num_selected, append_units,
359 append_wonders, TRUE, test_func);
360 g_free(data);
361 } else {
362 targets_used = collect_production_targets(targets, NULL, 0, append_units,
363 append_wonders, FALSE,
364 test_func);
365 }
366
367 name_and_sort_items(targets, targets_used, items,
368 city_operation != CO_NONE, NULL);
369
370 for (i = 0; i < 4; i++) {
371 row[i] = buf[i];
372 }
373
374
375 for (i = 0; i < 3; i++) {
376 size_group[i] = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
377 }
378
379 for (item = 0; item < targets_used; item++) {
380 struct universal target = items[item].item;
381 GMenuItem *menu_item;
382 char actbuf[256];
383 GSimpleAction *act;
384#ifdef MENUS_GTK3
385 char txt[256];
386 GtkWidget *hgrid, *label;
387 int grid_col = 0;
388#endif /* MENUS_GTK3 */
389
390 get_city_dialog_production_row(row, sizeof(buf[0]), &target, NULL);
391
392 fc_snprintf(actbuf, sizeof(actbuf), "win.%s%s%d", act_pfx, act_pfx2, item);
393
394 menu_item = g_menu_item_new(buf[0], actbuf);
395
396 fc_snprintf(actbuf, sizeof(actbuf), "%s%s%d", act_pfx, act_pfx2, item);
397 act = g_simple_action_new(actbuf, NULL);
398 g_object_set_data(G_OBJECT(act), "freeciv_test_func", test_func);
399 g_object_set_data(G_OBJECT(act), "freeciv_city_operation",
400 GINT_TO_POINTER(city_operation));
401 g_action_map_add_action(G_ACTION_MAP(act_group), G_ACTION(act));
402 g_signal_connect(act, "activate", callback,
403 GINT_TO_POINTER(cid_encode(target)));
404 menu_item_append_unref(menu, menu_item);
405
406#ifdef MENUS_GTK3
407 hgrid = gtk_grid_new();
408 gtk_grid_set_column_spacing(GTK_GRID(hgrid), 18);
409 gtk_container_add(GTK_CONTAINER(menu_item), hgrid);
410
411 for (i = 0; i < 3; i++) {
412 if (row[i][0] == '\0') {
413 continue;
414 }
415
416 if (city_operation == CO_SELL && i != 0) {
417 continue;
418 }
419
420 fc_snprintf(txt, ARRAY_SIZE(txt), "<span %s>%s</span>",
421 markup[i], row[i]);
422
423 label = gtk_label_new(NULL);
424 gtk_label_set_markup(GTK_LABEL(label), txt);
425
426 switch (i) {
427 case 0:
428 gtk_widget_set_halign(label, GTK_ALIGN_START);
429 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
430 break;
431 case 2:
432 gtk_widget_set_halign(label, GTK_ALIGN_END);
433 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
434 break;
435 default:
436 break;
437 }
438
439 gtk_grid_attach(GTK_GRID(hgrid), label, grid_col++, 0, 1, 1);
440 gtk_size_group_add_widget(size_group[i], label);
441 }
442
443 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
444 g_signal_connect(menu_item, "activate", callback,
445 GINT_TO_POINTER(cid_encode(target)));
446#endif /* MENUS_GTK3 */
447 }
448
449 for (i = 0; i < 3; i++) {
450 g_object_unref(size_group[i]);
451 }
452
453#ifdef MENUS_GTK3
454 gtk_widget_set_sensitive(GTK_WIDGET(parent_item), (targets_used > 0));
455#endif
456}
457
458/************************************************************************/
461 static void impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path,
462 GtkTreeIter *iter, gpointer data)
463{
464 struct universal target = cid_decode(GPOINTER_TO_INT(data));
465 struct city *pcity = city_model_get(model, iter);
466
467 if (NULL != pcity) {
468 city_change_production(pcity, &target);
469 }
470}
471
472/************************************************************************/
477 static void worklist_last_impr_or_unit_iterate(GtkTreeModel *model,
478 GtkTreePath *path,
479 GtkTreeIter *iter,
480 gpointer data)
481{
482 struct universal target = cid_decode(GPOINTER_TO_INT(data));
483 struct city *pcity = city_model_get(model, iter);
484
485 if (NULL != pcity) {
486 (void) city_queue_insert(pcity, -1, &target);
487 }
488 /* Perhaps should warn the user if not successful? */
489}
490
491/************************************************************************/
498 static void worklist_first_impr_or_unit_iterate(GtkTreeModel *model,
499 GtkTreePath *path,
500 GtkTreeIter *iter,
501 gpointer data)
502{
503 struct universal target = cid_decode(GPOINTER_TO_INT(data));
504 struct city *pcity = city_model_get(model, iter);
505
506 if (NULL != pcity) {
507 (void) city_queue_insert(pcity, 0, &target);
508 }
509 /* Perhaps should warn the user if not successful? */
510}
511
512/************************************************************************/
518 static void worklist_next_impr_or_unit_iterate(GtkTreeModel *model,
519 GtkTreePath *path,
520 GtkTreeIter *iter,
521 gpointer data)
522{
523 struct universal target = cid_decode(GPOINTER_TO_INT(data));
524 struct city *pcity = city_model_get(model, iter);
525
526 if (NULL != pcity) {
527 (void) city_queue_insert(pcity, 1, &target);
528 }
529 /* perhaps should warn the user if not successful? */
530}
531
532/************************************************************************/
537 static void worklist_next_to_last_impr_or_unit_iterate(GtkTreeModel *model,
538 GtkTreePath *path,
539 GtkTreeIter *iter,
540 gpointer data)
541{
542 struct universal target = cid_decode(GPOINTER_TO_INT(data));
543 struct city *pcity = city_model_get(model, iter);
544
545 if (NULL != pcity) {
546 city_queue_insert(pcity, worklist_length(&pcity->worklist), &target);
547 }
548}
549
550/************************************************************************/
553 static void sell_impr_iterate(GtkTreeModel *model, GtkTreePath *path,
554 GtkTreeIter *iter, gpointer data)
555{
556 struct sell_data *sd = (struct sell_data *) data;
557 struct city *pcity = city_model_get(model, iter);
558
559 if (NULL != pcity
560 && !pcity->did_sell
561 && city_has_building(pcity, sd->target)) {
562 sd->count++;
563 sd->gold += impr_sell_gold(sd->target);
564 city_sell_improvement(pcity, improvement_number(sd->target));
565 }
566}
567
568/************************************************************************/
572 static void select_impr_or_unit_callback(GSimpleAction *action,
573 GVariant *parameter,
574 gpointer data)
575{
576 struct universal target = cid_decode(GPOINTER_TO_INT(data));
577 TestCityFunc test_func = g_object_get_data(G_OBJECT(action), "freeciv_test_func");
578 enum city_operation_type city_operation =
579 GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "freeciv_city_operation"));
580
581 /* If this is not a city operation: */
582 if (city_operation == CO_NONE) {
583 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
584 ITree it;
585
586 gtk_tree_selection_unselect_all(city_selection);
587 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
588 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
589
590 if (NULL != pcity && test_func(pcity, &target)) {
591 itree_select(city_selection, &it);
592 }
593 }
594 } else {
595 GtkTreeSelectionForeachFunc foreach_func;
596
597 connection_do_buffer(&client.conn);
598 switch (city_operation) {
599 case CO_LAST:
600 gtk_tree_selection_selected_foreach(city_selection,
601 worklist_last_impr_or_unit_iterate,
602 GINT_TO_POINTER(cid_encode(target)));
603 break;
604 case CO_CHANGE:
605 gtk_tree_selection_selected_foreach(city_selection,
606 impr_or_unit_iterate,
607 GINT_TO_POINTER(cid_encode(target)));
608 break;
609 case CO_FIRST:
610 gtk_tree_selection_selected_foreach(city_selection,
611 worklist_first_impr_or_unit_iterate,
612 GINT_TO_POINTER(cid_encode(target)));
613 break;
614 case CO_NEXT:
615 gtk_tree_selection_selected_foreach(city_selection,
616 worklist_next_impr_or_unit_iterate,
617 GINT_TO_POINTER(cid_encode(target)));
618 break;
619 case CO_NEXT_TO_LAST:
620 foreach_func = worklist_next_to_last_impr_or_unit_iterate;
621 gtk_tree_selection_selected_foreach(city_selection, foreach_func,
622 GINT_TO_POINTER(cid_encode(target)));
623 break;
624 case CO_SELL:
625 fc_assert_action(target.kind == VUT_IMPROVEMENT, break);
626 {
627 const struct impr_type *building = target.value.building;
628 struct sell_data sd = { 0, 0, building };
629 GtkWidget *w;
630 gint res;
631 gchar *buf;
632 const char *imprname = improvement_name_translation(building);
633
634 /* Ask confirmation */
635 buf = g_strdup_printf(_("Are you sure you want to sell those %s?"), imprname);
636 w = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
637 GTK_MESSAGE_QUESTION,
638 GTK_BUTTONS_YES_NO, "%s", buf);
639 g_free(buf);
640 res = blocking_dialog(w); /* Synchron. */
641 gtk_window_destroy(GTK_WINDOW(w));
642 if (res == GTK_RESPONSE_NO) {
643 break;
644 }
645
646 gtk_tree_selection_selected_foreach(city_selection,
647 sell_impr_iterate, &sd);
648 if (sd.count > 0) {
649 /* FIXME: plurality of sd.count is ignored! */
650 /* TRANS: "Sold 3 Harbor for 90 gold." (Pluralisation is in gold --
651 * second %d -- not in buildings.) */
652 w = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
653 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
654 PL_("Sold %d %s for %d gold.",
655 "Sold %d %s for %d gold.",
656 sd.gold),
657 sd.count, imprname, sd.gold);
658 } else {
659 w = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
660 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
661 _("No %s could be sold."),
662 imprname);
663 }
664
665 g_signal_connect(w, "response",
666 G_CALLBACK(gtk_window_destroy), NULL);
667 gtk_window_present(GTK_WINDOW(w)); /* Asynchron. */
668 }
669 break;
670 case CO_NONE:
671 break;
672 }
673 connection_do_unbuffer(&client.conn);
674 }
675}
676
677/************************************************************************/
680 static void governors_iterate(GtkTreeModel *model, GtkTreePath *path,
681 GtkTreeIter *iter, gpointer data)
682{
683 struct city *pcity = city_model_get(model, iter);
684 int idx = GPOINTER_TO_INT(data);
685
686 if (NULL != pcity) {
687 if (CMA_NONE == idx) {
688 cma_release_city(pcity);
689 } else {
690 cma_put_city_under_agent(pcity, cmafec_preset_get_parameter(idx));
691 }
692 refresh_city_dialog(pcity);
693 }
694}
695
696/************************************************************************/
700 static void select_governor_callback(GSimpleAction *action,
701 GVariant *parameter,
702 gpointer data)
703{
704 int idx = GPOINTER_TO_INT(data);
705 bool change_governor =
706 GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "governor"));
707 struct cm_parameter cm;
708
709 /* If this is not the change button but the select cities button. */
710 if (!change_governor) {
711 ITree it;
712 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
713
714 gtk_tree_selection_unselect_all(city_selection);
715 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
716 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
717 int controlled;
718 bool select;
719
720 if (NULL == pcity) {
721 continue;
722 }
723 controlled = cma_is_city_under_agent(pcity, &cm);
724 select = FALSE;
725
726 if (idx == CMA_NONE) {
727 /* CMA_NONE selects not-controlled, all others require controlled */
728 if (!controlled) {
729 select = TRUE;
730 }
731 } else if (controlled) {
732 if (idx == CMA_CUSTOM) {
733 if (cmafec_preset_get_index_of_parameter(&cm) == -1) {
734 select = TRUE;
735 }
736 } else if (cm_are_parameter_equal(&cm,
737 cmafec_preset_get_parameter(idx))) {
738 select = TRUE;
739 }
740 }
741
742 if (select) {
743 itree_select(city_selection, &it);
744 }
745 }
746 } else {
747 gtk_tree_selection_selected_foreach(city_selection,
748 governors_iterate,
749 GINT_TO_POINTER(idx));
750 }
751}
752
753/************************************************************************/
759 static GMenu *create_governor_menu(GActionGroup *group,
760 bool change_governor)
761{
762 GMenu *menu;
763 int i;
764 struct cm_parameter cm;
765
766 menu = g_menu_new();
767
768 if (!can_client_issue_orders()) {
769 return menu;
770 }
771
772 if (change_governor) {
773 GSimpleAction *act;
774
775 act = g_simple_action_new("chg_governor_none", NULL);
776 g_object_set_data(G_OBJECT(act), "governor",
777 GINT_TO_POINTER(change_governor));
778 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
779 g_signal_connect(act, "activate", G_CALLBACK(select_governor_callback),
780 GINT_TO_POINTER(CMA_NONE));
781 menu_item_append_unref(menu,
782 g_menu_item_new(Q_("?cma:none"),
783 "win.chg_governor_none"));
784
785 for (i = 0; i < cmafec_preset_num(); i++) {
786 char buf[128];
787
788 fc_snprintf(buf, sizeof(buf), "chg_governor_%d", i);
789 act = g_simple_action_new(buf, NULL);
790 g_object_set_data(G_OBJECT(act), "governor",
791 GINT_TO_POINTER(change_governor));
792 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
793 g_signal_connect(act, "activate", G_CALLBACK(select_governor_callback),
794 GINT_TO_POINTER(i));
795 fc_snprintf(buf, sizeof(buf), "win.chg_governor_%d", i);
796 menu_item_append_unref(menu,
797 g_menu_item_new(cmafec_preset_get_descr(i), buf));
798 }
799 } else {
800 /* Search for a "none" */
801 bool found;
802
803 found = FALSE;
804 city_list_iterate(client.conn.playing->cities, pcity) {
805 if (!cma_is_city_under_agent(pcity, NULL)) {
806 found = TRUE;
807 break;
808 }
809 } city_list_iterate_end;
810
811 if (found) {
812 GSimpleAction *act;
813
814 act = g_simple_action_new("sel_governor_none", NULL);
815 g_object_set_data(G_OBJECT(act), "governor",
816 GINT_TO_POINTER(change_governor));
817 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
818 g_signal_connect(act, "activate", G_CALLBACK(select_governor_callback),
819 GINT_TO_POINTER(CMA_NONE));
820 menu_item_append_unref(menu,
821 g_menu_item_new(Q_("?cma:none"),
822 "win.sel_governor_none"));
823 }
824
825 /*
826 * Search for a city that's under custom (not preset) agent. Might
827 * take a lonnggg time.
828 */
829 found = FALSE;
830 city_list_iterate(client.conn.playing->cities, pcity) {
831 if (cma_is_city_under_agent(pcity, &cm)
832 && cmafec_preset_get_index_of_parameter(&cm) == -1) {
833 found = TRUE;
834 break;
835 }
836 } city_list_iterate_end;
837
838 if (found) {
839 /* We found city that's under agent but not a preset */
840 GSimpleAction *act;
841
842 act = g_simple_action_new("sel_governor_custom", NULL);
843 g_object_set_data(G_OBJECT(act), "governor",
844 GINT_TO_POINTER(change_governor));
845 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
846 g_signal_connect(act, "activate", G_CALLBACK(select_governor_callback),
847 GINT_TO_POINTER(CMA_CUSTOM));
848 menu_item_append_unref(menu,
849 g_menu_item_new(Q_("?cma:custom"),
850 "win.sel_governor_custom"));
851 }
852
853 /* Only fill in presets that are being used. */
854 for (i = 0; i < cmafec_preset_num(); i++) {
855 found = FALSE;
856 city_list_iterate(client.conn.playing->cities, pcity) {
857 if (cma_is_city_under_agent(pcity, &cm)
858 && cm_are_parameter_equal(&cm,
859 cmafec_preset_get_parameter(i))) {
860 found = TRUE;
861 break;
862 }
863 } city_list_iterate_end;
864
865 if (found) {
866 GSimpleAction *act;
867 char buf[128];
868
869 fc_snprintf(buf, sizeof(buf), "sel_governor_%d", i);
870
871 act = g_simple_action_new(buf, NULL);
872 g_object_set_data(G_OBJECT(act), "governor",
873 GINT_TO_POINTER(change_governor));
874 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
875 g_signal_connect(act, "activate", G_CALLBACK(select_governor_callback),
876 GINT_TO_POINTER(i));
877 fc_snprintf(buf, sizeof(buf), "win.sel_governor_%d", i);
878 menu_item_append_unref(menu,
879 g_menu_item_new(cmafec_preset_get_descr(i),
880 buf));
881 }
882 }
883 }
884
885 return menu;
886}
887
888/************************************************************************/
891 static void update_governor_menu(void)
892{
893 g_menu_remove(cityrep_menu, 1);
894 submenu_insert_unref(cityrep_menu, 1, _("Gover_nor"),
895 G_MENU_MODEL(create_governor_menu(cityrep_group, TRUE)));
896}
897
898/************************************************************************/
903 static void append_worklist_foreach(GtkTreeModel *model, GtkTreePath *path,
904 GtkTreeIter *iter, gpointer data)
905{
906 const struct worklist *pwl = data;
907 struct city *pcity = city_model_get(model, iter);
908
909 fc_assert_ret(pwl != NULL);
910
911 if (NULL != pcity) {
912 city_queue_insert_worklist(pcity, -1, pwl);
913 }
914}
915
916/************************************************************************/
921 static void append_worklist_callback(GSimpleAction *action,
922 GVariant *parameter,
923 gpointer data)
924{
925 struct global_worklist *pgwl =
926 global_worklist_by_id(GPOINTER_TO_INT(data));
927
928 fc_assert_ret(city_selection != NULL);
929
930 if (!pgwl) {
931 /* Maybe removed by an other way, not an error. */
932 return;
933 }
934
935 gtk_tree_selection_selected_foreach(city_selection,
936 append_worklist_foreach,
937 (gpointer) global_worklist_get(pgwl));
938}
939
940/************************************************************************/
944 static void set_worklist_foreach(GtkTreeModel *model, GtkTreePath *path,
945 GtkTreeIter *iter, gpointer data)
946{
947 const struct worklist *pwl = data;
948 struct city *pcity = city_model_get(model, iter);
949
950 fc_assert_ret(pwl != NULL);
951
952 if (NULL != pcity) {
953 city_set_queue(pcity, pwl);
954 }
955}
956
957/************************************************************************/
961 static void set_worklist_callback(GSimpleAction *action,
962 GVariant *parameter,
963 gpointer data)
964{
965 struct global_worklist *pgwl =
966 global_worklist_by_id(GPOINTER_TO_INT(data));
967
968 fc_assert_ret(city_selection != NULL);
969 gtk_tree_selection_selected_foreach(city_selection, set_worklist_foreach,
970 (gpointer) global_worklist_get(pgwl));
971
972 if (!pgwl) {
973 /* Maybe removed by an other way, not an error. */
974 return;
975 }
976
977 gtk_tree_selection_selected_foreach(city_selection,
978 set_worklist_foreach,
979 (gpointer) global_worklist_get(pgwl));
980}
981
982/************************************************************************/
985 static GMenu *create_wl_menu(GActionGroup *group, const char *act_pfx,
986 GCallback cb)
987{
988 GMenu *menu;
989 GSimpleAction *act;
990 int count = 0;
991
992 menu = g_menu_new();
993
994 if (!can_client_issue_orders()) {
995 return NULL;
996 }
997
998 global_worklists_iterate(pgwl) {
999 char buf[128];
1000
1001 fc_snprintf(buf, sizeof(buf), "wl%s%d", act_pfx, count);
1002 act = g_simple_action_new(buf, NULL);
1003 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1004 g_signal_connect(act, "activate", cb,
1005 GINT_TO_POINTER(global_worklist_id(pgwl)));
1006 fc_snprintf(buf, sizeof(buf), "win.wl%s%d", act_pfx, count);
1007 menu_item_append_unref(menu,
1008 g_menu_item_new(global_worklist_name(pgwl),
1009 buf));
1010 count++;
1011 } global_worklists_iterate_end;
1012
1013 if (count == 0) {
1014 char buf[64];
1015
1016 fc_snprintf(buf, sizeof(buf), "win.wl%s_dummy", act_pfx);
1017 menu_item_append_unref(menu,
1018 g_menu_item_new(_("(no worklists defined)"), buf));
1019 }
1020
1021 return menu;
1022}
1023
1024/************************************************************************/
1027 static void city_report_update_views(void)
1028{
1029 struct city_report_spec *spec;
1030 GtkTreeView *view;
1031 GtkTreeViewColumn *col;
1032 GList *columns, *p;
1033
1034 view = GTK_TREE_VIEW(city_view);
1035 fc_assert_ret(view != NULL);
1036
1037 columns = gtk_tree_view_get_columns(view);
1038
1039 for (p = columns; p != NULL; p = p->next) {
1040 col = p->data;
1041 spec = g_object_get_data(G_OBJECT(col), "city_report_spec");
1042 gtk_tree_view_column_set_visible(col, spec->show);
1043 }
1044
1045 g_list_free(columns);
1046}
1047
1048/************************************************************************/
1052 static GMenuItem *create_display_menu_item(int pos)
1053{
1054 GMenuItem *item;
1055 char act_name[50];
1056 struct city_report_spec *spec = city_report_specs + pos;
1057
1058 fc_snprintf(act_name, sizeof(act_name), "win.display%d(%s)",
1059 pos, spec->show ? "true" : "false");
1060 item = g_menu_item_new(spec->explanation, NULL);
1061 g_menu_item_set_detailed_action(item, act_name);
1062
1063 return item;
1064}
1065
1066/************************************************************************/
1069 static void toggle_view(GSimpleAction *act, GVariant *value, gpointer data)
1070{
1071 struct city_report_spec *spec = data;
1072 int idx = spec - city_report_specs;
1073
1074 spec->show ^= 1;
1075 city_report_update_views();
1076
1077 g_menu_remove(display_menu, idx);
1078 menu_item_insert_unref(display_menu, idx, create_display_menu_item(idx));
1079}
1080
1081/************************************************************************/
1084 static GMenu *create_display_menu(GActionGroup *group)
1085{
1086 struct city_report_spec *spec;
1087 int i;
1088 GVariantType *bvart = g_variant_type_new("b");
1089
1090 display_menu = g_menu_new();
1091 for (i = 0, spec = city_report_specs; i < NUM_CREPORT_COLS; i++, spec++) {
1092 GSimpleAction *act;
1093 char act_name[50];
1094 GVariant *var = g_variant_new("b", TRUE);
1095
1096 fc_snprintf(act_name, sizeof(act_name), "display%d", i);
1097 act = g_simple_action_new_stateful(act_name, bvart, var);
1098 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1099 g_signal_connect(act, "change-state", G_CALLBACK(toggle_view), (gpointer)spec);
1100
1101 menu_item_insert_unref(display_menu, i, create_display_menu_item(i));
1102 }
1103
1104 g_variant_type_free(bvart);
1105
1106 return display_menu;
1107}
1108
1109/************************************************************************/
1112 static GtkWidget *create_city_report_menu(void)
1113{
1114 GtkWidget *vbox, *sep;
1115 GtkWidget *aux_menu;
1116 GMenu *submenu;
1117
1118 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1119 sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
1120 gtk_box_append(GTK_BOX(vbox), sep);
1121
1122 aux_menu = aux_menu_new();
1123 cityrep_group = G_ACTION_GROUP(g_simple_action_group_new());
1124
1125 cityrep_menu = g_menu_new();
1126
1127 /* Placeholder */
1128 submenu_append_unref(cityrep_menu, _("_Production"),
1129 G_MENU_MODEL(g_menu_new()));
1130
1131 submenu_append_unref(cityrep_menu, _("Gover_nor"),
1132 G_MENU_MODEL(create_governor_menu(cityrep_group, TRUE)));
1133
1134 /* Placeholders */
1135 submenu_append_unref(cityrep_menu, _("S_ell"), G_MENU_MODEL(g_menu_new()));
1136 submenu_append_unref(cityrep_menu, _("_Select"), G_MENU_MODEL(g_menu_new()));
1137
1138 submenu = create_display_menu(cityrep_group);
1139 submenu_append_unref(cityrep_menu, _("_Display"), G_MENU_MODEL(submenu));
1140
1141 gtk_widget_insert_action_group(aux_menu, "win", cityrep_group);
1142 gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(aux_menu), G_MENU_MODEL(cityrep_menu));
1143 gtk_box_append(GTK_BOX(vbox), aux_menu);
1144
1145 return vbox;
1146}
1147
1148/************************************************************************/
1151 static gint cityrep_sort_func(GtkTreeModel *model, GtkTreeIter *a,
1152 GtkTreeIter *b, gpointer data)
1153{
1154 gint col = GPOINTER_TO_INT(data);
1155 const gchar *str1, *str2;
1156
1157 gtk_tree_model_get(model, a, col, &str1, -1);
1158 gtk_tree_model_get(model, b, col, &str2, -1);
1159
1160 return cityrepfield_compare(str1, str2);
1161}
1162
1163/************************************************************************/
1166 static void create_city_report_dialog(bool make_modal)
1167{
1168 static char **titles;
1169 static char (*buf)[128];
1170 struct city_report_spec *spec;
1171
1172 GtkWidget *w, *sw, *aux_menu;
1173 int i;
1174
1175 gui_dialog_new(&city_dialog_shell, GTK_NOTEBOOK(top_notebook), NULL, TRUE);
1176 gui_dialog_set_title(city_dialog_shell, _("Cities"));
1177
1178 gui_dialog_set_default_size(city_dialog_shell, -1, 420);
1179
1180 gui_dialog_response_set_callback(city_dialog_shell,
1181 city_command_callback);
1182
1183 /* Menu */
1184 aux_menu = create_city_report_menu();
1185 gui_dialog_add_action_widget(city_dialog_shell, aux_menu);
1186
1187 /* Buttons */
1188 city_total_buy_cost_label = gtk_label_new(NULL);
1189 gtk_widget_set_hexpand(city_total_buy_cost_label, TRUE);
1190 gtk_label_set_ellipsize(GTK_LABEL(city_total_buy_cost_label),
1191 PANGO_ELLIPSIZE_START);
1192 gui_dialog_add_action_widget(city_dialog_shell,
1193 city_total_buy_cost_label);
1194
1195 w = gui_dialog_add_button(city_dialog_shell, NULL,
1196 _("_Buy"), CITY_BUY);
1197 city_buy_command = w;
1198
1199 w = gui_dialog_add_button(city_dialog_shell, NULL,
1200 _("_Inspect"), CITY_POPUP);
1201 city_popup_command = w;
1202
1203 w = gui_dialog_add_button(city_dialog_shell, NULL,
1204 _("Cen_ter"), CITY_CENTER);
1205 city_center_command = w;
1206
1207 /* Tree view */
1208 buf = fc_realloc(buf, NUM_CREPORT_COLS * sizeof(buf[0]));
1209 titles = fc_realloc(titles, NUM_CREPORT_COLS * sizeof(titles[0]));
1210 for (i = 0; i < NUM_CREPORT_COLS; i++) {
1211 titles[i] = buf[i];
1212 }
1213 get_city_table_header(titles, sizeof(buf[0]));
1214
1215 city_model = city_report_dialog_store_new();
1216
1217 city_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(city_model));
1218 gtk_widget_set_hexpand(city_view, TRUE);
1219 gtk_widget_set_vexpand(city_view, TRUE);
1220 g_object_unref(city_model);
1221 gtk_widget_set_name(city_view, "small_font");
1222 g_signal_connect(city_view, "row_activated",
1223 G_CALLBACK(city_activated_callback), NULL);
1224 city_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(city_view));
1225 gtk_tree_selection_set_mode(city_selection, GTK_SELECTION_MULTIPLE);
1226 g_signal_connect(city_selection, "changed",
1227 G_CALLBACK(city_selection_changed_callback), NULL);
1228
1229 for (i = 0, spec = city_report_specs; i < NUM_CREPORT_COLS; i++, spec++) {
1230 GtkWidget *header;
1231 GtkCellRenderer *renderer;
1232 GtkTreeViewColumn *col;
1233
1234 renderer = gtk_cell_renderer_text_new();
1235 col = gtk_tree_view_column_new_with_attributes(NULL, renderer,
1236 "text", i, NULL);
1237 header = gtk_label_new(titles[i]);
1238 gtk_widget_set_tooltip_text(header, spec->explanation);
1239 gtk_widget_show(header);
1240 gtk_tree_view_column_set_widget(col, header);
1241 gtk_tree_view_column_set_visible(col, spec->show);
1242 gtk_tree_view_column_set_sort_column_id(col, i);
1243 gtk_tree_view_column_set_reorderable(col, TRUE);
1244 g_object_set_data(G_OBJECT(col), "city_report_spec", spec);
1245 gtk_tree_view_append_column(GTK_TREE_VIEW(city_view), col);
1246 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(city_model), i,
1247 cityrep_sort_func, GINT_TO_POINTER(i),
1248 NULL);
1249 }
1250
1251 sw = gtk_scrolled_window_new();
1252 gtk_scrolled_window_set_has_frame(GTK_SCROLLED_WINDOW(sw), TRUE);
1253 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
1254 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
1255 gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(sw), city_view);
1256
1257 gui_dialog_add_content_widget(city_dialog_shell, sw);
1258
1259 city_model_fill(city_model, NULL, NULL);
1260 gui_dialog_show_all(city_dialog_shell);
1261
1262 /* Real menus */
1263 recreate_production_menu(cityrep_group);
1264 recreate_select_menu(cityrep_group);
1265 recreate_sell_menu(cityrep_group);
1266
1267 city_selection_changed_callback(city_selection);
1268}
1269
1270/************************************************************************/
1273 static void city_select_all_callback(GSimpleAction *action,
1274 GVariant *parameter,
1275 gpointer data)
1276{
1277 gtk_tree_selection_select_all(city_selection);
1278}
1279
1280/************************************************************************/
1283 static void city_unselect_all_callback(GSimpleAction *action,
1284 GVariant *parameter,
1285 gpointer data)
1286{
1287 gtk_tree_selection_unselect_all(city_selection);
1288}
1289
1290/************************************************************************/
1293 static void city_invert_selection_callback(GSimpleAction *action,
1294 GVariant *parameter,
1295 gpointer data)
1296{
1297 ITree it;
1298 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
1299
1300 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
1301 if (itree_is_selected(city_selection, &it)) {
1302 itree_unselect(city_selection, &it);
1303 } else {
1304 itree_select(city_selection, &it);
1305 }
1306 }
1307}
1308
1309/************************************************************************/
1312 static void city_select_coastal_callback(GSimpleAction *action,
1313 GVariant *parameter,
1314 gpointer data)
1315{
1316 ITree it;
1317 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
1318
1319 gtk_tree_selection_unselect_all(city_selection);
1320
1321 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
1322 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
1323
1324 if (pcity != NULL
1325 && is_terrain_class_near_tile(&(wld.map), pcity->tile, TC_OCEAN)) {
1326 itree_select(city_selection, &it);
1327 }
1328 }
1329}
1330
1331/************************************************************************/
1334 static void same_island_iterate(GtkTreeModel *model, GtkTreePath *path,
1335 GtkTreeIter *iter, gpointer data)
1336{
1337 struct city *selected_pcity = city_model_get(model, iter);
1338 ITree it;
1339
1340 if (NULL == selected_pcity) {
1341 return;
1342 }
1343
1344 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
1345 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
1346
1347 if (NULL != pcity
1348 && (tile_continent(pcity->tile)
1349 == tile_continent(selected_pcity->tile))) {
1350 itree_select(city_selection, &it);
1351 }
1352 }
1353}
1354
1355/************************************************************************/
1358 static void city_select_island_callback(GSimpleAction *action,
1359 GVariant *parameter,
1360 gpointer data)
1361{
1362 gtk_tree_selection_selected_foreach(city_selection,
1363 same_island_iterate, NULL);
1364}
1365
1366/************************************************************************/
1369 static void city_select_building_callback(GSimpleAction *action,
1370 GVariant *parameter,
1371 gpointer data)
1372{
1373 enum production_class_type which = GPOINTER_TO_INT(data);
1374 ITree it;
1375 GtkTreeModel *model = GTK_TREE_MODEL(city_model);
1376
1377 gtk_tree_selection_unselect_all(city_selection);
1378
1379 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
1380 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
1381
1382 if (NULL != pcity
1383 && ((which == PCT_UNIT && VUT_UTYPE == pcity->production.kind)
1384 || (which == PCT_NORMAL_IMPROVEMENT
1385 && VUT_IMPROVEMENT == pcity->production.kind
1386 && !is_wonder(pcity->production.value.building))
1387 || (which == PCT_WONDER
1388 && VUT_IMPROVEMENT == pcity->production.kind
1389 && is_wonder(pcity->production.value.building)))) {
1390 itree_select(city_selection, &it);
1391 }
1392 }
1393}
1394
1395/************************************************************************/
1398 static void buy_iterate(GtkTreeModel *model, GtkTreePath *path,
1399 GtkTreeIter *iter, gpointer data)
1400{
1401 struct city *pcity = city_model_get(model, iter);
1402
1403 if (NULL != pcity) {
1404 cityrep_buy(pcity);
1405 }
1406}
1407
1408/************************************************************************/
1411 static void center_iterate(GtkTreeModel *model, GtkTreePath *path,
1412 GtkTreeIter *iter, gpointer data)
1413{
1414 struct city *pcity = city_model_get(model, iter);
1415
1416 if (NULL != pcity) {
1417 center_tile_mapcanvas(pcity->tile);
1418 }
1419}
1420
1421/************************************************************************/
1424 static void popup_iterate(GtkTreeModel *model, GtkTreePath *path,
1425 GtkTreeIter *iter, gpointer data)
1426{
1427 struct city *pcity = city_model_get(model, iter);
1428
1429 if (NULL != pcity) {
1430 if (gui_options.center_when_popup_city) {
1431 center_tile_mapcanvas(pcity->tile);
1432 }
1433 popup_city_dialog(pcity);
1434 }
1435}
1436
1437/************************************************************************/
1440 static void city_command_callback(struct gui_dialog *dlg, int response,
1441 gpointer data)
1442{
1443 switch (response) {
1444 case CITY_CENTER:
1445 if (1 == gtk_tree_selection_count_selected_rows(city_selection)) {
1446 /* Center to city doesn't make sense if many city are selected. */
1447 gtk_tree_selection_selected_foreach(city_selection, center_iterate,
1448 NULL);
1449 }
1450 break;
1451 case CITY_POPUP:
1452 gtk_tree_selection_selected_foreach(city_selection, popup_iterate, NULL);
1453 break;
1454 case CITY_BUY:
1455 gtk_tree_selection_selected_foreach(city_selection, buy_iterate, NULL);
1456 break;
1457 default:
1458 gui_dialog_destroy(dlg);
1459 break;
1460 }
1461}
1462
1463/************************************************************************/
1466 static void city_activated_callback(GtkTreeView *view, GtkTreePath *path,
1467 GtkTreeViewColumn *col, gpointer data)
1468{
1469 GtkTreeModel *model;
1470 GtkTreeIter iter;
1471 GdkSurface *win;
1472 GdkSeat *seat;
1473 GdkModifierType mask;
1474
1475 model = gtk_tree_view_get_model(view);
1476
1477 if (!gtk_tree_model_get_iter(model, &iter, path)) {
1478 return;
1479 }
1480
1481 win = gtk_native_get_surface(gtk_widget_get_native(GTK_WIDGET(view)));
1482 seat = gdk_display_get_default_seat(gdk_surface_get_display(win));
1483
1484 gdk_surface_get_device_position(win, gdk_seat_get_pointer(seat),
1485 NULL, NULL, &mask);
1486
1487 if (!(mask & GDK_CONTROL_MASK)) {
1488 popup_iterate(model, path, &iter, NULL);
1489 } else {
1490 center_iterate(model, path, &iter, NULL);
1491 }
1492}
1493
1494/************************************************************************/
1497 void real_city_report_dialog_update(void *unused)
1498{
1499 GHashTable *selected;
1500 ITree iter;
1501 gint city_id;
1502
1503 if (NULL == city_dialog_shell) {
1504 return;
1505 }
1506
1507 /* Save the selection. */
1508 selected = g_hash_table_new(NULL, NULL);
1509 for (itree_begin(GTK_TREE_MODEL(city_model), &iter);
1510 !itree_end(&iter); itree_next(&iter)) {
1511 if (itree_is_selected(city_selection, &iter)) {
1512 itree_get(&iter, CRD_COL_CITY_ID, &city_id, -1);
1513 g_hash_table_insert(selected, GINT_TO_POINTER(city_id), NULL);
1514 }
1515 }
1516
1517 /* Update and restore the selection. */
1518 gtk_list_store_clear(city_model);
1519 city_model_fill(city_model, city_selection, selected);
1520 g_hash_table_destroy(selected);
1521
1522 update_governor_menu();
1523}
1524
1525/************************************************************************/
1528 void real_city_report_update_city(struct city *pcity)
1529{
1530 GtkTreeIter iter;
1531
1532 if (NULL == city_dialog_shell) {
1533 return;
1534 }
1535
1536 if (!city_model_find(GTK_TREE_MODEL(city_model), &iter, pcity)) {
1537 gtk_list_store_prepend(city_model, &iter);
1538 }
1539 city_model_set(city_model, &iter, pcity);
1540
1541 update_total_buy_cost();
1542}
1543
1544/************************************************************************/
1553 static GMenu *create_change_menu(GActionGroup *group, const char *mname,
1554 const char *human_mname,
1555 enum city_operation_type oper)
1556{
1557 GMenu *menu = g_menu_new();
1558 GMenu *submenu;
1559 int n;
1560 char buf[128];
1561
1562 n = gtk_tree_selection_count_selected_rows(city_selection);
1563
1564 submenu = g_menu_new();
1565 append_impr_or_unit_to_menu(submenu, group, mname, "_u",
1566 TRUE, FALSE, oper,
1567 can_city_build_now,
1568 G_CALLBACK(select_impr_or_unit_callback), n);
1569 fc_snprintf(buf, sizeof(buf), human_mname, _("Unit"));
1570 submenu_append_unref(menu, buf, G_MENU_MODEL(submenu));
1571
1572 submenu = g_menu_new();
1573 append_impr_or_unit_to_menu(submenu, group, mname, "_i",
1574 FALSE, FALSE, oper,
1575 can_city_build_now,
1576 G_CALLBACK(select_impr_or_unit_callback), n);
1577 fc_snprintf(buf, sizeof(buf), human_mname, _("Improvement"));
1578 submenu_append_unref(menu, buf, G_MENU_MODEL(submenu));
1579
1580 submenu = g_menu_new();
1581 append_impr_or_unit_to_menu(submenu, group, mname, "_w",
1582 FALSE, TRUE, oper,
1583 can_city_build_now,
1584 G_CALLBACK(select_impr_or_unit_callback), n);
1585 fc_snprintf(buf, sizeof(buf), human_mname, _("Wonder"));
1586 submenu_append_unref(menu, buf, G_MENU_MODEL(submenu));
1587
1588 return menu;
1589}
1590
1591/************************************************************************/
1594 static void recreate_sell_menu(GActionGroup *group)
1595{
1596 int n;
1597 GMenu *menu = g_menu_new();
1598
1599 n = gtk_tree_selection_count_selected_rows(city_selection);
1600
1601 append_impr_or_unit_to_menu(menu, group, "sell", "",
1602 FALSE, FALSE, CO_SELL,
1603 can_city_sell_universal,
1604 G_CALLBACK(select_impr_or_unit_callback),
1605 n);
1606
1607 g_menu_remove(cityrep_menu, 2);
1608 submenu_insert_unref(cityrep_menu, 2, _("S_ell"), G_MENU_MODEL(menu));
1609}
1610
1611/************************************************************************/
1614 static GMenu *create_production_menu(GActionGroup *group)
1615{
1616 GSimpleAction *act;
1617
1618 prod_menu = g_menu_new();
1619
1620 /* TRANS: Menu name part to be used like "Change to Improvement"
1621 * This is about changing current production. */
1622 change_menu = create_change_menu(group, "change", _("Change to %s"), CO_CHANGE);
1623 submenu_append_unref(prod_menu, _("Chan_ge"), G_MENU_MODEL(change_menu));
1624
1625 add_first_menu = g_menu_new();
1626
1627 /* TRANS: Menu name to be used like "Set Improvement first"
1628 * This is about adding item to the beginning of the worklist. */
1629 add_first_menu = create_change_menu(group, "first", _("Set %s first"), CO_FIRST);
1630 submenu_append_unref(prod_menu, _("Add _First"),
1631 G_MENU_MODEL(add_first_menu));
1632
1633 add_last_menu = g_menu_new();
1634
1635 /* TRANS: Menu name to be used like "Set Improvement last"
1636 * This is about adding item to the end of the worklist. */
1637 add_last_menu = create_change_menu(group, "last", _("Set %s last"), CO_LAST);
1638 submenu_append_unref(prod_menu, _("Add _Last"),
1639 G_MENU_MODEL(add_last_menu));
1640
1641 add_next_menu = g_menu_new();
1642
1643 /* TRANS: Menu name to be used like "Set Improvement next"
1644 * This is about adding item after current one on the worklist. */
1645 add_next_menu = create_change_menu(group, "next", _("Set %s next"), CO_NEXT);
1646 submenu_append_unref(prod_menu, _("Add _Next"),
1647 G_MENU_MODEL(add_next_menu));
1648
1649 add_2ndlast_menu = g_menu_new();
1650
1651 /* TRANS: Menu name to be used like "Set Improvement 2nd last"
1652 * This is about adding item as second last on the worklist. */
1653 add_2ndlast_menu = create_change_menu(group, "2ndlast", _("Set %s 2nd last"), CO_NEXT_TO_LAST);
1654 submenu_append_unref(prod_menu, _("Add _2nd Last"),
1655 G_MENU_MODEL(add_2ndlast_menu));
1656
1657 wl_set_menu = create_wl_menu(group, "set", G_CALLBACK(set_worklist_callback));
1658 submenu_append_unref(prod_menu, _("Set Worklist"),
1659 G_MENU_MODEL(wl_set_menu));
1660
1661 wl_append_menu = create_wl_menu(group, "append", G_CALLBACK(append_worklist_callback));
1662 submenu_append_unref(prod_menu, _("Append Worklist"),
1663 G_MENU_MODEL(wl_append_menu));
1664
1665 act = g_simple_action_new("clear_worklist", NULL);
1666 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1667 g_signal_connect(act, "activate", G_CALLBACK(city_clear_worklist_callback),
1668 NULL);
1669 menu_item_append_unref(prod_menu, g_menu_item_new(_("Clear _Worklist"),
1670 "win.clear_worklist"));
1671
1672 return prod_menu;
1673}
1674
1675/************************************************************************/
1678 static void recreate_production_menu(GActionGroup *group)
1679{
1680 if (prod_menu != NULL) {
1681 g_menu_remove_all(change_menu);
1682 g_menu_remove_all(add_first_menu);
1683 g_menu_remove_all(add_last_menu);
1684 g_menu_remove_all(add_next_menu);
1685 g_menu_remove_all(add_2ndlast_menu);
1686 g_menu_remove_all(wl_set_menu);
1687 g_menu_remove_all(wl_append_menu);
1688 g_menu_remove_all(prod_menu);
1689 }
1690 g_menu_remove(cityrep_menu, 0);
1691 submenu_insert_unref(cityrep_menu, 0, _("_Production"),
1692 G_MENU_MODEL(create_production_menu(group)));
1693}
1694
1695/************************************************************************/
1698 static bool city_building_impr_or_unit(const struct city *pcity,
1699 const struct universal *target)
1700{
1701 return are_universals_equal(&pcity->production, target);
1702}
1703
1704/************************************************************************/
1707 static GMenu *create_select_menu(GActionGroup *group)
1708{
1709 GSimpleAction *act;
1710 char buf[128];
1711
1712 select_menu = g_menu_new();
1713
1714#if 0
1715 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
1716 g_signal_connect(menu, "show", G_CALLBACK(popup_select_menu), NULL);
1717#endif
1718
1719 act = g_simple_action_new("select_all", NULL);
1720 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1721 g_signal_connect(act, "activate", G_CALLBACK(city_select_all_callback),
1722 NULL);
1723 menu_item_append_unref(select_menu, g_menu_item_new(_("All Cities"),
1724 "win.select_all"));
1725
1726 act = g_simple_action_new("select_none", NULL);
1727 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1728 g_signal_connect(act, "activate", G_CALLBACK(city_unselect_all_callback),
1729 NULL);
1730 menu_item_append_unref(select_menu, g_menu_item_new(_("No Cities"),
1731 "win.select_none"));
1732
1733 act = g_simple_action_new("select_invert", NULL);
1734 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1735 g_signal_connect(act, "activate", G_CALLBACK(city_invert_selection_callback),
1736 NULL);
1737 menu_item_append_unref(select_menu, g_menu_item_new(_("Invert Selection"),
1738 "win.select_invert"));
1739
1740 act = g_simple_action_new("select_build_unit", NULL);
1741 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1742 g_signal_connect(act, "activate", G_CALLBACK(city_select_building_callback),
1743 GINT_TO_POINTER(PCT_UNIT));
1744 menu_item_append_unref(select_menu, g_menu_item_new(_("Building Units"),
1745 "win.select_build_unit"));
1746
1747 act = g_simple_action_new("select_build_impr", NULL);
1748 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1749 g_signal_connect(act, "activate", G_CALLBACK(city_select_building_callback),
1750 GINT_TO_POINTER(PCT_NORMAL_IMPROVEMENT));
1751 menu_item_append_unref(select_menu, g_menu_item_new(_("Building Improvements"),
1752 "win.select_build_impr"));
1753
1754 act = g_simple_action_new("select_build_wonder", NULL);
1755 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1756 g_signal_connect(act, "activate", G_CALLBACK(city_select_building_callback),
1757 GINT_TO_POINTER(PCT_WONDER));
1758 menu_item_append_unref(select_menu, g_menu_item_new(_("Building Wonders"),
1759 "win.select_build_wonder"));
1760
1761 unit_b_select_menu = g_menu_new();
1762 append_impr_or_unit_to_menu(unit_b_select_menu, group, "sel", "_b_u",
1763 TRUE, FALSE, CO_NONE,
1764 city_building_impr_or_unit,
1765 G_CALLBACK(select_impr_or_unit_callback), -1);
1766 fc_snprintf(buf, sizeof(buf), _("Building %s"), _("Unit"));
1767 submenu_append_unref(select_menu, buf, G_MENU_MODEL(unit_b_select_menu));
1768
1769 impr_b_select_menu = g_menu_new();
1770 append_impr_or_unit_to_menu(impr_b_select_menu, group, "sel", "_b_b",
1771 FALSE, FALSE, CO_NONE,
1772 city_building_impr_or_unit,
1773 G_CALLBACK(select_impr_or_unit_callback), -1);
1774 fc_snprintf(buf, sizeof(buf), _("Building %s"), _("Improvement"));
1775 submenu_append_unref(select_menu, buf, G_MENU_MODEL(impr_b_select_menu));
1776
1777 wndr_b_select_menu = g_menu_new();
1778 append_impr_or_unit_to_menu(wndr_b_select_menu, group, "sel", "_b_w",
1779 FALSE, TRUE, CO_NONE,
1780 city_building_impr_or_unit,
1781 G_CALLBACK(select_impr_or_unit_callback), -1);
1782 fc_snprintf(buf, sizeof(buf), _("Building %s"), _("Wonder"));
1783 submenu_append_unref(select_menu, buf, G_MENU_MODEL(wndr_b_select_menu));
1784
1785 act = g_simple_action_new("select_coastal", NULL);
1786 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1787 g_signal_connect(act, "activate", G_CALLBACK(city_select_coastal_callback),
1788 NULL);
1789 menu_item_append_unref(select_menu, g_menu_item_new(_("Coastal Cities"),
1790 "win.select_coastal"));
1791
1792 act = g_simple_action_new("select_island", NULL);
1793 g_action_map_add_action(G_ACTION_MAP(group), G_ACTION(act));
1794 g_signal_connect(act, "activate", G_CALLBACK(city_select_island_callback),
1795 NULL);
1796 menu_item_append_unref(select_menu, g_menu_item_new(_("Same Island"),
1797 "win.select_island"));
1798
1799 unit_s_select_menu = g_menu_new();
1800 append_impr_or_unit_to_menu(unit_s_select_menu, group, "sel", "_s_u",
1801 TRUE, FALSE, CO_NONE,
1802 city_unit_supported,
1803 G_CALLBACK(select_impr_or_unit_callback), -1);
1804 fc_snprintf(buf, sizeof(buf), _("Supported %s"), _("Unit"));
1805 submenu_append_unref(select_menu, buf, G_MENU_MODEL(unit_s_select_menu));
1806
1807 unit_p_select_menu = g_menu_new();
1808 append_impr_or_unit_to_menu(unit_p_select_menu, group, "sel", "_p_u",
1809 TRUE, FALSE, CO_NONE,
1810 city_unit_present,
1811 G_CALLBACK(select_impr_or_unit_callback), -1);
1812 fc_snprintf(buf, sizeof(buf), _("Present %s"), _("Unit"));
1813 submenu_append_unref(select_menu, buf, G_MENU_MODEL(unit_p_select_menu));
1814
1815 impr_p_select_menu = g_menu_new();
1816 append_impr_or_unit_to_menu(impr_p_select_menu, group, "sel", "_p_b",
1817 FALSE, FALSE, CO_NONE,
1818 city_building_present,
1819 G_CALLBACK(select_impr_or_unit_callback), -1);
1820 fc_snprintf(buf, sizeof(buf), _("Present %s"), _("Improvement"));
1821 submenu_append_unref(select_menu, buf, G_MENU_MODEL(impr_p_select_menu));
1822
1823 wndr_p_select_menu = g_menu_new();
1824 append_impr_or_unit_to_menu(wndr_p_select_menu, group, "sel", "_p_w",
1825 FALSE, TRUE, CO_NONE,
1826 city_building_present,
1827 G_CALLBACK(select_impr_or_unit_callback), -1);
1828 fc_snprintf(buf, sizeof(buf), _("Present %s"), _("Wonder"));
1829 submenu_append_unref(select_menu, buf, G_MENU_MODEL(wndr_p_select_menu));
1830
1831 unit_a_select_menu = g_menu_new();
1832 append_impr_or_unit_to_menu(unit_a_select_menu, group, "sel", "_a_u",
1833 TRUE, FALSE, CO_NONE,
1834 can_city_build_now,
1835 G_CALLBACK(select_impr_or_unit_callback), -1);
1836 fc_snprintf(buf, sizeof(buf), _("Available %s"), _("Unit"));
1837 submenu_append_unref(select_menu, buf, G_MENU_MODEL(unit_a_select_menu));
1838
1839 impr_a_select_menu = g_menu_new();
1840 append_impr_or_unit_to_menu(impr_a_select_menu, group, "sel", "_a_b",
1841 FALSE, FALSE, CO_NONE,
1842 can_city_build_now,
1843 G_CALLBACK(select_impr_or_unit_callback), -1);
1844 fc_snprintf(buf, sizeof(buf), _("Available %s"), _("Improvement"));
1845 submenu_append_unref(select_menu, buf, G_MENU_MODEL(impr_a_select_menu));
1846
1847 wndr_a_select_menu = g_menu_new();
1848 append_impr_or_unit_to_menu(wndr_a_select_menu, group, "sel", "_a_w",
1849 FALSE, TRUE, CO_NONE,
1850 can_city_build_now,
1851 G_CALLBACK(select_impr_or_unit_callback), -1);
1852 fc_snprintf(buf, sizeof(buf), _("Available %s"), _("Wonder"));
1853 submenu_append_unref(select_menu, buf, G_MENU_MODEL(wndr_a_select_menu));
1854
1855 governor_select_menu = create_governor_menu(cityrep_group, FALSE);
1856 submenu_append_unref(select_menu, _("Citizen Governor"),
1857 G_MENU_MODEL(governor_select_menu));
1858
1859 return select_menu;
1860}
1861
1862/************************************************************************/
1865 static void recreate_select_menu(GActionGroup *group)
1866{
1867 if (unit_b_select_menu != NULL) {
1868 g_menu_remove_all(unit_b_select_menu);
1869 g_menu_remove_all(impr_b_select_menu);
1870 g_menu_remove_all(wndr_b_select_menu);
1871 g_menu_remove_all(unit_s_select_menu);
1872 g_menu_remove_all(unit_p_select_menu);
1873 g_menu_remove_all(impr_p_select_menu);
1874 g_menu_remove_all(wndr_p_select_menu);
1875 g_menu_remove_all(unit_a_select_menu);
1876 g_menu_remove_all(impr_a_select_menu);
1877 g_menu_remove_all(wndr_a_select_menu);
1878 g_menu_remove_all(governor_select_menu);
1879 g_menu_remove_all(select_menu);
1880 }
1881 g_menu_remove(cityrep_menu, 3);
1882 submenu_insert_unref(cityrep_menu, 3, _("_Select"),
1883 G_MENU_MODEL(create_select_menu(group)));
1884}
1885
1886/************************************************************************/
1890 static void update_total_buy_cost(void)
1891{
1892 GtkWidget *label, *view;
1893 GList *rows, *p;
1894 GtkTreeModel *model;
1895 GtkTreeSelection *sel;
1896 GtkTreePath *path;
1897 GtkTreeIter iter;
1898 struct city *pcity;
1899 int total = 0;
1900
1901 view = city_view;
1902 label = city_total_buy_cost_label;
1903
1904 if (!view || !label) {
1905 return;
1906 }
1907
1908 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
1909 rows = gtk_tree_selection_get_selected_rows(sel, &model);
1910
1911 for (p = rows; p != NULL; p = p->next) {
1912 path = p->data;
1913 if (gtk_tree_model_get_iter(model, &iter, path)) {
1914 if ((pcity = city_model_get(model, &iter))) {
1915 total += pcity->client.buy_cost;
1916 }
1917 }
1918 gtk_tree_path_free(path);
1919 }
1920 g_list_free(rows);
1921
1922 if (total > 0) {
1923 gchar *buf = g_strdup_printf(_("Total Buy Cost: %d"), total);
1924
1925 gtk_label_set_text(GTK_LABEL(label), buf);
1926 g_free(buf);
1927 } else {
1928 gtk_label_set_text(GTK_LABEL(label), NULL);
1929 }
1930}
1931
1932/************************************************************************/
1936 static void city_selection_changed_callback(GtkTreeSelection *selection)
1937{
1938#ifdef MENUS_GTK3
1939 int n;
1940 bool obs_may, plr_may;
1941
1942 n = gtk_tree_selection_count_selected_rows(selection);
1943 obs_may = n > 0;
1944 plr_may = obs_may && can_client_issue_orders();
1945#endif /* MENUS_GTK3 */
1946
1947 update_governor_menu();
1948
1949#ifdef MENUS_GTK3
1950 gtk_widget_set_sensitive(city_center_command, obs_may);
1951 gtk_widget_set_sensitive(city_popup_command, obs_may);
1952 gtk_widget_set_sensitive(city_buy_command, plr_may);
1953#endif /* MENUS_GTK3 */
1954
1955 recreate_production_menu(cityrep_group);
1956 recreate_select_menu(cityrep_group);
1957 recreate_sell_menu(cityrep_group);
1958
1959#ifdef MENUS_GTK3
1960 if (!plr_may) {
1961 gtk_widget_set_sensitive(city_sell_command, FALSE);
1962 }
1963#endif /* MENUS_GTK3 */
1964
1965 update_total_buy_cost();
1966}
1967
1968/************************************************************************/
1971 static void clear_worklist_foreach_func(GtkTreeModel *model,
1972 GtkTreePath *path,
1973 GtkTreeIter *iter,
1974 gpointer data)
1975{
1976 struct city *pcity = city_model_get(model, iter);
1977
1978 if (NULL != pcity) {
1979 struct worklist empty;
1980
1981 worklist_init(&empty);
1982 city_set_worklist(pcity, &empty);
1983 }
1984}
1985
1986/************************************************************************/
1989 static void city_clear_worklist_callback(GSimpleAction *action, GVariant *parameter,
1990 gpointer data)
1991{
1992 struct connection *pconn = &client.conn;
1993
1994 fc_assert_ret(city_selection != NULL);
1995
1996 connection_do_buffer(pconn);
1997 gtk_tree_selection_selected_foreach(city_selection,
1998 clear_worklist_foreach_func, NULL);
1999 connection_do_unbuffer(pconn);
2000}
2001
2002/************************************************************************/
2007 void hilite_cities_from_canvas(void)
2008{
2009 ITree it;
2010 GtkTreeModel *model;
2011
2012 if (!city_dialog_shell) return;
2013
2014 model = GTK_TREE_MODEL(city_model);
2015
2016 gtk_tree_selection_unselect_all(city_selection);
2017
2018 for (itree_begin(model, &it); !itree_end(&it); itree_next(&it)) {
2019 struct city *pcity = city_model_get(model, TREE_ITER_PTR(it));
2020
2021 if (NULL != pcity && is_city_hilited(pcity)) {
2022 itree_select(city_selection, &it);
2023 }
2024 }
2025}
2026
2027/************************************************************************/
2030 void toggle_city_hilite(struct city *pcity, bool on_off)
2031{
2032 GtkTreeIter iter;
2033
2034 if (NULL == city_dialog_shell) {
2035 return;
2036 }
2037
2038 if (city_model_find(GTK_TREE_MODEL(city_model), &iter, pcity)) {
2039 if (on_off) {
2040 gtk_tree_selection_select_iter(city_selection, &iter);
2041 } else {
2042 gtk_tree_selection_unselect_iter(city_selection, &iter);
2043 }
2044 }
2045}
n
#define n
Definition astring.c:77
can_city_build_now
bool can_city_build_now(const struct city *pcity, const struct universal *target)
Definition city.c:989
city_has_building
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1212
city.h
cities_iterate_end
#define cities_iterate_end
Definition city.h:497
city_list_iterate
#define city_list_iterate(citylist, pcity)
Definition city.h:488
cities_iterate
#define cities_iterate(pcity)
Definition city.h:492
city_owner
#define city_owner(_pcity_)
Definition city.h:543
city_list_iterate_end
#define city_list_iterate_end
Definition city.h:490
production_class_type
production_class_type
Definition city.h:38
PCT_UNIT
@ PCT_UNIT
Definition city.h:39
PCT_NORMAL_IMPROVEMENT
@ PCT_NORMAL_IMPROVEMENT
Definition city.h:40
PCT_WONDER
@ PCT_WONDER
Definition city.h:41
get_city_dialog_production_row
void get_city_dialog_production_row(char *buf[], size_t column_size, struct universal *target, struct city *pcity)
Definition citydlg_common.c:364
city_set_worklist
int city_set_worklist(struct city *pcity, const struct worklist *pworklist)
Definition citydlg_common.c:1273
city_queue_insert
bool city_queue_insert(struct city *pcity, int position, struct universal *item)
Definition citydlg_common.c:1384
city_queue_insert_worklist
bool city_queue_insert_worklist(struct city *pcity, int position, const struct worklist *worklist)
Definition citydlg_common.c:1412
city_set_queue
bool city_set_queue(struct city *pcity, const struct worklist *pqueue)
Definition citydlg_common.c:1459
city_change_production
int city_change_production(struct city *pcity, struct universal *target)
Definition citydlg_common.c:1261
city_sell_improvement
int city_sell_improvement(struct city *pcity, Impr_type_id sell_id)
Definition citydlg_common.c:1517
citydlg_common.h
popup_city_dialog
void popup_city_dialog(struct city *pcity)
Definition update_queue.c:623
refresh_city_dialog
void refresh_city_dialog(struct city *pcity)
Definition update_queue.c:632
can_city_sell_universal
bool can_city_sell_universal(const struct city *pcity, const struct universal *target)
Definition cityrepdata.c:1104
city_report_specs
struct city_report_spec * city_report_specs
Definition cityrepdata.c:798
cityrepfield_compare
int cityrepfield_compare(const char *str1, const char *str2)
Definition cityrepdata.c:1077
cityrepdata.h
NUM_CREPORT_COLS
#define NUM_CREPORT_COLS
Definition cityrepdata.h:25
city_model
Definition cityrep.h:103
client
struct civclient client
Definition client_main.c:149
can_client_issue_orders
bool can_client_issue_orders(void)
Definition client_main.c:1265
client_has_player
bool client_has_player(void)
Definition client_main.c:1365
client_main.h
client_player
#define client_player()
Definition client_main.h:106
city_unit_supported
bool city_unit_supported(const struct city *pcity, const struct universal *target)
Definition climisc.c:537
cityrep_buy
void cityrep_buy(struct city *pcity)
Definition climisc.c:1137
name_and_sort_items
void name_and_sort_items(struct universal *targets, int num_targets, struct item *items, bool show_cost, struct city *pcity)
Definition climisc.c:633
cid_encode
cid cid_encode(struct universal target)
Definition climisc.c:475
city_building_present
bool city_building_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:575
cid_decode
struct universal cid_decode(cid id)
Definition climisc.c:518
city_unit_present
bool city_unit_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:556
collect_production_targets
int collect_production_targets(struct universal *targets, struct city **selected_cities, int num_selected_cities, bool append_units, bool append_wonders, bool change_prod, TestCityFunc test_func)
Definition climisc.c:683
climisc.h
MAX_NUM_PRODUCTION_TARGETS
#define MAX_NUM_PRODUCTION_TARGETS
Definition climisc.h:87
TestCityFunc
bool(* TestCityFunc)(const struct city *, const struct universal *)
Definition climisc.h:85
cm_are_parameter_equal
bool cm_are_parameter_equal(const struct cm_parameter *const p1, const struct cm_parameter *const p2)
Definition cm.c:2136
cma_is_city_under_agent
bool cma_is_city_under_agent(const struct city *pcity, struct cm_parameter *parameter)
Definition cma_core.c:550
cma_put_city_under_agent
void cma_put_city_under_agent(struct city *pcity, const struct cm_parameter *const parameter)
Definition cma_core.c:522
cma_release_city
void cma_release_city(struct city *pcity)
Definition cma_core.c:540
cmafec_preset_get_descr
char * cmafec_preset_get_descr(int idx)
Definition cma_fec.c:169
cmafec_preset_get_parameter
const struct cm_parameter * cmafec_preset_get_parameter(int idx)
Definition cma_fec.c:182
cmafec_preset_get_index_of_parameter
int cmafec_preset_get_index_of_parameter(const struct cm_parameter *const parameter)
Definition cma_fec.c:196
cmafec_preset_num
int cmafec_preset_num(void)
Definition cma_fec.c:213
cma_fec.h
connection_do_buffer
void connection_do_buffer(struct connection *pc)
Definition connection.c:323
connection_do_unbuffer
void connection_do_unbuffer(struct connection *pc)
Definition connection.c:335
id
int int id
Definition editgui_g.h:28
fcintl.h
Q_
#define Q_(String)
Definition fcintl.h:70
PL_
#define PL_(String1, String2, n)
Definition fcintl.h:71
_
#define _(String)
Definition fcintl.h:67
wld
struct world wld
Definition game.c:58
game_city_by_number
struct city * game_city_by_number(int id)
Definition game.c:102
game.h
global_worklist_by_id
struct global_worklist * global_worklist_by_id(int id)
Definition global_worklist.c:298
global_worklist_name
const char * global_worklist_name(const struct global_worklist *pgwl)
Definition global_worklist.c:323
global_worklist_id
int global_worklist_id(const struct global_worklist *pgwl)
Definition global_worklist.c:288
global_worklist_get
const struct worklist * global_worklist_get(const struct global_worklist *pgwl)
Definition global_worklist.c:276
global_worklist.h
global_worklists_iterate
#define global_worklists_iterate(pgwl)
Definition global_worklist.h:65
global_worklists_iterate_end
#define global_worklists_iterate_end
Definition global_worklist.h:68
append_worklist_foreach
static void append_worklist_foreach(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:857
create_city_report_dialog
static void create_city_report_dialog(bool make_modal)
Definition cityrep.c:1138
city_invert_selection_callback
static void city_invert_selection_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:1259
city_popup_command
static GtkWidget * city_popup_command
Definition cityrep.c:119
worklist_next_impr_or_unit_iterate
static void worklist_next_impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:513
city_total_buy_cost_label
static GtkWidget * city_total_buy_cost_label
Definition cityrep.c:124
city_buy_command
static GtkWidget * city_buy_command
Definition cityrep.c:120
update_total_buy_cost
static void update_total_buy_cost(void)
Definition cityrep.c:1960
real_city_report_dialog_update
void real_city_report_dialog_update(void *unused)
Definition cityrep.c:1455
CRD_COL_CITY_ID
#define CRD_COL_CITY_ID
Definition cityrep.c:107
real_city_report_update_city
void real_city_report_update_city(struct city *pcity)
Definition cityrep.c:1490
city_select_building_callback
static void city_select_building_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:1328
popup_iterate
static void popup_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:1381
create_select_menu
static void create_select_menu(GtkWidget *item)
Definition cityrep.c:1771
city_activated_callback
static void city_activated_callback(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
Definition cityrep.c:1423
select_impr_or_unit_callback
static void select_impr_or_unit_callback(GtkWidget *wdg, gpointer data)
Definition cityrep.c:567
impr_or_unit_iterate
static void impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:456
city_model_fill
static void city_model_fill(GtkListStore *store, GtkTreeSelection *selection, GHashTable *select)
Definition cityrep.c:262
center_iterate
static void center_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:1368
CITY_POPUP
@ CITY_POPUP
Definition cityrep.c:101
CITY_CENTER
@ CITY_CENTER
Definition cityrep.c:101
CITY_BUY
@ CITY_BUY
Definition cityrep.c:101
toggle_city_hilite
void toggle_city_hilite(struct city *pcity, bool on_off)
Definition cityrep.c:2092
city_building_impr_or_unit
static bool city_building_impr_or_unit(const struct city *pcity, const struct universal *target)
Definition cityrep.c:1890
CMA_NONE
#define CMA_NONE
Definition cityrep.c:64
cityrep_sort_func
static gint cityrep_sort_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
Definition cityrep.c:1123
city_model_get
static struct city * city_model_get(GtkTreeModel *model, GtkTreeIter *iter)
Definition cityrep.c:226
city_select_coastal_callback
static void city_select_coastal_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:1276
popup_select_menu
static void popup_select_menu(GtkMenuShell *menu, gpointer data)
Definition cityrep.c:1899
city_command_callback
static void city_command_callback(struct gui_dialog *dlg, int response, gpointer data)
Definition cityrep.c:1397
city_model_set
static void city_model_set(GtkListStore *store, GtkTreeIter *iter, struct city *pcity)
Definition cityrep.c:207
city_clear_worklist_callback
static void city_clear_worklist_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:2050
city_model
static GtkListStore * city_model
Definition cityrep.c:106
clear_worklist_foreach_func
static void clear_worklist_foreach_func(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:2032
city_sell_command
static GtkWidget * city_sell_command
Definition cityrep.c:123
NEG_VAL
#define NEG_VAL(x)
Definition cityrep.c:61
city_select_all_callback
static void city_select_all_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:1243
CMA_CUSTOM
#define CMA_CUSTOM
Definition cityrep.c:65
sell_impr_iterate
static void sell_impr_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:548
city_selection
static GtkTreeSelection * city_selection
Definition cityrep.c:105
same_island_iterate
static void same_island_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:1296
set_worklist_callback
static void set_worklist_callback(GtkMenuItem *menuitem, gpointer data)
Definition cityrep.c:913
city_selection_changed_callback
static void city_selection_changed_callback(GtkTreeSelection *selection)
Definition cityrep.c:2006
city_model_find
static gboolean city_model_find(GtkTreeModel *model, GtkTreeIter *iter, const struct city *pcity)
Definition cityrep.c:242
worklist_next_to_last_impr_or_unit_iterate
static void worklist_next_to_last_impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:532
city_report_dialog_store_new
static GtkListStore * city_report_dialog_store_new(void)
Definition cityrep.c:188
city_dialog_shell_is_modal
static int city_dialog_shell_is_modal
Definition cityrep.c:162
city_report_update_views
static void city_report_update_views(void)
Definition cityrep.c:986
get_city_table_header
static void get_city_table_header(char **text, int n)
Definition cityrep.c:169
hilite_cities_from_canvas
void hilite_cities_from_canvas(void)
Definition cityrep.c:2067
city_report_dialog_popdown
void city_report_dialog_popdown(void)
Definition cityrep.c:312
city_report_dialog_popup
void city_report_dialog_popup(bool raise)
Definition cityrep.c:292
city_view
static GtkWidget * city_view
Definition cityrep.c:104
city_dialog_shell
static struct gui_dialog * city_dialog_shell
Definition cityrep.c:98
worklist_first_impr_or_unit_iterate
static void worklist_first_impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:493
set_worklist_foreach
static void set_worklist_foreach(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:896
toggle_view
static void toggle_view(GtkCheckMenuItem *item, gpointer data)
Definition cityrep.c:1010
append_worklist_callback
static void append_worklist_callback(GtkMenuItem *menuitem, gpointer data)
Definition cityrep.c:875
city_unselect_all_callback
static void city_unselect_all_callback(GtkMenuItem *item, gpointer data)
Definition cityrep.c:1251
worklist_last_impr_or_unit_iterate
static void worklist_last_impr_or_unit_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:472
city_center_command
static GtkWidget * city_center_command
Definition cityrep.c:118
buy_iterate
static void buy_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:1355
city_operation_type
city_operation_type
Definition cityrep.c:73
CO_SELL
@ CO_SELL
Definition cityrep.c:74
CO_NEXT_TO_LAST
@ CO_NEXT_TO_LAST
Definition cityrep.c:74
CO_NEXT
@ CO_NEXT
Definition cityrep.c:74
CO_CHANGE
@ CO_CHANGE
Definition cityrep.c:74
CO_FIRST
@ CO_FIRST
Definition cityrep.c:74
CO_LAST
@ CO_LAST
Definition cityrep.c:74
CO_NONE
@ CO_NONE
Definition cityrep.c:74
recreate_sell_menu
static void recreate_sell_menu(void)
Definition cityrep.c:1744
create_change_menu
static void create_change_menu(GtkWidget *item)
Definition cityrep.c:1509
pos
static struct tile * pos
Definition finddlg.c:53
top_notebook
GtkWidget * top_notebook
Definition gui_main.c:128
gui_dialog_destroy
void gui_dialog_destroy(struct gui_dialog *dlg)
Definition gui_stuff.c:951
gui_dialog_present
void gui_dialog_present(struct gui_dialog *dlg)
Definition gui_stuff.c:834
itree_get
void itree_get(ITree *it,...)
Definition gui_stuff.c:158
gui_dialog_raise
void gui_dialog_raise(struct gui_dialog *dlg)
Definition gui_stuff.c:864
gui_dialog_new
void gui_dialog_new(struct gui_dialog **pdlg, GtkNotebook *notebook, gpointer user_data, bool check_top)
Definition gui_stuff.c:504
gui_dialog_response_set_callback
void gui_dialog_response_set_callback(struct gui_dialog *dlg, GUI_DIALOG_RESPONSE_FUN fun)
Definition gui_stuff.c:985
itree_begin
void itree_begin(GtkTreeModel *model, ITree *it)
Definition gui_stuff.c:121
gui_dialog_add_button
GtkWidget * gui_dialog_add_button(struct gui_dialog *dlg, const char *text, int response)
Definition gui_stuff.c:706
itree_unselect
void itree_unselect(GtkTreeSelection *selection, ITree *it)
Definition gui_stuff.c:200
gui_dialog_show_all
void gui_dialog_show_all(struct gui_dialog *dlg)
Definition gui_stuff.c:794
itree_select
void itree_select(GtkTreeSelection *selection, ITree *it)
Definition gui_stuff.c:192
gui_dialog_set_title
void gui_dialog_set_title(struct gui_dialog *dlg, const char *title)
Definition gui_stuff.c:932
gui_dialog_set_default_size
void gui_dialog_set_default_size(struct gui_dialog *dlg, int width, int height)
Definition gui_stuff.c:916
itree_next
void itree_next(ITree *it)
Definition gui_stuff.c:138
itree_is_selected
gboolean itree_is_selected(GtkTreeSelection *selection, ITree *it)
Definition gui_stuff.c:184
itree_end
gboolean itree_end(ITree *it)
Definition gui_stuff.c:130
TREE_ITER_PTR
#define TREE_ITER_PTR(x)
Definition gui_stuff.h:37
impr_b_select_menu
static GMenu * impr_b_select_menu
Definition cityrep.c:136
create_city_report_menu
static GtkWidget * create_city_report_menu(void)
Definition cityrep.c:1112
wl_set_menu
static GMenu * wl_set_menu
Definition cityrep.c:131
recreate_production_menu
static void recreate_production_menu(GActionGroup *group)
Definition cityrep.c:1678
unit_b_select_menu
static GMenu * unit_b_select_menu
Definition cityrep.c:135
city_select_island_callback
static void city_select_island_callback(GSimpleAction *action, GVariant *parameter, gpointer data)
Definition cityrep.c:1358
display_menu
static GMenu * display_menu
Definition cityrep.c:151
add_first_menu
static GMenu * add_first_menu
Definition cityrep.c:127
add_2ndlast_menu
static GMenu * add_2ndlast_menu
Definition cityrep.c:130
add_next_menu
static GMenu * add_next_menu
Definition cityrep.c:129
impr_a_select_menu
static GMenu * impr_a_select_menu
Definition cityrep.c:143
select_governor_callback
static void select_governor_callback(GSimpleAction *action, GVariant *parameter, gpointer data)
Definition cityrep.c:700
unit_s_select_menu
static GMenu * unit_s_select_menu
Definition cityrep.c:138
impr_p_select_menu
static GMenu * impr_p_select_menu
Definition cityrep.c:140
cityrep_group
static GActionGroup * cityrep_group
Definition cityrep.c:150
wl_append_menu
static GMenu * wl_append_menu
Definition cityrep.c:132
governors_iterate
static void governors_iterate(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Definition cityrep.c:680
create_governor_menu
static GMenu * create_governor_menu(GActionGroup *group, bool change_governor)
Definition cityrep.c:759
create_display_menu
static GMenu * create_display_menu(GActionGroup *group)
Definition cityrep.c:1084
recreate_select_menu
static void recreate_select_menu(GActionGroup *group)
Definition cityrep.c:1865
create_production_menu
static GMenu * create_production_menu(GActionGroup *group)
Definition cityrep.c:1614
create_display_menu_item
static GMenuItem * create_display_menu_item(int pos)
Definition cityrep.c:1052
select_menu
static GMenu * select_menu
Definition cityrep.c:134
prod_menu
static GMenu * prod_menu
Definition cityrep.c:125
add_last_menu
static GMenu * add_last_menu
Definition cityrep.c:128
cityrep_menu
static GMenu * cityrep_menu
Definition cityrep.c:149
create_wl_menu
static GMenu * create_wl_menu(GActionGroup *group, const char *act_pfx, GCallback cb)
Definition cityrep.c:985
append_impr_or_unit_to_menu
static void append_impr_or_unit_to_menu(GMenu *menu, GActionGroup *act_group, const char *act_pfx, const char *act_pfx2, bool append_units, bool append_wonders, enum city_operation_type city_operation, TestCityFunc test_func, GCallback callback, int size)
Definition cityrep.c:307
unit_a_select_menu
static GMenu * unit_a_select_menu
Definition cityrep.c:142
unit_p_select_menu
static GMenu * unit_p_select_menu
Definition cityrep.c:139
update_governor_menu
static void update_governor_menu(void)
Definition cityrep.c:891
governor_select_menu
static GMenu * governor_select_menu
Definition cityrep.c:145
change_menu
static GMenu * change_menu
Definition cityrep.c:126
wndr_b_select_menu
static GMenu * wndr_b_select_menu
Definition cityrep.c:137
wndr_p_select_menu
static GMenu * wndr_p_select_menu
Definition cityrep.c:141
wndr_a_select_menu
static GMenu * wndr_a_select_menu
Definition cityrep.c:144
blocking_dialog
gint blocking_dialog(GtkWidget *dlg)
Definition gui_stuff.c:1126
aux_menu_new
GtkWidget * aux_menu_new(void)
Definition gui_stuff.c:243
gui_dialog_add_content_widget
void gui_dialog_add_content_widget(struct gui_dialog *dlg, GtkWidget *wdg)
Definition gui_stuff.c:1095
gui_dialog_add_action_widget
GtkWidget * gui_dialog_add_action_widget(struct gui_dialog *dlg, GtkWidget *widget)
Definition gui_stuff.c:680
gui_stuff.h
submenu_append_unref
#define submenu_append_unref(menu, name, submenu)
Definition gui_stuff.h:165
menu_item_insert_unref
#define menu_item_insert_unref(menu, index, item)
Definition gui_stuff.h:142
submenu_insert_unref
#define submenu_insert_unref(menu, index, name, submenu)
Definition gui_stuff.h:156
menu_item_append_unref
#define menu_item_append_unref(menu, item)
Definition gui_stuff.h:149
chatline.h
citydlg.h
cityrep.h
gui_main.h
mapview.h
optiondlg.h
repodlgs.h
impr_sell_gold
int impr_sell_gold(const struct impr_type *pimprove)
Definition improvement.c:332
improvement_number
Impr_type_id improvement_number(const struct impr_type *pimprove)
Definition improvement.c:182
is_wonder
bool is_wonder(const struct impr_type *pimprove)
Definition improvement.c:341
improvement_name_translation
const char * improvement_name_translation(const struct impr_type *pimprove)
Definition improvement.c:241
log.h
fc_assert_ret
#define fc_assert_ret(condition)
Definition log.h:191
fc_assert_action
#define fc_assert_action(condition, action)
Definition log.h:187
is_city_hilited
bool is_city_hilited(struct city *pcity)
Definition mapctrl_common.c:302
mapctrl_common.h
center_tile_mapcanvas
void center_tile_mapcanvas(const struct tile *ptile)
Definition mapview_common.c:1222
mapview_common.h
fc_realloc
#define fc_realloc(ptr, sz)
Definition mem.h:36
gui_options
struct client_options gui_options
Definition options.c:71
options.h
packets.h
cities
struct city_list * cities
Definition packhand.c:117
are_universals_equal
bool are_universals_equal(const struct universal *psource1, const struct universal *psource2)
Definition requirements.c:5278
shared.h
ARRAY_SIZE
#define ARRAY_SIZE(x)
Definition shared.h:85
size
size_t size
Definition specvec.h:72
ITree
Definition gui_stuff.h:31
action
Definition actions.h:379
callback
Definition gui_main.c:2187
city_report_spec
Definition cityrepdata.h:27
city_report_spec::func
const char *(* func)(const struct city *pcity, const void *data)
Definition cityrepdata.h:34
city_report_spec::width
int width
Definition cityrepdata.h:29
city_report_spec::title2
const char * title2
Definition cityrepdata.h:31
city_report_spec::data
void * data
Definition cityrepdata.h:33
city_report_spec::show
bool show
Definition cityrepdata.h:28
city_report_spec::explanation
const char * explanation
Definition cityrepdata.h:32
city_report_spec::title1
const char * title1
Definition cityrepdata.h:30
city
Definition city.h:309
city::did_sell
bool did_sell
Definition city.h:367
city::id
int id
Definition city.h:315
city::worklist
struct worklist worklist
Definition city.h:387
city::production
struct universal production
Definition city.h:382
city::buy_cost
int buy_cost
Definition city.h:449
city::tile
struct tile * tile
Definition city.h:311
city::client
struct city::@17::@20 client
civclient::conn
struct connection conn
Definition client_main.h:96
client_options::center_when_popup_city
bool center_when_popup_city
Definition options.h:154
cm_parameter
Definition cm.h:40
connection
Definition connection.h:141
connection::playing
struct player * playing
Definition connection.h:156
global_worklist
Definition global_worklist.c:49
gui_dialog
Definition gui_stuff.h:69
impr_type
Definition improvement.h:68
item
Definition climisc.h:80
item::item
struct universal item
Definition climisc.h:81
player::cities
struct city_list * cities
Definition player.h:281
sell_data
Definition cityrep.c:67
sell_data::gold
int gold
Definition cityrep.c:69
sell_data::count
int count
Definition cityrep.c:68
sell_data::target
const struct impr_type * target
Definition cityrep.c:70
test_func
Definition mapgen.c:679
universal
Definition fc_types.h:756
universal::kind
enum universals_n kind
Definition fc_types.h:758
universal::value
universals_u value
Definition fc_types.h:757
view
Definition mapview_common.h:36
worklist
Definition worklist.h:28
world::map
struct civ_map map
Definition world_object.h:38
fc_snprintf
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:969
support.h
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
is_terrain_class_near_tile
bool is_terrain_class_near_tile(const struct civ_map *nmap, const struct tile *ptile, enum terrain_class tclass)
Definition terrain.c:600
tile_continent
#define tile_continent(_tile)
Definition tile.h:91
universals_u::building
const struct impr_type * building
Definition fc_types.h:598
unit.h
worklist_init
void worklist_init(struct worklist *pwl)
Definition worklist.c:38
worklist_length
int worklist_length(const struct worklist *pwl)
Definition worklist.c:57