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

Freeciv-3.1

Loading...
Searching...
No Matches
gui_main.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#ifdef AUDIO_SDL
19/* Though it would happily compile without this include,
20 * it is needed for sound to work.
21 * It defines "main" macro to rename our main() so that
22 * it can install SDL's own. */
23#ifdef SDL2_PLAIN_INCLUDE
24#include <SDL.h>
25#else /* PLAIN_INCLUDE */
26#include <SDL2/SDL.h>
27#endif /* PLAIN_INCLUDE */
28#endif /* AUDIO_SDL */
29
30#ifdef HAVE_LOCALE_H
31#include <locale.h>
32#endif
33#include <stdarg.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <time.h>
38
39#ifdef HAVE_UNISTD_H
40#include <unistd.h>
41#endif
42
43#include <gtk/gtk.h>
44#include <gdk/gdkkeysyms.h>
45
46/* utility */
47#include "fc_cmdline.h"
48#include "fciconv.h"
49#include "fcintl.h"
50#include "log.h"
51#include "mem.h"
52#include "support.h"
53
54/* common */
55#include "dataio.h"
56#include "featured_text.h"
57#include "game.h"
58#include "government.h"
59#include "map.h"
60#include "unitlist.h"
61#include "version.h"
62
63/* client */
64#include "client_main.h"
65#include "climisc.h"
66#include "clinet.h"
67#include "colors.h"
68#include "connectdlg_common.h"
69#include "control.h"
70#include "editor.h"
71#include "options.h"
72#include "text.h"
73#include "tilespec.h"
74#include "zoom.h"
75
76/* client/gui-gtk-3.22 */
77#include "chatline.h"
78#include "citizensinfo.h"
79#include "connectdlg.h"
80#include "cma_fe.h"
81#include "dialogs.h"
82#include "diplodlg.h"
83#include "editgui.h"
84#include "gotodlg.h"
85#include "graphics.h"
86#include "gui_stuff.h"
87#include "happiness.h"
88#include "helpdlg.h"
89#include "inteldlg.h"
90#include "mapctrl.h"
91#include "mapview.h"
92#include "menu.h"
93#include "messagewin.h"
94#include "optiondlg.h"
95#include "pages.h"
96#include "plrdlg.h"
97#include "luaconsole.h"
98#include "spaceshipdlg.h"
99#include "repodlgs.h"
100#include "voteinfo_bar.h"
101
102#include "gui_main.h"
103
104 const char *client_string = GUI_NAME_FULL;
105
106GtkWidget *map_canvas; /* GtkDrawingArea */
107GtkWidget *map_horizontal_scrollbar;
108GtkWidget *map_vertical_scrollbar;
109
110GtkWidget *overview_canvas; /* GtkDrawingArea */
111GtkWidget *overview_scrolled_window; /* GtkScrolledWindow */
112/* The two values below define the width and height of the map overview. The
113 * first set of values (2*62, 2*46) define the size for a netbook display. For
114 * bigger displays the values are doubled (default). */
115#define OVERVIEW_CANVAS_STORE_WIDTH_NETBOOK (2 * 64)
116#define OVERVIEW_CANVAS_STORE_HEIGHT_NETBOOK (2 * 46)
117#define OVERVIEW_CANVAS_STORE_WIDTH \
118 (2 * OVERVIEW_CANVAS_STORE_WIDTH_NETBOOK)
119#define OVERVIEW_CANVAS_STORE_HEIGHT \
120 (2 * OVERVIEW_CANVAS_STORE_HEIGHT_NETBOOK)
121 int overview_canvas_store_width = OVERVIEW_CANVAS_STORE_WIDTH;
122 int overview_canvas_store_height = OVERVIEW_CANVAS_STORE_HEIGHT;
123
124GtkWidget *toplevel;
125GdkWindow *root_window;
126GtkWidget *toplevel_tabs;
127GtkWidget *top_vbox;
128GtkWidget *top_notebook, *bottom_notebook, *right_notebook;
129GtkWidget *map_widget;
130 static GtkWidget *bottom_hpaned;
131
132PangoFontDescription *city_names_style = NULL;
133PangoFontDescription *city_productions_style = NULL;
134PangoFontDescription *reqtree_text_style = NULL;
135
136GtkWidget *main_frame_civ_name;
137GtkWidget *main_label_info;
138
139GtkWidget *avbox, *ahbox, *conn_box;
140GtkWidget* scroll_panel;
141
142GtkWidget *econ_label[10];
143GtkWidget *bulb_label;
144GtkWidget *sun_label;
145GtkWidget *flake_label;
146GtkWidget *government_label;
147GtkWidget *timeout_label;
148GtkWidget *turn_done_button;
149
150GtkWidget *unit_info_label;
151GtkWidget *unit_info_box;
152GtkWidget *unit_info_frame;
153
154GtkWidget *econ_ebox;
155GtkWidget *bulb_ebox;
156GtkWidget *sun_ebox;
157GtkWidget *flake_ebox;
158GtkWidget *government_ebox;
159
160 const char *const gui_character_encoding = "UTF-8";
161 const bool gui_use_transliteration = FALSE;
162
163 static GtkWidget *main_menubar;
164 static GtkWidget *unit_image_table;
165 static GtkWidget *unit_image;
166 static GtkWidget *unit_image_button;
167 static GtkWidget *unit_below_image[MAX_NUM_UNITS_BELOW];
168 static GtkWidget *unit_below_image_button[MAX_NUM_UNITS_BELOW];
169 static GtkWidget *more_arrow_pixmap;
170 static GtkWidget *more_arrow_pixmap_button;
171 static GtkWidget *more_arrow_pixmap_container;
172
173 static int unit_id_top;
174 static int unit_ids[MAX_NUM_UNITS_BELOW]; /* ids of the units icons in
175 * information display: (or 0) */
176GtkTextView *main_message_area;
177GtkTextBuffer *message_buffer = NULL;
178 static GtkWidget *allied_chat_toggle_button;
179
180 static gint timer_id; /* ditto */
181 static GIOChannel *srv_channel;
182 static guint srv_id;
183gint cur_x, cur_y;
184
185 static bool gui_up = FALSE;
186
187 static struct video_mode vmode = { -1, -1 };
188
189static void set_g_log_callbacks(void);
190
191static gboolean show_info_button_release(GtkWidget *w, GdkEventButton *ev, gpointer data);
192static gboolean show_info_popup(GtkWidget *w, GdkEventButton *ev, gpointer data);
193
194static void end_turn_callback(GtkWidget *w, gpointer data);
195static gboolean get_net_input(GIOChannel *source, GIOCondition condition,
196 gpointer data);
197static void set_wait_for_writable_socket(struct connection *pc,
198 bool socket_writable);
199
200static void print_usage(void);
201static bool parse_options(int argc, char **argv);
202static gboolean toplevel_key_press_handler(GtkWidget *w, GdkEventKey *ev, gpointer data);
203static gboolean toplevel_key_release_handler(GtkWidget *w, GdkEventKey *ev, gpointer data);
204static gboolean mouse_scroll_mapcanvas(GtkWidget *w, GdkEventScroll *ev);
205
206static void tearoff_callback(GtkWidget *b, gpointer data);
207static GtkWidget *detached_widget_new(void);
208static GtkWidget *detached_widget_fill(GtkWidget *tearbox);
209
210static gboolean select_unit_image_callback(GtkWidget *w, GdkEvent *ev,
211 gpointer data);
212static gboolean select_more_arrow_pixmap_callback(GtkWidget *w, GdkEvent *ev,
213 gpointer data);
214static gboolean quit_dialog_callback(void);
215
216static void allied_chat_button_toggled(GtkToggleButton *button,
217 gpointer user_data);
218
219static void free_unit_table(void);
220
221static void adjust_default_options(void);
222
223/**********************************************************************/
226 static void log_callback_utf8(enum log_level level, const char *message,
227 bool file_too)
228{
229 if (!file_too || level <= LOG_FATAL) {
230 fc_fprintf(stderr, "%d: %s\n", level, message);
231 }
232}
233
234/**********************************************************************/
238 static gboolean timer_callback(gpointer data)
239{
240 double seconds = real_timer_callback();
241
242 timer_id = g_timeout_add(seconds * 1000, timer_callback, NULL);
243
244 return FALSE;
245}
246
247/**********************************************************************/
251 static void print_usage(void)
252{
253 /* add client-specific usage information here */
254 fc_fprintf(stderr,
255 _("This client accepts the standard Gtk command-line options\n"
256 "after '--'. See the Gtk documentation.\n\n"));
257
258 fc_fprintf(stderr,
259 _("Other gui-specific options are:\n"));
260
261 fc_fprintf(stderr,
262 _("-r, --resolution WIDTHxHEIGHT\tAssume given resolution "
263 "screen\n"));
264
265 fc_fprintf(stderr, "\n");
266
267 /* TRANS: No full stop after the URL, could cause confusion. */
268 fc_fprintf(stderr, _("Report bugs at %s\n"), BUG_URL);
269}
270
271/**********************************************************************/
274 static bool parse_options(int argc, char **argv)
275{
276 int i = 1;
277
278 while (i < argc) {
279 char *option = NULL;
280
281 if (is_option("--help", argv[i])) {
282 print_usage();
283
284 return FALSE;
285 } else if ((option = get_option_malloc("--resolution", argv, &i, argc, FALSE))) {
286 if (!string_to_video_mode(option, &vmode)) {
287 fc_fprintf(stderr, _("Illegal video mode '%s'\n"), option);
288 exit(EXIT_FAILURE);
289 }
290 free(option);
291 }
292 /* Can't check against unknown options, as those might be gtk options */
293
294 i++;
295 }
296
297 return TRUE;
298}
299
300/**********************************************************************/
303 static gboolean toplevel_focus(GtkWidget *w, GtkDirectionType arg)
304{
305 switch (arg) {
306 case GTK_DIR_TAB_FORWARD:
307 case GTK_DIR_TAB_BACKWARD:
308
309 if (!gtk_widget_get_can_focus(w)) {
310 return FALSE;
311 }
312
313 if (!gtk_widget_is_focus(w)) {
314 gtk_widget_grab_focus(w);
315 return TRUE;
316 }
317 break;
318
319 default:
320 break;
321 }
322 return FALSE;
323}
324
325/**********************************************************************/
330 static void main_message_area_size_allocate(GtkWidget *widget,
331 GtkAllocation *allocation,
332 gpointer data)
333{
334 static int old_width = 0, old_height = 0;
335
336 if (allocation->width != old_width
337 || allocation->height != old_height) {
338 chatline_scroll_to_bottom(TRUE);
339 old_width = allocation->width;
340 old_height = allocation->height;
341 }
342}
343
344/**********************************************************************/
347gboolean map_canvas_focus(void)
348{
349 gtk_window_present(GTK_WINDOW(toplevel));
350 gtk_notebook_set_current_page(GTK_NOTEBOOK(top_notebook), 0);
351 gtk_widget_grab_focus(map_canvas);
352 return TRUE;
353}
354
355/**********************************************************************/
364 static gboolean toplevel_handler(GtkWidget *w, GdkEvent *ev, gpointer data)
365{
366 GtkWidget *focus;
367
368 focus = gtk_window_get_focus(GTK_WINDOW(toplevel));
369 if (focus) {
370 if (GTK_IS_ENTRY(focus)
371 || (GTK_IS_TEXT_VIEW(focus)
372 && gtk_text_view_get_editable(GTK_TEXT_VIEW(focus)))) {
373 /* Propagate event to currently focused entry widget. */
374 if (gtk_widget_event(focus, ev)) {
375 /* Do not propagate event to our children. */
376 return TRUE;
377 }
378 }
379 }
380
381 /* Continue propagating event to our children. */
382 return FALSE;
383}
384
385/**********************************************************************/
388 static gboolean key_press_map_canvas(GtkWidget *w, GdkEventKey *ev,
389 gpointer data)
390{
391 if ((ev->state & GDK_SHIFT_MASK)) {
392 switch (ev->keyval) {
393
394 case GDK_KEY_Left:
395 scroll_mapview(DIR8_WEST);
396 return TRUE;
397
398 case GDK_KEY_Right:
399 scroll_mapview(DIR8_EAST);
400 return TRUE;
401
402 case GDK_KEY_Up:
403 scroll_mapview(DIR8_NORTH);
404 return TRUE;
405
406 case GDK_KEY_Down:
407 scroll_mapview(DIR8_SOUTH);
408 return TRUE;
409
410 case GDK_KEY_Home:
411 key_center_capital();
412 return TRUE;
413
414 case GDK_KEY_Page_Up:
415 g_signal_emit_by_name(main_message_area, "move_cursor",
416 GTK_MOVEMENT_PAGES, -1, FALSE);
417 return TRUE;
418
419 case GDK_KEY_Page_Down:
420 g_signal_emit_by_name(main_message_area, "move_cursor",
421 GTK_MOVEMENT_PAGES, 1, FALSE);
422 return TRUE;
423
424 default:
425 break;
426 }
427 } else if (!(ev->state & GDK_CONTROL_MASK)) {
428 switch (ev->keyval) {
429 default:
430 break;
431 }
432 }
433
434 if (ev->state & GDK_SHIFT_MASK) {
435 bool volchange = FALSE;
436
437 switch (ev->keyval) {
438 case GDK_KEY_plus:
439 case GDK_KEY_KP_Add:
440 gui_options.sound_effects_volume += 10;
441 volchange = TRUE;
442 break;
443
444 case GDK_KEY_minus:
445 case GDK_KEY_KP_Subtract:
446 gui_options.sound_effects_volume -= 10;
447 volchange = TRUE;
448 break;
449
450 default:
451 break;
452 }
453
454 if (volchange) {
455 struct option *poption = optset_option_by_name(client_optset, "sound_effects_volume");
456
457 gui_options.sound_effects_volume = CLIP(0, gui_options.sound_effects_volume, 100);
458 option_changed(poption);
459
460 return TRUE;
461 }
462 } else if (!(ev->state & GDK_CONTROL_MASK)) {
463 switch (ev->keyval) {
464 case GDK_KEY_plus:
465 case GDK_KEY_KP_Add:
466 zoom_step_up();
467 return TRUE;
468
469 case GDK_KEY_minus:
470 case GDK_KEY_KP_Subtract:
471 zoom_step_down();
472 return TRUE;
473
474 default:
475 break;
476 }
477 }
478
479 /* Return here if observer */
480 if (client_is_observer()) {
481 return FALSE;
482 }
483
484 switch (ev->keyval) {
485
486 case GDK_KEY_KP_Up:
487 case GDK_KEY_KP_8:
488 case GDK_KEY_Up:
489 case GDK_KEY_8:
490 key_unit_move(DIR8_NORTH);
491 return TRUE;
492
493 case GDK_KEY_KP_Page_Up:
494 case GDK_KEY_KP_9:
495 case GDK_KEY_Page_Up:
496 case GDK_KEY_9:
497 key_unit_move(DIR8_NORTHEAST);
498 return TRUE;
499
500 case GDK_KEY_KP_Right:
501 case GDK_KEY_KP_6:
502 case GDK_KEY_Right:
503 case GDK_KEY_6:
504 key_unit_move(DIR8_EAST);
505 return TRUE;
506
507 case GDK_KEY_KP_Page_Down:
508 case GDK_KEY_KP_3:
509 case GDK_KEY_Page_Down:
510 case GDK_KEY_3:
511 key_unit_move(DIR8_SOUTHEAST);
512 return TRUE;
513
514 case GDK_KEY_KP_Down:
515 case GDK_KEY_KP_2:
516 case GDK_KEY_Down:
517 case GDK_KEY_2:
518 key_unit_move(DIR8_SOUTH);
519 return TRUE;
520
521 case GDK_KEY_KP_End:
522 case GDK_KEY_KP_1:
523 case GDK_KEY_End:
524 case GDK_KEY_1:
525 key_unit_move(DIR8_SOUTHWEST);
526 return TRUE;
527
528 case GDK_KEY_KP_Left:
529 case GDK_KEY_KP_4:
530 case GDK_KEY_Left:
531 case GDK_KEY_4:
532 key_unit_move(DIR8_WEST);
533 return TRUE;
534
535 case GDK_KEY_KP_Home:
536 case GDK_KEY_KP_7:
537 case GDK_KEY_Home:
538 case GDK_KEY_7:
539 key_unit_move(DIR8_NORTHWEST);
540 return TRUE;
541
542 case GDK_KEY_KP_Begin:
543 case GDK_KEY_KP_5:
544 case GDK_KEY_5:
545 key_recall_previous_focus_unit();
546 return TRUE;
547
548 case GDK_KEY_Escape:
549 key_cancel_action();
550 return TRUE;
551
552 case GDK_KEY_b:
553 if (tiles_hilited_cities) {
554 buy_production_in_selected_cities();
555 return TRUE;
556 }
557 break;
558
559 default:
560 break;
561 };
562
563 return FALSE;
564}
565
566/**********************************************************************/
569 static gboolean toplevel_key_release_handler(GtkWidget *w, GdkEventKey *ev,
570 gpointer data)
571{
572 /* inputline history code */
573 if (!gtk_widget_get_mapped(top_vbox) || inputline_has_focus()) {
574 return FALSE;
575 }
576
577 if (editor_is_active()) {
578 return handle_edit_key_release(ev);
579 }
580
581 return FALSE;
582}
583
584/**********************************************************************/
587 static gboolean toplevel_key_press_handler(GtkWidget *w, GdkEventKey *ev,
588 gpointer data)
589{
590 if (inputline_has_focus()) {
591 return FALSE;
592 }
593
594 if (ev->keyval == GDK_KEY_apostrophe) {
595 /* Allow this even if not in main map view; chatline is present on
596 * some other pages too */
597
598 /* Make the chatline visible if it's not currently.
599 * FIXME: should find the correct window, even when detached, from any
600 * other window; should scroll to the bottom automatically showing the
601 * latest text from other players; MUST NOT make spurious text windows
602 * at the bottom of other dialogs. */
603 if (gtk_widget_get_mapped(top_vbox)) {
604 /* The main game view is visible. May need to switch notebook. */
605 if (GUI_GTK_OPTION(message_chat_location) == GUI_GTK_MSGCHAT_MERGED) {
606 gtk_notebook_set_current_page(GTK_NOTEBOOK(top_notebook), 1);
607 } else {
608 gtk_notebook_set_current_page(GTK_NOTEBOOK(bottom_notebook), 0);
609 }
610 }
611
612 /* If the chatline is (now) visible, focus it. */
613 if (inputline_is_visible()) {
614 inputline_grab_focus();
615 return TRUE;
616 }
617 }
618
619 if (!gtk_widget_get_mapped(top_vbox)
620 || !can_client_change_view()) {
621 return FALSE;
622 }
623
624 if (editor_is_active()) {
625 if (handle_edit_key_press(ev)) {
626 return TRUE;
627 }
628 }
629
630 if (ev->state & GDK_SHIFT_MASK) {
631 switch (ev->keyval) {
632
633 case GDK_KEY_Return:
634 case GDK_KEY_KP_Enter:
635 key_end_turn();
636 return TRUE;
637
638 default:
639 break;
640 }
641 }
642
643 if (0 == gtk_notebook_get_current_page(GTK_NOTEBOOK(top_notebook))) {
644 /* 0 means the map view is focused. */
645 return key_press_map_canvas(w, ev, data);
646 }
647
648#if 0
649 /* We are focused some other dialog, tab, or widget. */
650 if ((ev->state & GDK_CONTROL_MASK)) {
651 } else if ((ev->state & GDK_SHIFT_MASK)) {
652 } else {
653 switch (ev->keyval) {
654
655 case GDK_KEY_F4:
656 map_canvas_focus();
657 return TRUE;
658
659 default:
660 break;
661 };
662 }
663#endif /* 0 */
664
665 return FALSE;
666}
667
668/**********************************************************************/
671 static gboolean mouse_scroll_mapcanvas(GtkWidget *w, GdkEventScroll *ev)
672{
673 int scroll_x, scroll_y, xstep, ystep;
674
675 if (!can_client_change_view()) {
676 return FALSE;
677 }
678
679 get_mapview_scroll_pos(&scroll_x, &scroll_y);
680 get_mapview_scroll_step(&xstep, &ystep);
681
682 switch (ev->direction) {
683 case GDK_SCROLL_UP:
684 scroll_y -= ystep*2;
685 break;
686 case GDK_SCROLL_DOWN:
687 scroll_y += ystep*2;
688 break;
689 case GDK_SCROLL_RIGHT:
690 scroll_x += xstep*2;
691 break;
692 case GDK_SCROLL_LEFT:
693 scroll_x -= xstep*2;
694 break;
695 default:
696 return FALSE;
697 };
698
699 set_mapview_scroll_pos(scroll_x, scroll_y, mouse_zoom);
700
701 /* Emulating mouse move now */
702 if (!gtk_widget_has_focus(map_canvas)) {
703 gtk_widget_grab_focus(map_canvas);
704 }
705
706 update_line(ev->x, ev->y);
707 if (rbutton_down && (ev->state & GDK_BUTTON3_MASK)) {
708 update_selection_rectangle(ev->x, ev->y);
709 }
710
711 if (keyboardless_goto_button_down && hover_state == HOVER_NONE) {
712 maybe_activate_keyboardless_goto(cur_x, cur_y);
713 }
714
715 control_mouse_cursor(canvas_pos_to_tile(cur_x, cur_y, mouse_zoom));
716
717 return TRUE;
718}
719
720/**********************************************************************/
723 static void tearoff_destroy(GtkWidget *w, gpointer data)
724{
725 GtkWidget *p, *b, *box;
726 GtkWidget *old_parent;
727
728 box = GTK_WIDGET(data);
729 old_parent = gtk_widget_get_parent(box);
730 p = g_object_get_data(G_OBJECT(w), "parent");
731 b = g_object_get_data(G_OBJECT(w), "toggle");
732 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b), FALSE);
733
734 gtk_widget_hide(w);
735
736 g_object_ref(box); /* Make sure reference count stays above 0
737 * during the transition to new parent. */
738 gtk_container_remove(GTK_CONTAINER(old_parent), box);
739 gtk_container_add(GTK_CONTAINER(p), box);
740 g_object_unref(box);
741}
742
743/**********************************************************************/
746 static gboolean propagate_keypress(GtkWidget *w, GdkEvent *ev)
747{
748 gtk_widget_event(toplevel, ev);
749
750 return FALSE;
751}
752
753/**********************************************************************/
757 static void tearoff_callback(GtkWidget *b, gpointer data)
758{
759 GtkWidget *box = GTK_WIDGET(data);
760
761 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b))) {
762 GtkWidget *old_parent;
763 GtkWidget *w;
764 GtkWidget *temp_hide;
765
766 old_parent = gtk_widget_get_parent(box);
767 w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
768 setup_dialog(w, toplevel);
769 gtk_widget_set_name(w, "Freeciv");
770 gtk_window_set_title(GTK_WINDOW(w), _("Freeciv"));
771 gtk_window_set_position(GTK_WINDOW(w), GTK_WIN_POS_MOUSE);
772 g_signal_connect(w, "destroy", G_CALLBACK(tearoff_destroy), box);
773 g_signal_connect(w, "key_press_event",
774 G_CALLBACK(propagate_keypress), NULL);
775
776 g_object_set_data(G_OBJECT(w), "parent", gtk_widget_get_parent(box));
777 g_object_set_data(G_OBJECT(w), "toggle", b);
778
779 temp_hide = g_object_get_data(G_OBJECT(box), "hide-over-reparent");
780 if (temp_hide != NULL) {
781 gtk_widget_hide(temp_hide);
782 }
783
784 g_object_ref(box); /* Make sure reference count stays above 0
785 * during the transition to new parent. */
786 gtk_container_remove(GTK_CONTAINER(old_parent), box);
787 gtk_container_add(GTK_CONTAINER(w), box);
788 g_object_unref(box);
789 gtk_widget_show(w);
790
791 if (temp_hide != NULL) {
792 gtk_widget_show(temp_hide);
793 }
794 } else {
795 gtk_widget_destroy(gtk_widget_get_parent(box));
796 }
797}
798
799/**********************************************************************/
802 static GtkWidget *detached_widget_new(void)
803{
804 GtkWidget *hgrid = gtk_grid_new();
805 gtk_grid_set_column_spacing(GTK_GRID(hgrid), 2);
806 return hgrid;
807}
808
809/**********************************************************************/
813 static GtkWidget *detached_widget_fill(GtkWidget *tearbox)
814{
815 GtkWidget *b, *fillbox;
816 static GtkCssProvider *detach_button_provider = NULL;
817
818 if (detach_button_provider == NULL) {
819 detach_button_provider = gtk_css_provider_new();
820
821 /* These toggle buttons run vertically down the side of many UI
822 * elements, so they need to be thin horizontally. */
823 gtk_css_provider_load_from_data(detach_button_provider,
824 ".detach_button {\n"
825 " padding: 0px 0px 0px 0px;\n"
826 " min-width: 6px;\n"
827 "}",
828 -1, NULL);
829 }
830
831 b = gtk_toggle_button_new();
832 gtk_style_context_add_provider(gtk_widget_get_style_context(b),
833 GTK_STYLE_PROVIDER(detach_button_provider),
834 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
835 gtk_style_context_add_class(gtk_widget_get_style_context(b),
836 "detach_button");
837
838 gtk_container_add(GTK_CONTAINER(tearbox), b);
839 g_signal_connect(b, "toggled", G_CALLBACK(tearoff_callback), tearbox);
840
841 fillbox = gtk_grid_new();
842 gtk_orientable_set_orientation(GTK_ORIENTABLE(fillbox),
843 GTK_ORIENTATION_VERTICAL);
844
845 gtk_container_add(GTK_CONTAINER(tearbox), fillbox);
846
847 return fillbox;
848}
849
850/**********************************************************************/
857 static void populate_unit_image_table(void)
858{
859 int i, width;
860 GtkWidget *table = unit_image_table;
861 GdkPixbuf *pix;
862 int ttw;
863
864 /* Get width of the overview window */
865 width = (overview_canvas_store_width > GUI_GTK_OVERVIEW_MIN_XSIZE)
866 ? overview_canvas_store_width
867 : GUI_GTK_OVERVIEW_MIN_XSIZE;
868
869 ttw = tileset_tile_width(tileset);
870
871 if (GUI_GTK_OPTION(small_display_layout)) {
872 /* We want arrow to appear if there is other units in addition
873 to active one in tile. Active unit is not counted, so there
874 can be 0 other units to not to display arrow. */
875 num_units_below = 1 - 1;
876 } else {
877 num_units_below = width / ttw;
878 num_units_below = CLIP(1, num_units_below, MAX_NUM_UNITS_BELOW);
879 }
880
881 /* Top row: the active unit. */
882 /* Note, we ref this and other widgets here so that we can unref them
883 * in reset_unit_table. */
884 unit_image = gtk_image_new();
885 gtk_widget_add_events(unit_image, GDK_BUTTON_PRESS_MASK);
886 g_object_ref(unit_image);
887 unit_image_button = gtk_event_box_new();
888 gtk_widget_set_size_request(unit_image_button, ttw, -1);
889 gtk_event_box_set_visible_window(GTK_EVENT_BOX(unit_image_button), FALSE);
890 g_object_ref(unit_image_button);
891 gtk_container_add(GTK_CONTAINER(unit_image_button), unit_image);
892 gtk_grid_attach(GTK_GRID(table), unit_image_button, 0, 0, 1, 1);
893 g_signal_connect(unit_image_button, "button_press_event",
894 G_CALLBACK(select_unit_image_callback),
895 GINT_TO_POINTER(-1));
896
897 if (!GUI_GTK_OPTION(small_display_layout)) {
898 /* Bottom row: other units in the same tile. */
899 for (i = 0; i < num_units_below; i++) {
900 unit_below_image[i] = gtk_image_new();
901 g_object_ref(unit_below_image[i]);
902 gtk_widget_add_events(unit_below_image[i], GDK_BUTTON_PRESS_MASK);
903 unit_below_image_button[i] = gtk_event_box_new();
904 g_object_ref(unit_below_image_button[i]);
905 gtk_widget_set_size_request(unit_below_image_button[i], ttw, -1);
906 gtk_event_box_set_visible_window(GTK_EVENT_BOX(unit_below_image_button[i]),
907 FALSE);
908 gtk_container_add(GTK_CONTAINER(unit_below_image_button[i]),
909 unit_below_image[i]);
910 g_signal_connect(unit_below_image_button[i],
911 "button_press_event",
912 G_CALLBACK(select_unit_image_callback),
913 GINT_TO_POINTER(i));
914
915 gtk_grid_attach(GTK_GRID(table), unit_below_image_button[i],
916 i, 1, 1, 1);
917 }
918 }
919
920 /* Create arrow (popup for all units on the selected tile) */
921 pix = sprite_get_pixbuf(get_arrow_sprite(tileset, ARROW_RIGHT));
922 more_arrow_pixmap = gtk_image_new_from_pixbuf(pix);
923 g_object_ref(more_arrow_pixmap);
924 more_arrow_pixmap_button = gtk_event_box_new();
925 g_object_ref(more_arrow_pixmap_button);
926 gtk_event_box_set_visible_window(GTK_EVENT_BOX(more_arrow_pixmap_button),
927 FALSE);
928 gtk_container_add(GTK_CONTAINER(more_arrow_pixmap_button),
929 more_arrow_pixmap);
930 g_signal_connect(more_arrow_pixmap_button,
931 "button_press_event",
932 G_CALLBACK(select_more_arrow_pixmap_callback), NULL);
933 /* An extra layer so that we can hide the clickable button but keep
934 * an explicit size request to avoid the layout jumping around */
935 more_arrow_pixmap_container = gtk_frame_new(NULL);
936 gtk_frame_set_shadow_type(GTK_FRAME(more_arrow_pixmap_container), GTK_SHADOW_NONE);
937 gtk_widget_set_halign(more_arrow_pixmap_container, GTK_ALIGN_CENTER);
938 gtk_widget_set_valign(more_arrow_pixmap_container, GTK_ALIGN_CENTER);
939 g_object_ref(more_arrow_pixmap_container);
940 gtk_container_add(GTK_CONTAINER(more_arrow_pixmap_container),
941 more_arrow_pixmap_button);
942 gtk_widget_set_size_request(more_arrow_pixmap_container,
943 gdk_pixbuf_get_width(pix), -1);
944 g_object_unref(G_OBJECT(pix));
945
946 if (!GUI_GTK_OPTION(small_display_layout)) {
947 /* Display on bottom row. */
948 gtk_grid_attach(GTK_GRID(table), more_arrow_pixmap_container,
949 num_units_below, 1, 1, 1);
950 } else {
951 /* Display on top row (there is no bottom row). */
952 gtk_grid_attach(GTK_GRID(table), more_arrow_pixmap_container,
953 1, 0, 1, 1);
954 }
955
956 gtk_widget_show_all(table);
957}
958
959/**********************************************************************/
962 static void free_unit_table(void)
963{
964 if (unit_image_button) {
965 gtk_container_remove(GTK_CONTAINER(unit_image_table),
966 unit_image_button);
967 g_object_unref(unit_image);
968 g_object_unref(unit_image_button);
969 if (!GUI_GTK_OPTION(small_display_layout)) {
970 int i;
971
972 for (i = 0; i < num_units_below; i++) {
973 gtk_container_remove(GTK_CONTAINER(unit_image_table),
974 unit_below_image_button[i]);
975 g_object_unref(unit_below_image[i]);
976 g_object_unref(unit_below_image_button[i]);
977 }
978 }
979 gtk_container_remove(GTK_CONTAINER(unit_image_table),
980 more_arrow_pixmap_container);
981 g_object_unref(more_arrow_pixmap);
982 g_object_unref(more_arrow_pixmap_button);
983 g_object_unref(more_arrow_pixmap_container);
984 }
985}
986
987/**********************************************************************/
990 void reset_unit_table(void)
991{
992 /* Unreference all of the widgets that we're about to reallocate, thus
993 * avoiding a memory leak. Remove them from the container first, just
994 * to be safe. Note, the widgets are ref'd in
995 * populate_unit_image_table. */
996 free_unit_table();
997
998 populate_unit_image_table();
999
1000 /* We have to force a redraw of the units. And we explicitly have
1001 * to force a redraw of the focus unit, which is normally only
1002 * redrawn when the focus changes. We also have to force the 'more'
1003 * arrow to go away, both by expicitly hiding it and telling it to
1004 * do so (this will be reset immediately afterwards if necessary,
1005 * but we have to make the *internal* state consistent). */
1006 gtk_widget_hide(more_arrow_pixmap_button);
1007 set_unit_icons_more_arrow(FALSE);
1008 if (get_num_units_in_focus() == 1) {
1009 set_unit_icon(-1, head_of_units_in_focus());
1010 } else {
1011 set_unit_icon(-1, NULL);
1012 }
1013 update_unit_pix_label(get_units_in_focus());
1014}
1015
1016/**********************************************************************/
1019 void enable_menus(bool enable)
1020{
1021 if (enable) {
1022 main_menubar = setup_menus(toplevel);
1023 /* Ensure the menus are really created before performing any operations
1024 * on them. */
1025 while (gtk_events_pending()) {
1026 gtk_main_iteration();
1027 }
1028 gtk_grid_attach_next_to(GTK_GRID(top_vbox), main_menubar, NULL, GTK_POS_TOP, 1, 1);
1029 menus_init();
1030 gtk_widget_show_all(main_menubar);
1031 } else {
1032 gtk_widget_destroy(main_menubar);
1033 }
1034}
1035
1036/**********************************************************************/
1042 static gboolean right_notebook_button_release(GtkWidget *widget,
1043 GdkEventButton *event)
1044{
1045 if (event->type != GDK_BUTTON_RELEASE) {
1046 return FALSE;
1047 }
1048
1049 if (!GTK_IS_NOTEBOOK(widget)
1050 || -1 == gtk_notebook_get_current_page(GTK_NOTEBOOK(widget))) {
1051 /* Make sure the default gtk handler
1052 * does NOT get called in this case. */
1053 return TRUE;
1054 }
1055
1056 return FALSE;
1057}
1058
1059/**********************************************************************/
1062#if 0
1063static void setup_canvas_color_for_state(GtkStateFlags state)
1064{
1065 gtk_widget_override_background_color(GTK_WIDGET(overview_canvas), state,
1066 &get_color(tileset, COLOR_OVERVIEW_UNKNOWN)->color);
1067 gtk_widget_override_background_color(GTK_WIDGET(map_canvas), state,
1068 &get_color(tileset, COLOR_OVERVIEW_UNKNOWN)->color);
1069}
1070#endif
1071
1072/**********************************************************************/
1075 void update_turn_done_tooltip(void)
1076{
1077 struct option *opt = optset_option_by_name(server_optset, "fixedlength");
1078
1079 if (opt != NULL && option_bool_get(opt)) {
1080 gtk_widget_set_tooltip_text(turn_done_button,
1081 _("Fixed length turns"));
1082 } else {
1083 char buf[256];
1084
1085 fc_snprintf(buf, sizeof(buf), "%s:\n%s",
1086 _("Turn Done"), _("Shift+Return"));
1087 gtk_widget_set_tooltip_text(turn_done_button, buf);
1088 }
1089}
1090
1091/**********************************************************************/
1094 static void setup_widgets(void)
1095{
1096 GtkWidget *page, *ebox, *hgrid, *hgrid2, *label;
1097 GtkWidget *frame, *table, *table2, *paned, *sw, *text;
1098 GtkWidget *button, *view, *vgrid, *right_vbox = NULL;
1099 int i;
1100 GtkWidget *notebook, *statusbar;
1101 GtkWidget *dtach_lowbox = NULL;
1102 struct sprite *spr;
1103
1104 message_buffer = gtk_text_buffer_new(NULL);
1105
1106 notebook = gtk_notebook_new();
1107
1108 /* Stop mouse wheel notebook page switching. */
1109 g_signal_connect(notebook, "scroll_event",
1110 G_CALLBACK(gtk_true), NULL);
1111
1112 toplevel_tabs = notebook;
1113 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
1114 gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
1115 vgrid = gtk_grid_new();
1116 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1117 GTK_ORIENTATION_VERTICAL);
1118 gtk_grid_set_row_spacing(GTK_GRID(vgrid), 4);
1119 gtk_container_add(GTK_CONTAINER(toplevel), vgrid);
1120 gtk_container_add(GTK_CONTAINER(vgrid), notebook);
1121 statusbar = create_statusbar();
1122 gtk_container_add(GTK_CONTAINER(vgrid), statusbar);
1123
1124 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1125 create_main_page(), NULL);
1126 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1127 create_start_page(), NULL);
1128 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1129 create_scenario_page(), NULL);
1130 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1131 create_load_page(), NULL);
1132 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1133 create_network_page(), NULL);
1134
1135 editgui_create_widgets();
1136
1137 ingame_votebar = voteinfo_bar_new(FALSE);
1138 g_object_set(ingame_votebar, "margin", 2, NULL);
1139
1140 /* *** everything in the top *** */
1141
1142 page = gtk_scrolled_window_new(NULL, NULL);
1143 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(page),
1144 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1145 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(page),
1146 GTK_SHADOW_ETCHED_IN);
1147 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, NULL);
1148
1149 top_vbox = gtk_grid_new();
1150 gtk_orientable_set_orientation(GTK_ORIENTABLE(top_vbox),
1151 GTK_ORIENTATION_VERTICAL);
1152 gtk_grid_set_row_spacing(GTK_GRID(top_vbox), 5);
1153 hgrid = gtk_grid_new();
1154
1155 if (GUI_GTK_OPTION(small_display_layout)) {
1156 /* The window is divided into two horizontal panels: overview +
1157 * civinfo + unitinfo, main view + message window. */
1158 right_vbox = gtk_grid_new();
1159 gtk_orientable_set_orientation(GTK_ORIENTABLE(right_vbox),
1160 GTK_ORIENTATION_VERTICAL);
1161 gtk_container_add(GTK_CONTAINER(hgrid), right_vbox);
1162
1163 paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1164 gtk_container_add(GTK_CONTAINER(page), top_vbox);
1165 gtk_container_add(GTK_CONTAINER(top_vbox), hgrid);
1166 gtk_container_add(GTK_CONTAINER(right_vbox), paned);
1167 gtk_container_add(GTK_CONTAINER(right_vbox), ingame_votebar);
1168
1169 /* Overview size designed for small displays (netbooks). */
1170 overview_canvas_store_width = OVERVIEW_CANVAS_STORE_WIDTH_NETBOOK;
1171 overview_canvas_store_height = OVERVIEW_CANVAS_STORE_HEIGHT_NETBOOK;
1172 } else {
1173 /* The window is divided into two vertical panes: overview +
1174 * + civinfo + unitinfo + main view, message window. */
1175 paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
1176 gtk_container_add(GTK_CONTAINER(page), paned);
1177 gtk_paned_pack1(GTK_PANED(paned), top_vbox, TRUE, FALSE);
1178 gtk_container_add(GTK_CONTAINER(top_vbox), hgrid);
1179
1180 /* Overview size designed for big displays (desktops). */
1181 overview_canvas_store_width = OVERVIEW_CANVAS_STORE_WIDTH;
1182 overview_canvas_store_height = OVERVIEW_CANVAS_STORE_HEIGHT;
1183 }
1184
1185 /* this holds the overview canvas, production info, etc. */
1186 vgrid = gtk_grid_new();
1187 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1188 GTK_ORIENTATION_VERTICAL);
1189 gtk_grid_set_column_spacing(GTK_GRID(vgrid), 3);
1190 /* Put vgrid to the left of anything else in hgrid -- right_vbox is either
1191 * the chat/messages pane, or NULL which is OK */
1192 gtk_grid_attach_next_to(GTK_GRID(hgrid), vgrid, right_vbox,
1193 GTK_POS_LEFT, 1, 1);
1194
1195 /* Overview canvas */
1196 ahbox = detached_widget_new();
1197 gtk_widget_set_hexpand(ahbox, FALSE);
1198 gtk_widget_set_vexpand(ahbox, FALSE);
1199 gtk_container_add(GTK_CONTAINER(vgrid), ahbox);
1200 avbox = detached_widget_fill(ahbox);
1201
1202 overview_scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1203 gtk_container_set_border_width(GTK_CONTAINER (overview_scrolled_window), 1);
1204 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (overview_scrolled_window),
1205 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1206
1207 overview_canvas = gtk_drawing_area_new();
1208 gtk_widget_set_halign(overview_canvas, GTK_ALIGN_CENTER);
1209 gtk_widget_set_valign(overview_canvas, GTK_ALIGN_CENTER);
1210 gtk_widget_set_size_request(overview_canvas, overview_canvas_store_width,
1211 overview_canvas_store_height);
1212 gtk_widget_set_size_request(overview_scrolled_window, overview_canvas_store_width,
1213 overview_canvas_store_height);
1214 gtk_widget_set_hexpand(overview_canvas, TRUE);
1215 gtk_widget_set_vexpand(overview_canvas, TRUE);
1216
1217 gtk_widget_add_events(overview_canvas, GDK_EXPOSURE_MASK
1218 |GDK_BUTTON_PRESS_MASK
1219 |GDK_POINTER_MOTION_MASK);
1220 gtk_container_add(GTK_CONTAINER(avbox), overview_scrolled_window);
1221
1222 gtk_container_add(GTK_CONTAINER(overview_scrolled_window),
1223 overview_canvas);
1224
1225 g_signal_connect(overview_canvas, "draw",
1226 G_CALLBACK(overview_canvas_draw), NULL);
1227
1228 g_signal_connect(overview_canvas, "motion_notify_event",
1229 G_CALLBACK(move_overviewcanvas), NULL);
1230
1231 g_signal_connect(overview_canvas, "button_press_event",
1232 G_CALLBACK(butt_down_overviewcanvas), NULL);
1233
1234 /* The rest */
1235
1236 ahbox = detached_widget_new();
1237 gtk_container_add(GTK_CONTAINER(vgrid), ahbox);
1238 gtk_widget_set_hexpand(ahbox, FALSE);
1239 avbox = detached_widget_fill(ahbox);
1240 gtk_widget_set_vexpand(avbox, TRUE);
1241 gtk_widget_set_valign(avbox, GTK_ALIGN_FILL);
1242
1243 /* Info on player's civilization, when game is running. */
1244 frame = gtk_frame_new("");
1245 gtk_container_add(GTK_CONTAINER(avbox), frame);
1246
1247 main_frame_civ_name = frame;
1248
1249 vgrid = gtk_grid_new();
1250 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1251 GTK_ORIENTATION_VERTICAL);
1252 gtk_container_add(GTK_CONTAINER(frame), vgrid);
1253 gtk_widget_set_hexpand(vgrid, TRUE);
1254
1255 ebox = gtk_event_box_new();
1256 gtk_widget_add_events(ebox, GDK_BUTTON_PRESS_MASK);
1257 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
1258 g_signal_connect(ebox, "button_press_event",
1259 G_CALLBACK(show_info_popup), NULL);
1260 gtk_container_add(GTK_CONTAINER(vgrid), ebox);
1261
1262 label = gtk_label_new(NULL);
1263 gtk_widget_set_halign(label, GTK_ALIGN_START);
1264 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
1265 gtk_widget_set_margin_start(label, 2);
1266 gtk_widget_set_margin_end(label, 2);
1267 gtk_widget_set_margin_top(label, 2);
1268 gtk_widget_set_margin_bottom(label, 2);
1269 gtk_container_add(GTK_CONTAINER(ebox), label);
1270 main_label_info = label;
1271
1272 /* Production status */
1273 table = gtk_grid_new();
1274 gtk_widget_set_halign(table, GTK_ALIGN_CENTER);
1275 gtk_grid_set_column_homogeneous(GTK_GRID(table), TRUE);
1276 gtk_container_add(GTK_CONTAINER(avbox), table);
1277
1278 /* Citizens for taxrates */
1279 ebox = gtk_event_box_new();
1280 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
1281 gtk_grid_attach(GTK_GRID(table), ebox, 0, 0, 10, 1);
1282 econ_ebox = ebox;
1283
1284 table2 = gtk_grid_new();
1285 gtk_container_add(GTK_CONTAINER(ebox), table2);
1286
1287 for (i = 0; i < 10; i++) {
1288 ebox = gtk_event_box_new();
1289 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
1290 gtk_widget_add_events(ebox, GDK_BUTTON_PRESS_MASK);
1291
1292 gtk_grid_attach(GTK_GRID(table2), ebox, i, 0, 1, 1);
1293
1294 g_signal_connect(ebox, "button_press_event",
1295 G_CALLBACK(taxrates_callback), GINT_TO_POINTER(i));
1296
1297 spr = i < 5 ? get_tax_sprite(tileset, O_SCIENCE) : get_tax_sprite(tileset, O_GOLD);
1298 econ_label[i] = gtk_image_new_from_surface(spr->surface);
1299 gtk_container_add(GTK_CONTAINER(ebox), econ_label[i]);
1300 }
1301
1302 /* Science, environmental, govt, timeout */
1303 spr = client_research_sprite();
1304 if (spr != NULL) {
1305 bulb_label = gtk_image_new_from_surface(spr->surface);
1306 } else {
1307 bulb_label = gtk_image_new();
1308 }
1309
1310 spr = client_warming_sprite();
1311 if (spr != NULL) {
1312 sun_label = gtk_image_new_from_surface(spr->surface);
1313 } else {
1314 sun_label = gtk_image_new();
1315 }
1316
1317 spr = client_cooling_sprite();
1318 if (spr != NULL) {
1319 flake_label = gtk_image_new_from_surface(spr->surface);
1320 } else {
1321 flake_label = gtk_image_new();
1322 }
1323
1324 spr = client_government_sprite();
1325 if (spr != NULL) {
1326 government_label = gtk_image_new_from_surface(spr->surface);
1327 } else {
1328 government_label = gtk_image_new();
1329 }
1330
1331 for (i = 0; i < 4; i++) {
1332 GtkWidget *w;
1333
1334 ebox = gtk_event_box_new();
1335 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
1336
1337 switch (i) {
1338 case 0:
1339 w = bulb_label;
1340 bulb_ebox = ebox;
1341 break;
1342 case 1:
1343 w = sun_label;
1344 sun_ebox = ebox;
1345 break;
1346 case 2:
1347 w = flake_label;
1348 flake_ebox = ebox;
1349 break;
1350 default:
1351 case 3:
1352 w = government_label;
1353 government_ebox = ebox;
1354 break;
1355 }
1356
1357 gtk_widget_set_halign(w, GTK_ALIGN_START);
1358 gtk_widget_set_valign(w, GTK_ALIGN_START);
1359 gtk_widget_set_margin_start(w, 0);
1360 gtk_widget_set_margin_end(w, 0);
1361 gtk_widget_set_margin_top(w, 0);
1362 gtk_widget_set_margin_bottom(w, 0);
1363 gtk_container_add(GTK_CONTAINER(ebox), w);
1364 gtk_grid_attach(GTK_GRID(table), ebox, i, 1, 1, 1);
1365 }
1366
1367 timeout_label = gtk_label_new("");
1368
1369 frame = gtk_frame_new(NULL);
1370 gtk_grid_attach(GTK_GRID(table), frame, 4, 1, 6, 1);
1371 gtk_container_add(GTK_CONTAINER(frame), timeout_label);
1372
1373
1374 /* Turn done */
1375 turn_done_button = gtk_button_new_with_label(_("Turn Done"));
1376
1377 gtk_grid_attach(GTK_GRID(table), turn_done_button, 0, 2, 10, 1);
1378
1379 g_signal_connect(turn_done_button, "clicked",
1380 G_CALLBACK(end_turn_callback), NULL);
1381 update_turn_done_tooltip();
1382
1383 /* Selected unit status */
1384
1385 unit_info_box = gtk_grid_new();
1386 gtk_widget_set_hexpand(unit_info_box, FALSE);
1387 gtk_orientable_set_orientation(GTK_ORIENTABLE(unit_info_box),
1388 GTK_ORIENTATION_VERTICAL);
1389 gtk_container_add(GTK_CONTAINER(avbox), unit_info_box);
1390
1391 /* In edit mode the unit_info_box widget is replaced by the
1392 * editinfobox, so we need to add a ref here so that it is
1393 * not destroyed when removed from its container.
1394 * See editinfobox_refresh(). */
1395 g_object_ref(unit_info_box);
1396
1397 unit_info_frame = gtk_frame_new("");
1398 gtk_container_add(GTK_CONTAINER(unit_info_box), unit_info_frame);
1399
1400 sw = gtk_scrolled_window_new(NULL, NULL);
1401 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
1402 GTK_SHADOW_OUT);
1403 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
1404 GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
1405 gtk_container_add(GTK_CONTAINER(unit_info_frame), sw);
1406
1407 label = gtk_label_new(NULL);
1408 gtk_widget_set_hexpand(label, TRUE);
1409 gtk_widget_set_halign(label, GTK_ALIGN_START);
1410 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
1411 gtk_widget_set_margin_start(label, 2);
1412 gtk_widget_set_margin_end(label, 2);
1413 gtk_widget_set_margin_top(label, 2);
1414 gtk_widget_set_margin_bottom(label, 2);
1415 gtk_container_add(GTK_CONTAINER(sw), label);
1416 unit_info_label = label;
1417
1418 hgrid2 = gtk_grid_new();
1419 gtk_container_add(GTK_CONTAINER(unit_info_box), hgrid2);
1420
1421 table = gtk_grid_new();
1422 g_object_set(table, "margin", 5, NULL);
1423 gtk_container_add(GTK_CONTAINER(hgrid2), table);
1424
1425 gtk_grid_set_row_spacing(GTK_GRID(table), 2);
1426 gtk_grid_set_column_spacing(GTK_GRID(table), 2);
1427
1428 unit_image_table = table;
1429
1430 /* Map canvas, editor toolbar, and scrollbars */
1431
1432 /* The top notebook containing the map view and dialogs. */
1433
1434 top_notebook = gtk_notebook_new();
1435 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(top_notebook), GTK_POS_BOTTOM);
1436 gtk_notebook_set_scrollable(GTK_NOTEBOOK(top_notebook), TRUE);
1437
1438
1439 if (GUI_GTK_OPTION(small_display_layout)) {
1440 gtk_paned_pack1(GTK_PANED(paned), top_notebook, TRUE, FALSE);
1441 } else if (GUI_GTK_OPTION(message_chat_location) == GUI_GTK_MSGCHAT_MERGED) {
1442 right_vbox = gtk_grid_new();
1443 gtk_orientable_set_orientation(GTK_ORIENTABLE(right_vbox),
1444 GTK_ORIENTATION_VERTICAL);
1445
1446 gtk_container_add(GTK_CONTAINER(right_vbox), top_notebook);
1447 gtk_container_add(GTK_CONTAINER(right_vbox), ingame_votebar);
1448 gtk_container_add(GTK_CONTAINER(hgrid), right_vbox);
1449 } else {
1450 gtk_container_add(GTK_CONTAINER(hgrid), top_notebook);
1451 }
1452
1453 map_widget = gtk_grid_new();
1454
1455 vgrid = gtk_grid_new();
1456 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1457 GTK_ORIENTATION_VERTICAL);
1458 gtk_container_add(GTK_CONTAINER(vgrid), map_widget);
1459
1460 gtk_container_add(GTK_CONTAINER(vgrid), editgui_get_editbar()->widget);
1461 g_object_set(editgui_get_editbar()->widget, "margin", 4, NULL);
1462
1463 label = gtk_label_new(Q_("?noun:View"));
1464 gtk_notebook_append_page(GTK_NOTEBOOK(top_notebook), vgrid, label);
1465
1466 frame = gtk_frame_new(NULL);
1467 gtk_grid_attach(GTK_GRID(map_widget), frame, 0, 0, 1, 1);
1468
1469 map_canvas = gtk_drawing_area_new();
1470 gtk_widget_set_hexpand(map_canvas, TRUE);
1471 gtk_widget_set_vexpand(map_canvas, TRUE);
1472 gtk_widget_set_size_request(map_canvas, 300, 300);
1473 gtk_widget_set_can_focus(map_canvas, TRUE);
1474
1475#if 0
1476 setup_canvas_color_for_state(GTK_STATE_FLAG_NORMAL);
1477 setup_canvas_color_for_state(GTK_STATE_FLAG_ACTIVE);
1478 setup_canvas_color_for_state(GTK_STATE_FLAG_PRELIGHT);
1479 setup_canvas_color_for_state(GTK_STATE_FLAG_SELECTED);
1480 setup_canvas_color_for_state(GTK_STATE_FLAG_INSENSITIVE);
1481 setup_canvas_color_for_state(GTK_STATE_FLAG_INCONSISTENT);
1482 setup_canvas_color_for_state(GTK_STATE_FLAG_FOCUSED);
1483 setup_canvas_color_for_state(GTK_STATE_FLAG_BACKDROP);
1484#endif /* 0 */
1485
1486 gtk_widget_add_events(map_canvas, GDK_EXPOSURE_MASK
1487 |GDK_BUTTON_PRESS_MASK
1488 |GDK_BUTTON_RELEASE_MASK
1489 |GDK_KEY_PRESS_MASK
1490 |GDK_POINTER_MOTION_MASK
1491 |GDK_SCROLL_MASK);
1492
1493 gtk_container_add(GTK_CONTAINER(frame), map_canvas);
1494
1495 map_horizontal_scrollbar =
1496 gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);
1497 gtk_grid_attach(GTK_GRID(map_widget), map_horizontal_scrollbar, 0, 1, 1, 1);
1498
1499 map_vertical_scrollbar =
1500 gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);
1501 gtk_grid_attach(GTK_GRID(map_widget), map_vertical_scrollbar, 1, 0, 1, 1);
1502
1503 g_signal_connect(map_canvas, "draw",
1504 G_CALLBACK(map_canvas_draw), NULL);
1505
1506 g_signal_connect(map_canvas, "configure_event",
1507 G_CALLBACK(map_canvas_configure), NULL);
1508
1509 g_signal_connect(map_canvas, "motion_notify_event",
1510 G_CALLBACK(move_mapcanvas), NULL);
1511
1512 g_signal_connect(toplevel, "enter_notify_event",
1513 G_CALLBACK(leave_mapcanvas), NULL);
1514
1515 g_signal_connect(map_canvas, "button_press_event",
1516 G_CALLBACK(butt_down_mapcanvas), NULL);
1517
1518 g_signal_connect(map_canvas, "button_release_event",
1519 G_CALLBACK(butt_release_mapcanvas), NULL);
1520
1521 g_signal_connect(map_canvas, "scroll_event",
1522 G_CALLBACK(mouse_scroll_mapcanvas), NULL);
1523
1524 g_signal_connect(toplevel, "key_press_event",
1525 G_CALLBACK(toplevel_key_press_handler), NULL);
1526
1527 g_signal_connect(toplevel, "key_release_event",
1528 G_CALLBACK(toplevel_key_release_handler), NULL);
1529
1530 /* *** The message window -- this is a detachable widget *** */
1531
1532 if (GUI_GTK_OPTION(message_chat_location) == GUI_GTK_MSGCHAT_MERGED) {
1533 bottom_hpaned = paned;
1534 right_notebook = bottom_notebook = top_notebook;
1535 } else {
1536 GtkWidget *hpaned;
1537
1538 dtach_lowbox = detached_widget_new();
1539 gtk_paned_pack2(GTK_PANED(paned), dtach_lowbox, FALSE, TRUE);
1540 avbox = detached_widget_fill(dtach_lowbox);
1541
1542 vgrid = gtk_grid_new();
1543 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1544 GTK_ORIENTATION_VERTICAL);
1545 if (!GUI_GTK_OPTION(small_display_layout)) {
1546 gtk_container_add(GTK_CONTAINER(vgrid), ingame_votebar);
1547 }
1548 gtk_container_add(GTK_CONTAINER(avbox), vgrid);
1549
1550 if (GUI_GTK_OPTION(small_display_layout)) {
1551 hpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
1552 } else {
1553 hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1554 }
1555 gtk_container_add(GTK_CONTAINER(vgrid), hpaned);
1556 g_object_set(hpaned, "margin", 4, NULL);
1557 bottom_hpaned = hpaned;
1558
1559 bottom_notebook = gtk_notebook_new();
1560 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(bottom_notebook), GTK_POS_TOP);
1561 gtk_notebook_set_scrollable(GTK_NOTEBOOK(bottom_notebook), TRUE);
1562 gtk_paned_pack1(GTK_PANED(hpaned), bottom_notebook, TRUE, TRUE);
1563
1564 right_notebook = gtk_notebook_new();
1565 g_object_ref(right_notebook);
1566 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(right_notebook), GTK_POS_TOP);
1567 gtk_notebook_set_scrollable(GTK_NOTEBOOK(right_notebook), TRUE);
1568 g_signal_connect(right_notebook, "button-release-event",
1569 G_CALLBACK(right_notebook_button_release), NULL);
1570 if (GUI_GTK_OPTION(message_chat_location) == GUI_GTK_MSGCHAT_SPLIT) {
1571 gtk_paned_pack2(GTK_PANED(hpaned), right_notebook, TRUE, TRUE);
1572 }
1573 }
1574
1575 vgrid = gtk_grid_new();
1576 gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
1577 GTK_ORIENTATION_VERTICAL);
1578
1579 sw = gtk_scrolled_window_new(NULL, NULL);
1580 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
1581 GTK_SHADOW_ETCHED_IN);
1582 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC,
1583 GTK_POLICY_ALWAYS);
1584 gtk_container_add(GTK_CONTAINER(vgrid), sw);
1585
1586 label = gtk_label_new(_("Chat"));
1587 gtk_notebook_append_page(GTK_NOTEBOOK(bottom_notebook), vgrid, label);
1588
1589 text = gtk_text_view_new_with_buffer(message_buffer);
1590 gtk_widget_set_hexpand(text, TRUE);
1591 gtk_widget_set_vexpand(text, TRUE);
1592 set_message_buffer_view_link_handlers(text);
1593 gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
1594 gtk_container_add(GTK_CONTAINER(sw), text);
1595 g_signal_connect(text, "size-allocate",
1596 G_CALLBACK(main_message_area_size_allocate), NULL);
1597
1598 gtk_widget_set_name(text, "chatline");
1599
1600 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
1601 gtk_widget_realize(text);
1602 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5);
1603
1604 main_message_area = GTK_TEXT_VIEW(text);
1605 if (dtach_lowbox != NULL) {
1606 g_object_set_data(G_OBJECT(dtach_lowbox), "hide-over-reparent", main_message_area);
1607 }
1608
1609 chat_welcome_message(TRUE);
1610
1611 /* the chat line */
1612 view = inputline_toolkit_view_new();
1613 gtk_container_add(GTK_CONTAINER(vgrid), view);
1614 g_object_set(view, "margin", 3, NULL);
1615
1616 button = gtk_check_button_new_with_label(_("Allies Only"));
1617 gtk_widget_set_focus_on_click(button, FALSE);
1618 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
1619 GUI_GTK_OPTION(allied_chat_only));
1620 g_signal_connect(button, "toggled",
1621 G_CALLBACK(allied_chat_button_toggled), NULL);
1622 inputline_toolkit_view_append_button(view, button);
1623 allied_chat_toggle_button = button;
1624
1625 button = gtk_button_new_with_label(_("Clear links"));
1626 g_signal_connect(button, "clicked",
1627 G_CALLBACK(link_marks_clear_all), NULL);
1628 inputline_toolkit_view_append_button(view, button);
1629
1630 /* Other things to take care of */
1631
1632 gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(toplevel)));
1633
1634 if (GUI_GTK_OPTION(enable_tabs)) {
1635 meswin_dialog_popup(FALSE);
1636 }
1637
1638 gtk_notebook_set_current_page(GTK_NOTEBOOK(top_notebook), 0);
1639 gtk_notebook_set_current_page(GTK_NOTEBOOK(bottom_notebook), 0);
1640
1641 if (!GUI_GTK_OPTION(map_scrollbars)) {
1642 gtk_widget_hide(map_horizontal_scrollbar);
1643 gtk_widget_hide(map_vertical_scrollbar);
1644 }
1645}
1646
1647/**********************************************************************/
1650 static void g_log_to_freelog_cb(const gchar *log_domain,
1651 GLogLevelFlags log_level,
1652 const gchar *message,
1653 gpointer user_data)
1654{
1655 enum log_level fllvl = LOG_ERROR;
1656
1657 switch (log_level) {
1658 case G_LOG_LEVEL_DEBUG:
1659 fllvl = LOG_DEBUG;
1660 break;
1661 case G_LOG_LEVEL_WARNING:
1662 fllvl = LOG_WARN;
1663 break;
1664 default:
1665 break;
1666 }
1667
1668 if (log_domain != NULL) {
1669 log_base(fllvl, "%s: %s", log_domain, message);
1670 } else {
1671 log_base(fllvl, "%s", message);
1672 }
1673}
1674
1675/**********************************************************************/
1678 static GLogWriterOutput g_log_writer_to_freelog_cb(GLogLevelFlags log_level,
1679 const GLogField *fields,
1680 gsize n_fields,
1681 gpointer user_data)
1682{
1683 /* No need to have formatter of our own - let's use glib's default one. */
1684 gchar *out = g_log_writer_format_fields(log_level, fields, n_fields, FALSE);
1685
1686 g_log_to_freelog_cb(NULL, log_level, out, NULL);
1687
1688 return G_LOG_WRITER_HANDLED;
1689}
1690
1691/**********************************************************************/
1694 static void set_g_log_callback_domain(const char *domain)
1695{
1696 g_log_set_handler(domain,
1697 G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING
1698 | G_LOG_LEVEL_MASK
1699 | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
1700 g_log_to_freelog_cb, NULL);
1701}
1702
1703/**********************************************************************/
1706 static void set_g_log_callbacks(void)
1707{
1708 /* Old API, still used by many log producers */
1709 g_log_set_default_handler(g_log_to_freelog_cb, NULL);
1710
1711 set_g_log_callback_domain("Gtk");
1712 set_g_log_callback_domain("Gdk");
1713 set_g_log_callback_domain("Glib");
1714
1715 /* glib >= 2.50 API */
1716 g_log_set_writer_func(g_log_writer_to_freelog_cb, NULL, NULL);
1717}
1718
1719/**********************************************************************/
1722 void ui_init(void)
1723{
1724 log_set_callback(log_callback_utf8);
1725 set_g_log_callbacks();
1726 set_frame_by_frame_animation();
1727}
1728
1729/**********************************************************************/
1732 int main(int argc, char **argv)
1733{
1734 return client_main(argc, argv, FALSE);
1735}
1736
1737/**********************************************************************/
1740 static void migrate_options_from_gtk2(void)
1741{
1742 log_normal(_("Migrating options from gtk2 to gtk3 client"));
1743
1744#define MIGRATE_OPTION(opt) gui_options.gui_gtk3_##opt = gui_options.gui_gtk2_##opt;
1745#define MIGRATE_STR_OPTION(opt) \
1746 strncpy(gui_options.gui_gtk3_##opt, gui_options.gui_gtk2_##opt, \
1747 sizeof(gui_options.gui_gtk3_##opt));
1748
1749 /* Default theme name is never migrated */
1750 /* 'fullscreen', 'small_display_layout', and 'message_chat_location'
1751 * not migrated, as (unlike Gtk2), Gtk3-client tries to pick better
1752 * defaults for these in fresh installations based on screen size (see
1753 * adjust_default_options()); so user is probably better served by
1754 * getting these adaptive defaults than whatever they had for Gtk2.
1755 * Since 'fullscreen' isn't migrated, we don't need to worry about
1756 * preserving gui_gtk2_migrated_from_2_5 either. */
1757 MIGRATE_OPTION(map_scrollbars);
1758 MIGRATE_OPTION(dialogs_on_top);
1759 MIGRATE_OPTION(show_task_icons);
1760 MIGRATE_OPTION(enable_tabs);
1761 MIGRATE_OPTION(show_chat_message_time);
1762 MIGRATE_OPTION(new_messages_go_to_top);
1763 MIGRATE_OPTION(show_message_window_buttons);
1764 MIGRATE_OPTION(metaserver_tab_first);
1765 MIGRATE_OPTION(allied_chat_only);
1766 MIGRATE_OPTION(mouse_over_map_focus);
1767 MIGRATE_OPTION(chatline_autocompletion);
1768 MIGRATE_OPTION(citydlg_xsize);
1769 MIGRATE_OPTION(citydlg_ysize);
1770 MIGRATE_OPTION(popup_tech_help);
1771
1772 MIGRATE_STR_OPTION(font_city_label);
1773 MIGRATE_STR_OPTION(font_notify_label);
1774 MIGRATE_STR_OPTION(font_spaceship_label);
1775 MIGRATE_STR_OPTION(font_help_label);
1776 MIGRATE_STR_OPTION(font_help_link);
1777 MIGRATE_STR_OPTION(font_help_text);
1778 MIGRATE_STR_OPTION(font_chatline);
1779 MIGRATE_STR_OPTION(font_beta_label);
1780 MIGRATE_STR_OPTION(font_small);
1781 MIGRATE_STR_OPTION(font_comment_label);
1782 MIGRATE_STR_OPTION(font_city_names);
1783 MIGRATE_STR_OPTION(font_city_productions);
1784 MIGRATE_STR_OPTION(font_reqtree_text);
1785
1786#undef MIGRATE_OPTION
1787#undef MIGRATE_STR_OPTION
1788
1789 gui_options.gui_gtk3_migrated_from_gtk2 = TRUE;
1790}
1791
1792/**********************************************************************/
1795 static void migrate_options_from_gtk3(void)
1796{
1797 log_normal(_("Migrating options from gtk3 to gtk3.22 client"));
1798
1799#define MIGRATE_OPTION(opt) GUI_GTK_OPTION(opt) = gui_options.gui_gtk3_##opt;
1800#define MIGRATE_STR_OPTION(opt) \
1801 strncpy(GUI_GTK_OPTION(opt), gui_options.gui_gtk3_##opt, \
1802 sizeof(GUI_GTK_OPTION(opt)));
1803
1804 /* Default theme name is never migrated */
1805
1806 /* Simulate gui-gtk3's migrate_options_from_2_5() */
1807 if (!gui_options.gui_gtk3_migrated_from_2_5) {
1808 log_normal(_("Migrating gtk3-client options from freeciv-2.5 options."));
1809 gui_options.gui_gtk3_fullscreen = gui_options.migrate_fullscreen;
1810 gui_options.gui_gtk3_migrated_from_2_5 = TRUE;
1811 }
1812
1813 MIGRATE_OPTION(fullscreen);
1814 MIGRATE_OPTION(map_scrollbars);
1815 MIGRATE_OPTION(dialogs_on_top);
1816 MIGRATE_OPTION(show_task_icons);
1817 MIGRATE_OPTION(enable_tabs);
1818 MIGRATE_OPTION(show_chat_message_time);
1819 MIGRATE_OPTION(new_messages_go_to_top);
1820 MIGRATE_OPTION(show_message_window_buttons);
1821 MIGRATE_OPTION(metaserver_tab_first);
1822 MIGRATE_OPTION(allied_chat_only);
1823 MIGRATE_OPTION(message_chat_location);
1824 MIGRATE_OPTION(small_display_layout);
1825 MIGRATE_OPTION(mouse_over_map_focus);
1826 MIGRATE_OPTION(chatline_autocompletion);
1827 MIGRATE_OPTION(citydlg_xsize);
1828 MIGRATE_OPTION(citydlg_ysize);
1829 MIGRATE_OPTION(popup_tech_help);
1830
1831 MIGRATE_STR_OPTION(font_city_label);
1832 MIGRATE_STR_OPTION(font_notify_label);
1833 MIGRATE_STR_OPTION(font_spaceship_label);
1834 MIGRATE_STR_OPTION(font_help_label);
1835 MIGRATE_STR_OPTION(font_help_link);
1836 MIGRATE_STR_OPTION(font_help_text);
1837 MIGRATE_STR_OPTION(font_chatline);
1838 MIGRATE_STR_OPTION(font_beta_label);
1839 MIGRATE_STR_OPTION(font_small);
1840 MIGRATE_STR_OPTION(font_comment_label);
1841 MIGRATE_STR_OPTION(font_city_names);
1842 MIGRATE_STR_OPTION(font_city_productions);
1843 MIGRATE_STR_OPTION(font_reqtree_text);
1844
1845#undef MIGRATE_OPTION
1846#undef MIGRATE_STR_OPTION
1847
1848 GUI_GTK_OPTION(migrated_from_gtk3) = TRUE;
1849}
1850
1851/**********************************************************************/
1854 int ui_main(int argc, char **argv)
1855{
1856 PangoFontDescription *toplevel_font_name;
1857 guint sig;
1858
1859 if (parse_options(argc, argv)) {
1860 char window_name[1024];
1861
1862 /* The locale has already been set in init_nls() and the windows-specific
1863 * locale logic in gtk_init() causes problems with zh_CN (see PR#39475) */
1864 gtk_disable_setlocale();
1865
1866 /* GTK withdraw gtk options. Process GTK arguments */
1867 if (!gtk_init_check(&argc, &argv)) {
1868 log_fatal(_("Failed to open graphical mode."));
1869 exit(EXIT_FAILURE);
1870 }
1871
1872 help_system_init();
1873
1874 dlg_tab_provider_prepare();
1875
1876 toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1877 gtk_window_set_position(GTK_WINDOW(toplevel), GTK_WIN_POS_CENTER);
1878 if (vmode.width > 0 && vmode.height > 0) {
1879 gtk_window_resize(GTK_WINDOW(toplevel), vmode.width, vmode.height);
1880 }
1881 g_signal_connect(toplevel, "key_press_event",
1882 G_CALLBACK(toplevel_handler), NULL);
1883
1884 gtk_window_set_role(GTK_WINDOW(toplevel), "toplevel");
1885 gtk_widget_realize(toplevel);
1886 gtk_widget_set_name(toplevel, "Freeciv");
1887 root_window = gtk_widget_get_window(toplevel);
1888
1889 if (gui_options.first_boot) {
1890 adjust_default_options();
1891 /* We're using fresh defaults for this version of this client,
1892 * so prevent any future migrations from other clients / versions */
1893 GUI_GTK_OPTION(migrated_from_gtk3) = TRUE;
1894 /* Avoid also marking gtk3 as migrated, so that it can have its own
1895 * run of its adjust_default_options() if it is ever run (as a
1896 * side effect of Gtk2->Gtk3 migration). */
1897 } else {
1898 if (!GUI_GTK_OPTION(migrated_from_gtk3)) {
1899 if (!gui_options.gui_gtk3_migrated_from_gtk2) {
1900 migrate_options_from_gtk2();
1901 /* We want a fresh look at screen-size-related options after Gtk2 */
1902 adjust_default_options();
1903 /* We don't ever want to consider pre-2.6 fullscreen option again
1904 * (even for gui-gtk3) */
1905 gui_options.gui_gtk3_migrated_from_2_5 = TRUE;
1906 }
1907 migrate_options_from_gtk3();
1908 }
1909 }
1910
1911 if (GUI_GTK_OPTION(fullscreen)) {
1912 gtk_window_fullscreen(GTK_WINDOW(toplevel));
1913 }
1914
1915 fc_snprintf(window_name, sizeof(window_name), _("Freeciv (%s)"), GUI_NAME_SHORT);
1916 gtk_window_set_title(GTK_WINDOW(toplevel), window_name);
1917
1918 g_signal_connect(toplevel, "delete_event",
1919 G_CALLBACK(quit_dialog_callback), NULL);
1920
1921 /* Disable GTK+ cursor key focus movement */
1922 sig = g_signal_lookup("focus", GTK_TYPE_WIDGET);
1923 g_signal_handlers_disconnect_matched(toplevel, G_SIGNAL_MATCH_ID, sig,
1924 0, 0, 0, 0);
1925 g_signal_connect(toplevel, "focus", G_CALLBACK(toplevel_focus), NULL);
1926
1927 options_iterate(client_optset, poption) {
1928 if (OT_FONT == option_type(poption)) {
1929 /* Force to call the appropriate callback. */
1930 option_changed(poption);
1931 }
1932 } options_iterate_end;
1933
1934 toplevel_font_name = pango_context_get_font_description(
1935 gtk_widget_get_pango_context(toplevel));
1936
1937 if (NULL == city_names_style) {
1938 city_names_style = pango_font_description_copy(toplevel_font_name);
1939 log_error("city_names_style should have been set by options.");
1940 }
1941 if (NULL == city_productions_style) {
1942 city_productions_style = pango_font_description_copy(toplevel_font_name);
1943 log_error("city_productions_style should have been set by options.");
1944 }
1945 if (NULL == reqtree_text_style) {
1946 reqtree_text_style = pango_font_description_copy(toplevel_font_name);
1947 log_error("reqtree_text_style should have been set by options.");
1948 }
1949
1950 tileset_init(tileset);
1951 tileset_load_tiles(tileset);
1952
1953 /* Keep the icon of the executable on Windows (see PR#36491) */
1954#ifndef FREECIV_MSWINDOWS
1955 {
1956 GdkPixbuf *pixbuf = sprite_get_pixbuf(get_icon_sprite(tileset, ICON_FREECIV));
1957
1958 /* Only call this after tileset_load_tiles is called. */
1959 gtk_window_set_icon(GTK_WINDOW(toplevel), pixbuf);
1960 g_object_unref(pixbuf);
1961 }
1962#endif /* FREECIV_MSWINDOWS */
1963
1964 setup_widgets();
1965 load_cursors();
1966 cma_fe_init();
1967 diplomacy_dialog_init();
1968 luaconsole_dialog_init();
1969 happiness_dialog_init();
1970 citizens_dialog_init();
1971 intel_dialog_init();
1972 spaceship_dialog_init();
1973 chatline_init();
1974 init_mapcanvas_and_overview();
1975
1976 tileset_use_preferred_theme(tileset);
1977
1978 gtk_widget_show(toplevel);
1979
1980 /* Assumes toplevel showing */
1981 set_client_state(C_S_DISCONNECTED);
1982
1983 /* Assumes client_state is set */
1984 timer_id = g_timeout_add(TIMER_INTERVAL, timer_callback, NULL);
1985
1986 gui_up = TRUE;
1987 gtk_main();
1988 gui_up = FALSE;
1989
1990 destroy_server_scans();
1991 free_mapcanvas_and_overview();
1992 spaceship_dialog_done();
1993 intel_dialog_done();
1994 citizens_dialog_done();
1995 luaconsole_dialog_done();
1996 happiness_dialog_done();
1997 diplomacy_dialog_done();
1998 cma_fe_done();
1999 free_unit_table();
2000
2001 /* We have extra ref for unit_info_box that has protected
2002 * it from getting destroyed when editinfobox_refresh()
2003 * moves widgets around. Free that extra ref here. */
2004 g_object_unref(unit_info_box);
2005
2006 editgui_free();
2007 gtk_widget_destroy(toplevel_tabs);
2008 gtk_widget_destroy(toplevel);
2009 menus_free();
2010 message_buffer = NULL; /* Result of destruction of everything */
2011 tileset_free_tiles(tileset);
2012 }
2013
2014 return EXIT_SUCCESS;
2015}
2016
2017/**********************************************************************/
2020 bool is_gui_up(void)
2021{
2022 return gui_up;
2023}
2024
2025/**********************************************************************/
2028 void ui_exit(void)
2029{
2030 if (message_buffer != NULL) {
2031 g_object_unref(message_buffer);
2032 message_buffer = NULL;
2033 }
2034}
2035
2036/**********************************************************************/
2039 enum gui_type get_gui_type(void)
2040{
2041 return GUI_GTK3_22;
2042}
2043
2044/**********************************************************************/
2047 void sound_bell(void)
2048{
2049 gdk_display_beep(gdk_display_get_default());
2050}
2051
2052/**********************************************************************/
2058 void set_unit_icon(int idx, struct unit *punit)
2059{
2060 GtkWidget *w;
2061
2062 fc_assert_ret(idx >= -1 && idx < num_units_below);
2063
2064 if (idx == -1) {
2065 w = unit_image;
2066 unit_id_top = punit ? punit->id : 0;
2067 } else {
2068 w = unit_below_image[idx];
2069 unit_ids[idx] = punit ? punit->id : 0;
2070 }
2071
2072 if (!w) {
2073 return;
2074 }
2075
2076 if (punit) {
2077 put_unit_image(punit, GTK_IMAGE(w), -1);
2078 } else {
2079 gtk_image_clear(GTK_IMAGE(w));
2080 }
2081}
2082
2083/**********************************************************************/
2088 void set_unit_icons_more_arrow(bool onoff)
2089{
2090 static bool showing = FALSE;
2091
2092 if (!more_arrow_pixmap_button) {
2093 return;
2094 }
2095
2096 if (onoff && !showing) {
2097 gtk_widget_show(more_arrow_pixmap_button);
2098 showing = TRUE;
2099 } else if (!onoff && showing) {
2100 gtk_widget_hide(more_arrow_pixmap_button);
2101 showing = FALSE;
2102 }
2103}
2104
2105/**********************************************************************/
2111 void real_focus_units_changed(void)
2112{
2113 goto_dialog_focus_units_changed();
2114}
2115
2116/**********************************************************************/
2120 static gboolean select_unit_image_callback(GtkWidget *w, GdkEvent *ev,
2121 gpointer data)
2122{
2123 int i = GPOINTER_TO_INT(data);
2124 struct unit *punit;
2125
2126 if (i == -1) {
2127 punit = game_unit_by_number(unit_id_top);
2128 if (punit && unit_is_in_focus(punit)) {
2129 /* Clicking on the currently selected unit will center it. */
2130 center_tile_mapcanvas(unit_tile(punit));
2131 }
2132 return TRUE;
2133 }
2134
2135 if (unit_ids[i] == 0) /* no unit displayed at this place */
2136 return TRUE;
2137
2138 punit = game_unit_by_number(unit_ids[i]);
2139 if (NULL != punit && unit_owner(punit) == client.conn.playing) {
2140 /* Unit shouldn't be NULL but may be owned by an ally. */
2141 unit_focus_set(punit);
2142 }
2143
2144 return TRUE;
2145}
2146
2147/**********************************************************************/
2151 static gboolean select_more_arrow_pixmap_callback(GtkWidget *w, GdkEvent *ev,
2152 gpointer data)
2153{
2154 struct unit *punit = game_unit_by_number(unit_id_top);
2155
2156 if (punit) {
2157 unit_select_dialog_popup(unit_tile(punit));
2158 }
2159
2160 return TRUE;
2161}
2162
2163/**********************************************************************/
2166 static gboolean show_info_button_release(GtkWidget *w, GdkEventButton *ev,
2167 gpointer data)
2168{
2169 gtk_grab_remove(w);
2170 gdk_seat_ungrab(gdk_device_get_seat(ev->device));
2171 gtk_widget_destroy(w);
2172
2173 return FALSE;
2174}
2175
2176/**********************************************************************/
2179 static gboolean show_info_popup(GtkWidget *w, GdkEventButton *ev, gpointer data)
2180{
2181 if (ev->button == 1) {
2182 GtkWidget *p;
2183
2184 p = gtk_window_new(GTK_WINDOW_POPUP);
2185 gtk_container_set_border_width(GTK_CONTAINER(p), 4);
2186 gtk_window_set_transient_for(GTK_WINDOW(p), GTK_WINDOW(toplevel));
2187 gtk_window_set_position(GTK_WINDOW(p), GTK_WIN_POS_MOUSE);
2188
2189 gtk_widget_new(GTK_TYPE_LABEL, "GtkWidget::parent", p,
2190 "GtkLabel::label", get_info_label_text_popup(),
2191 "GtkWidget::visible", TRUE,
2192 NULL);
2193 gtk_widget_show(p);
2194
2195 gdk_seat_grab(gdk_device_get_seat(ev->device), gtk_widget_get_window(p),
2196 GDK_SEAT_CAPABILITY_ALL_POINTING,
2197 TRUE, NULL, (GdkEvent *)ev, NULL, NULL);
2198 gtk_grab_add(p);
2199
2200 g_signal_connect_after(p, "button_release_event",
2201 G_CALLBACK(show_info_button_release), NULL);
2202 }
2203
2204 return TRUE;
2205}
2206
2207/**********************************************************************/
2210 static void end_turn_callback(GtkWidget *w, gpointer data)
2211{
2212 gtk_widget_set_sensitive(turn_done_button, FALSE);
2213 user_ended_turn();
2214}
2215
2216/**********************************************************************/
2219 static gboolean get_net_input(GIOChannel *source, GIOCondition condition,
2220 gpointer data)
2221{
2222 input_from_server(g_io_channel_unix_get_fd(source));
2223
2224 return TRUE;
2225}
2226
2227/**********************************************************************/
2230 static void set_wait_for_writable_socket(struct connection *pc,
2231 bool socket_writable)
2232{
2233 static bool previous_state = FALSE;
2234
2235 fc_assert_ret(pc == &client.conn);
2236
2237 if (previous_state == socket_writable)
2238 return;
2239
2240 log_debug("set_wait_for_writable_socket(%d)", socket_writable);
2241
2242 g_source_remove(srv_id);
2243 srv_id = g_io_add_watch(srv_channel,
2244 G_IO_IN | (socket_writable ? G_IO_OUT : 0) | G_IO_ERR,
2245 get_net_input,
2246 NULL);
2247
2248 previous_state = socket_writable;
2249}
2250
2251/**********************************************************************/
2255 void add_net_input(int sock)
2256{
2257#ifdef FREECIV_MSWINDOWS
2258 srv_channel = g_io_channel_win32_new_socket(sock);
2259#else
2260 srv_channel = g_io_channel_unix_new(sock);
2261#endif
2262 srv_id = g_io_add_watch(srv_channel,
2263 G_IO_IN | G_IO_ERR,
2264 get_net_input,
2265 NULL);
2266 client.conn.notify_of_writable_data = set_wait_for_writable_socket;
2267}
2268
2269/**********************************************************************/
2273 void remove_net_input(void)
2274{
2275 g_source_remove(srv_id);
2276 g_io_channel_unref(srv_channel);
2277 gdk_window_set_cursor(root_window, NULL);
2278}
2279
2280/**********************************************************************/
2284 static void quit_dialog_response(GtkWidget *dialog, gint response)
2285{
2286 gtk_widget_destroy(dialog);
2287 if (response == GTK_RESPONSE_YES) {
2288 start_quitting();
2289 if (client.conn.used) {
2290 disconnect_from_server();
2291 }
2292 quit_gtk_main();
2293 }
2294}
2295
2296/**********************************************************************/
2299 void quit_gtk_main(void)
2300{
2301 /* Quit gtk main loop. After this it will return to finish
2302 * ui_main() */
2303
2304 gtk_main_quit();
2305}
2306
2307/**********************************************************************/
2311 void popup_quit_dialog(void)
2312{
2313 static GtkWidget *dialog;
2314
2315 if (!dialog) {
2316 dialog = gtk_message_dialog_new(NULL,
2317 0,
2318 GTK_MESSAGE_WARNING,
2319 GTK_BUTTONS_YES_NO,
2320 _("Are you sure you want to quit?"));
2321 setup_dialog(dialog, toplevel);
2322
2323 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
2324
2325 g_signal_connect(dialog, "response",
2326 G_CALLBACK(quit_dialog_response), NULL);
2327 g_signal_connect(dialog, "destroy",
2328 G_CALLBACK(gtk_widget_destroyed), &dialog);
2329 }
2330
2331 gtk_window_present(GTK_WINDOW(dialog));
2332}
2333
2334/**********************************************************************/
2337 static gboolean quit_dialog_callback(void)
2338{
2339 popup_quit_dialog();
2340 /* Stop emission of event. */
2341 return TRUE;
2342}
2343
2344struct callback {
2345 void (*callback)(void *data);
2346 void *data;
2347};
2348
2349/**********************************************************************/
2352 static gboolean idle_callback_wrapper(gpointer data)
2353{
2354 struct callback *cb = data;
2355
2356 (cb->callback)(cb->data);
2357 free(cb);
2358
2359 return FALSE;
2360}
2361
2362/**********************************************************************/
2367 void add_idle_callback(void (callback)(void *), void *data)
2368{
2369 struct callback *cb = fc_malloc(sizeof(*cb));
2370
2371 cb->callback = callback;
2372 cb->data = data;
2373 g_idle_add(idle_callback_wrapper, cb);
2374}
2375
2376/**********************************************************************/
2380 static void allied_chat_only_callback(struct option *poption)
2381{
2382 GtkWidget *button;
2383
2384 button = allied_chat_toggle_button;
2385 fc_assert_ret(button != NULL);
2386 fc_assert_ret(GTK_IS_TOGGLE_BUTTON(button));
2387
2388 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
2389 option_bool_get(poption));
2390}
2391
2392/**********************************************************************/
2395 void fullscreen_opt_refresh(struct option *poption)
2396{
2397 if (GUI_GTK_OPTION(fullscreen)) {
2398 gtk_window_fullscreen(GTK_WINDOW(toplevel));
2399 } else {
2400 gtk_window_unfullscreen(GTK_WINDOW(toplevel));
2401 }
2402}
2403
2404/**********************************************************************/
2407 static void apply_city_names_font(struct option *poption)
2408{
2409 gui_update_font_full(option_font_target(poption),
2410 option_font_get(poption),
2411 &city_names_style);
2412 update_city_descriptions();
2413}
2414
2415/**********************************************************************/
2418 static void apply_city_productions_font(struct option *poption)
2419{
2420 gui_update_font_full(option_font_target(poption),
2421 option_font_get(poption),
2422 &city_productions_style);
2423 update_city_descriptions();
2424}
2425
2426/**********************************************************************/
2429 static void apply_reqtree_text_font(struct option *poption)
2430{
2431 gui_update_font_full(option_font_target(poption),
2432 option_font_get(poption),
2433 &reqtree_text_style);
2434 science_report_dialog_redraw();
2435}
2436
2437/**********************************************************************/
2441 void options_extra_init(void)
2442{
2443
2444 struct option *poption;
2445
2446#define option_var_set_callback(var, callback) \
2447 if ((poption = optset_option_by_name(client_optset, GUI_GTK_OPTION_STR(var)))) { \
2448 option_set_changed_callback(poption, callback); \
2449 } else { \
2450 log_error("Didn't find option %s!", GUI_GTK_OPTION_STR(var)); \
2451 }
2452
2453 option_var_set_callback(allied_chat_only,
2454 allied_chat_only_callback);
2455 option_var_set_callback(fullscreen,
2456 fullscreen_opt_refresh);
2457
2458 option_var_set_callback(font_city_names,
2459 apply_city_names_font);
2460 option_var_set_callback(font_city_productions,
2461 apply_city_productions_font);
2462 option_var_set_callback(font_reqtree_text,
2463 apply_reqtree_text_font);
2464#undef option_var_set_callback
2465}
2466
2467/**********************************************************************/
2471 void refresh_chat_buttons(void)
2472{
2473 GtkWidget *button;
2474
2475 button = allied_chat_toggle_button;
2476 fc_assert_ret(button != NULL);
2477 fc_assert_ret(GTK_IS_TOGGLE_BUTTON(button));
2478
2479 /* Hide the "Allies Only" button for local games. */
2480 if (is_server_running()) {
2481 gtk_widget_hide(button);
2482 } else {
2483 gtk_widget_show(button);
2484 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
2485 GUI_GTK_OPTION(allied_chat_only));
2486 }
2487}
2488
2489/**********************************************************************/
2492 static void allied_chat_button_toggled(GtkToggleButton *button,
2493 gpointer user_data)
2494{
2495 GUI_GTK_OPTION(allied_chat_only) = gtk_toggle_button_get_active(button);
2496}
2497
2498/**********************************************************************/
2501 void insert_client_build_info(char *outbuf, size_t outlen)
2502{
2503 cat_snprintf(outbuf, outlen, _("\nBuilt against gtk+ %d.%d.%d, using %d.%d.%d"
2504 "\nBuilt against glib %d.%d.%d, using %d.%d.%d"),
2505 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION,
2506 gtk_get_major_version(), gtk_get_minor_version(), gtk_get_micro_version(),
2507 GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
2508 glib_major_version, glib_minor_version, glib_micro_version);
2509}
2510
2511/**********************************************************************/
2515 static bool monitor_size(GdkRectangle *rect_p)
2516{
2517 GdkDisplay *display;
2518 GdkMonitor *monitor;
2519
2520 display = gdk_display_get_default();
2521 if (!display) {
2522 return FALSE;
2523 }
2524
2525 monitor = gdk_display_get_primary_monitor(display);
2526 if (!monitor) {
2527 return FALSE;
2528 }
2529
2530 gdk_monitor_get_geometry(monitor, rect_p);
2531 return TRUE;
2532}
2533
2534/**********************************************************************/
2537 int screen_width(void)
2538{
2539 GdkRectangle rect;
2540
2541 if (vmode.width > 0) {
2542 return vmode.width;
2543 }
2544
2545 if (monitor_size(&rect)) {
2546 return rect.width;
2547 } else {
2548 return 0;
2549 }
2550}
2551
2552/**********************************************************************/
2555 int screen_height(void)
2556{
2557 GdkRectangle rect;
2558
2559 if (vmode.height > 0) {
2560 return vmode.height;
2561 }
2562
2563 if (monitor_size(&rect)) {
2564 return rect.height;
2565 } else {
2566 return 0;
2567 }
2568}
2569
2570/**********************************************************************/
2573 struct video_mode *resolution_request_get(void)
2574{
2575 if (vmode.width > 0 && vmode.height > 0) {
2576 return &vmode;
2577 }
2578
2579 return NULL;
2580}
2581
2582/**********************************************************************/
2585 static void adjust_default_options(void)
2586{
2587 int scr_height = screen_height();
2588
2589 if (scr_height > 0) {
2590 /* Adjust these options only if we do know the screen height. */
2591
2592 if (scr_height <= 480) {
2593 /* Freeciv is practically unusable outside fullscreen mode in so
2594 * small display */
2595 log_verbose("Changing default to fullscreen due to very small screen");
2596 GUI_GTK_OPTION(fullscreen) = TRUE;
2597 }
2598 if (scr_height < 1024) {
2599 /* This is a small display */
2600 log_verbose("Defaulting to small widget layout due to small screen");
2601 GUI_GTK_OPTION(small_display_layout) = TRUE;
2602 log_verbose("Defaulting to merged messages/chat due to small screen");
2603 GUI_GTK_OPTION(message_chat_location) = GUI_GTK_MSGCHAT_MERGED;
2604 }
2605 }
2606}
width
struct canvas int int struct sprite int int int width
Definition canvas_g.h:44
chat_welcome_message
void chat_welcome_message(bool gui_has_copying_mitem)
Definition chatline_common.c:177
client_is_observer
bool client_is_observer(void)
Definition client_main.c:1086
real_timer_callback
double real_timer_callback(void)
Definition client_main.c:1183
client_main
int client_main(int argc, char *argv[], bool postpone_tileset)
Definition client_main.c:344
user_ended_turn
void user_ended_turn(void)
Definition client_main.c:801
client
struct civclient client
Definition client_main.c:149
start_quitting
void start_quitting(void)
Definition client_main.c:1645
set_client_state
void set_client_state(enum client_states newstate)
Definition client_main.c:847
can_client_change_view
bool can_client_change_view(void)
Definition client_main.c:1313
client_main.h
TIMER_INTERVAL
#define TIMER_INTERVAL
Definition client_main.h:30
C_S_DISCONNECTED
@ C_S_DISCONNECTED
Definition client_main.h:45
buy_production_in_selected_cities
void buy_production_in_selected_cities(void)
Definition climisc.c:1299
client_warming_sprite
struct sprite * client_warming_sprite(void)
Definition climisc.c:371
client_cooling_sprite
struct sprite * client_cooling_sprite(void)
Definition climisc.c:388
client_research_sprite
struct sprite * client_research_sprite(void)
Definition climisc.c:348
client_government_sprite
struct sprite * client_government_sprite(void)
Definition climisc.c:406
climisc.h
input_from_server
void input_from_server(int fd)
Definition clinet.c:406
disconnect_from_server
void disconnect_from_server(void)
Definition clinet.c:305
clinet.h
get_color
struct color * get_color(const struct tileset *t, enum color_std stdcolor)
Definition colors_common.c:100
is_server_running
bool is_server_running(void)
Definition connectdlg_common.c:124
connectdlg_common.h
key_recall_previous_focus_unit
void key_recall_previous_focus_unit(void)
Definition control.c:3132
unit_is_in_focus
bool unit_is_in_focus(const struct unit *punit)
Definition control.c:384
key_cancel_action
void key_cancel_action(void)
Definition control.c:3071
num_units_below
int num_units_below
Definition control.c:76
unit_focus_set
void unit_focus_set(struct unit *punit)
Definition control.c:502
get_units_in_focus
struct unit_list * get_units_in_focus(void)
Definition control.c:177
key_end_turn
void key_end_turn(void)
Definition control.c:3124
update_unit_pix_label
void update_unit_pix_label(struct unit_list *punitlist)
Definition control.c:966
key_unit_move
void key_unit_move(enum direction8 gui_dir)
Definition control.c:3153
hover_state
enum cursor_hover_state hover_state
Definition control.c:89
head_of_units_in_focus
struct unit * head_of_units_in_focus(void)
Definition control.c:406
get_num_units_in_focus
int get_num_units_in_focus(void)
Definition control.c:185
control_mouse_cursor
void control_mouse_cursor(struct tile *ptile)
Definition control.c:1188
key_center_capital
void key_center_capital(void)
Definition control.c:3107
control.h
MAX_NUM_UNITS_BELOW
#define MAX_NUM_UNITS_BELOW
Definition control.h:285
HOVER_NONE
@ HOVER_NONE
Definition control.h:26
dataio.h
punit
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:73
editor_is_active
bool editor_is_active(void)
Definition editor.c:346
editor.h
event
enum event_type event
Definition events.c:81
is_option
bool is_option(const char *option_name, char *option)
Definition fc_cmdline.c:112
get_option_malloc
char * get_option_malloc(const char *option_name, char **argv, int *i, int argc, bool gc)
Definition fc_cmdline.c:50
fc_cmdline.h
O_SCIENCE
@ O_SCIENCE
Definition fc_types.h:91
O_GOLD
@ O_GOLD
Definition fc_types.h:91
fciconv.h
fc_fprintf
void fc_fprintf(FILE *stream, const char *format,...) fc__attribute((__format__(__printf__
fcintl.h
Q_
#define Q_(String)
Definition fcintl.h:70
_
#define _(String)
Definition fcintl.h:67
featured_text.h
game_unit_by_number
struct unit * game_unit_by_number(int id)
Definition game.c:111
game.h
government.h
inputline_has_focus
bool inputline_has_focus(void)
Definition chatline.c:71
inputline_toolkit_view_append_button
void inputline_toolkit_view_append_button(GtkWidget *toolkit_view, GtkWidget *button)
Definition chatline.c:1288
inputline_toolkit_view_new
GtkWidget * inputline_toolkit_view_new(void)
Definition chatline.c:1266
set_message_buffer_view_link_handlers
void set_message_buffer_view_link_handlers(GtkWidget *view)
Definition chatline.c:744
inputline_is_visible
bool inputline_is_visible(void)
Definition chatline.c:87
chatline_init
void chatline_init(void)
Definition chatline.c:1298
inputline_grab_focus
void inputline_grab_focus(void)
Definition chatline.c:79
chatline_scroll_to_bottom
void chatline_scroll_to_bottom(bool delayed)
Definition chatline.c:1006
citizens_dialog_init
void citizens_dialog_init(void)
Definition citizensinfo.c:267
citizens_dialog_done
void citizens_dialog_done(void)
Definition citizensinfo.c:275
cma_fe_init
void cma_fe_init(void)
Definition cma_fe.c:88
cma_fe_done
void cma_fe_done(void)
Definition cma_fe.c:96
unit_select_dialog_popup
void unit_select_dialog_popup(struct tile *ptile)
Definition dialogs.c:382
taxrates_callback
gboolean taxrates_callback(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition dialogs.c:1434
diplomacy_dialog_init
void diplomacy_dialog_init(void)
Definition diplodlg.c:1173
diplomacy_dialog_done
void diplomacy_dialog_done(void)
Definition diplodlg.c:1182
handle_edit_key_release
gboolean handle_edit_key_release(GdkEventKey *ev)
Definition editgui.c:1779
handle_edit_key_press
gboolean handle_edit_key_press(GdkEventKey *ev)
Definition editgui.c:1661
editgui_create_widgets
void editgui_create_widgets(void)
Definition editgui.c:1821
editgui_get_editbar
struct editbar * editgui_get_editbar(void)
Definition editgui.c:1787
editgui_free
void editgui_free(void)
Definition editgui.c:1834
goto_dialog_focus_units_changed
void goto_dialog_focus_units_changed(void)
Definition gotodlg.c:540
source
static GtkWidget * source
Definition gotodlg.c:58
load_cursors
void load_cursors(void)
Definition graphics.c:78
map_vertical_scrollbar
GtkWidget * map_vertical_scrollbar
Definition gui_main.c:108
ui_main
int ui_main(int argc, char **argv)
Definition gui_main.c:1701
client_string
const char * client_string
Definition gui_main.c:104
message_buffer
GtkTextBuffer * message_buffer
Definition gui_main.c:177
quit_dialog_response
static void quit_dialog_response(GtkWidget *dialog, gint response)
Definition gui_main.c:2126
real_focus_units_changed
void real_focus_units_changed(void)
Definition gui_main.c:1954
set_unit_icons_more_arrow
void set_unit_icons_more_arrow(bool onoff)
Definition gui_main.c:1931
print_usage
static void print_usage(void)
Definition gui_main.c:249
OVERVIEW_CANVAS_STORE_WIDTH_NETBOOK
#define OVERVIEW_CANVAS_STORE_WIDTH_NETBOOK
Definition gui_main.c:115
option_var_set_callback
#define option_var_set_callback(var, callback)
select_unit_image_callback
static gboolean select_unit_image_callback(GtkWidget *w, GdkEvent *ev, gpointer data)
Definition gui_main.c:1963
quit_dialog_callback
static gboolean quit_dialog_callback(void)
Definition gui_main.c:2179
srv_channel
static GIOChannel * srv_channel
Definition gui_main.c:181
main_label_info
GtkWidget * main_label_info
Definition gui_main.c:137
bottom_notebook
GtkWidget * bottom_notebook
Definition gui_main.c:128
unit_info_label
GtkWidget * unit_info_label
Definition gui_main.c:150
timer_callback
static gboolean timer_callback(gpointer data)
Definition gui_main.c:236
resolution_request_get
struct video_mode * resolution_request_get(void)
Definition gui_main.c:2395
set_unit_icon
void set_unit_icon(int idx, struct unit *punit)
Definition gui_main.c:1901
unit_ids
static int unit_ids[MAX_NUM_UNITS_BELOW]
Definition gui_main.c:174
timeout_label
GtkWidget * timeout_label
Definition gui_main.c:147
gui_up
static bool gui_up
Definition gui_main.c:185
srv_id
static guint srv_id
Definition gui_main.c:182
mouse_scroll_mapcanvas
static gboolean mouse_scroll_mapcanvas(GtkWidget *w, GdkEventScroll *ev)
Definition gui_main.c:690
city_productions_style
PangoFontDescription * city_productions_style
Definition gui_main.c:133
overview_scrolled_window
GtkWidget * overview_scrolled_window
Definition gui_main.c:111
more_arrow_pixmap
static GtkWidget * more_arrow_pixmap
Definition gui_main.c:169
detached_widget_fill
static GtkWidget * detached_widget_fill(GtkWidget *tearbox)
Definition gui_main.c:817
enable_menus
void enable_menus(bool enable)
Definition gui_main.c:1000
select_more_arrow_pixmap_callback
static gboolean select_more_arrow_pixmap_callback(GtkWidget *w, GdkEvent *ev, gpointer data)
Definition gui_main.c:1994
top_notebook
GtkWidget * top_notebook
Definition gui_main.c:128
propagate_keypress
static gboolean propagate_keypress(GtkWidget *w, GdkEvent *ev)
Definition gui_main.c:758
MIGRATE_STR_OPTION
#define MIGRATE_STR_OPTION(opt)
econ_ebox
GtkWidget * econ_ebox
Definition gui_main.c:154
unit_info_box
GtkWidget * unit_info_box
Definition gui_main.c:151
ui_exit
void ui_exit(void)
Definition gui_main.c:1871
get_gui_type
enum gui_type get_gui_type(void)
Definition gui_main.c:1882
detached_widget_new
static GtkWidget * detached_widget_new(void)
Definition gui_main.c:805
cur_y
gint cur_y
Definition gui_main.c:183
main
int main(int argc, char **argv)
Definition gui_main.c:1626
fullscreen_opt_refresh
void fullscreen_opt_refresh(struct option *poption)
Definition gui_main.c:2237
main_message_area_size_allocate
static void main_message_area_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer data)
Definition gui_main.c:349
toplevel_handler
static gboolean toplevel_handler(GtkWidget *w, GdkEvent *ev, gpointer data)
Definition gui_main.c:383
ui_init
void ui_init(void)
Definition gui_main.c:1617
unit_below_image_button
static GtkWidget * unit_below_image_button[MAX_NUM_UNITS_BELOW]
Definition gui_main.c:168
free_unit_table
static void free_unit_table(void)
Definition gui_main.c:943
idle_callback_wrapper
static gboolean idle_callback_wrapper(gpointer data)
Definition gui_main.c:2194
apply_city_names_font
static void apply_city_names_font(struct option *poption)
Definition gui_main.c:2249
apply_city_productions_font
static void apply_city_productions_font(struct option *poption)
Definition gui_main.c:2260
unit_below_image
static GtkWidget * unit_below_image[MAX_NUM_UNITS_BELOW]
Definition gui_main.c:167
tearoff_destroy
static void tearoff_destroy(GtkWidget *w, gpointer data)
Definition gui_main.c:742
government_label
GtkWidget * government_label
Definition gui_main.c:146
sun_label
GtkWidget * sun_label
Definition gui_main.c:144
city_names_style
PangoFontDescription * city_names_style
Definition gui_main.c:132
refresh_chat_buttons
void refresh_chat_buttons(void)
Definition gui_main.c:2312
map_canvas_focus
gboolean map_canvas_focus(void)
Definition gui_main.c:366
turn_done_button
GtkWidget * turn_done_button
Definition gui_main.c:148
bottom_hpaned
static GtkWidget * bottom_hpaned
Definition gui_main.c:130
timer_id
static gint timer_id
Definition gui_main.c:180
main_menubar
static GtkWidget * main_menubar
Definition gui_main.c:163
screen_width
int screen_width(void)
Definition gui_main.c:2355
scroll_panel
GtkWidget * scroll_panel
Definition gui_main.c:140
end_turn_callback
static void end_turn_callback(GtkWidget *w, gpointer data)
Definition gui_main.c:2051
OVERVIEW_CANVAS_STORE_HEIGHT_NETBOOK
#define OVERVIEW_CANVAS_STORE_HEIGHT_NETBOOK
Definition gui_main.c:116
log_callback_utf8
static void log_callback_utf8(enum log_level level, const char *message, bool file_too)
Definition gui_main.c:224
add_idle_callback
void add_idle_callback(void(callback)(void *), void *data)
Definition gui_main.c:2209
show_info_popup
static gboolean show_info_popup(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition gui_main.c:2020
reset_unit_table
void reset_unit_table(void)
Definition gui_main.c:971
key_press_map_canvas
static gboolean key_press_map_canvas(GtkWidget *w, GdkEventKey *ev, gpointer data)
Definition gui_main.c:407
unit_info_frame
GtkWidget * unit_info_frame
Definition gui_main.c:152
options_extra_init
void options_extra_init(void)
Definition gui_main.c:2283
top_vbox
GtkWidget * top_vbox
Definition gui_main.c:127
allied_chat_only_callback
static void allied_chat_only_callback(struct option *poption)
Definition gui_main.c:2222
root_window
GdkWindow * root_window
Definition gui_main.c:125
adjust_default_options
static void adjust_default_options(void)
Definition gui_main.c:2407
set_wait_for_writable_socket
static void set_wait_for_writable_socket(struct connection *pc, bool socket_writable)
Definition gui_main.c:2071
more_arrow_pixmap_button
static GtkWidget * more_arrow_pixmap_button
Definition gui_main.c:170
ahbox
GtkWidget * ahbox
Definition gui_main.c:139
apply_reqtree_text_font
static void apply_reqtree_text_font(struct option *poption)
Definition gui_main.c:2271
show_info_button_release
static gboolean show_info_button_release(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition gui_main.c:2009
is_gui_up
bool is_gui_up(void)
Definition gui_main.c:1863
toplevel_focus
static gboolean toplevel_focus(GtkWidget *w, GtkDirectionType arg)
Definition gui_main.c:322
reqtree_text_style
PangoFontDescription * reqtree_text_style
Definition gui_main.c:134
sun_ebox
GtkWidget * sun_ebox
Definition gui_main.c:156
bulb_ebox
GtkWidget * bulb_ebox
Definition gui_main.c:155
flake_label
GtkWidget * flake_label
Definition gui_main.c:145
avbox
GtkWidget * avbox
Definition gui_main.c:139
cur_x
gint cur_x
Definition gui_main.c:183
insert_client_build_info
void insert_client_build_info(char *outbuf, size_t outlen)
Definition gui_main.c:2342
unit_image_button
static GtkWidget * unit_image_button
Definition gui_main.c:166
unit_image_table
static GtkWidget * unit_image_table
Definition gui_main.c:164
right_notebook_button_release
static gboolean right_notebook_button_release(GtkWidget *widget, GdkEventButton *event)
Definition gui_main.c:1023
bulb_label
GtkWidget * bulb_label
Definition gui_main.c:143
overview_canvas
GtkWidget * overview_canvas
Definition gui_main.c:110
toplevel
GtkWidget * toplevel
Definition gui_main.c:124
setup_widgets
static void setup_widgets(void)
Definition gui_main.c:1073
OVERVIEW_CANVAS_STORE_WIDTH
#define OVERVIEW_CANVAS_STORE_WIDTH
Definition gui_main.c:117
toplevel_key_release_handler
static gboolean toplevel_key_release_handler(GtkWidget *w, GdkEventKey *ev, gpointer data)
Definition gui_main.c:588
remove_net_input
void remove_net_input(void)
Definition gui_main.c:2115
map_horizontal_scrollbar
GtkWidget * map_horizontal_scrollbar
Definition gui_main.c:107
setup_canvas_color_for_state
static void setup_canvas_color_for_state(GtkStateFlags state)
Definition gui_main.c:1043
map_canvas
GtkWidget * map_canvas
Definition gui_main.c:106
toplevel_key_press_handler
static gboolean toplevel_key_press_handler(GtkWidget *w, GdkEventKey *ev, gpointer data)
Definition gui_main.c:606
sound_bell
void sound_bell(void)
Definition gui_main.c:1890
migrate_options_from_gtk2
static void migrate_options_from_gtk2(void)
Definition gui_main.c:1634
econ_label
GtkWidget * econ_label[10]
Definition gui_main.c:142
government_ebox
GtkWidget * government_ebox
Definition gui_main.c:158
popup_quit_dialog
void popup_quit_dialog(void)
Definition gui_main.c:2153
gui_character_encoding
const char *const gui_character_encoding
Definition gui_main.c:160
unit_id_top
static int unit_id_top
Definition gui_main.c:173
get_net_input
static gboolean get_net_input(GIOChannel *source, GIOCondition condition, gpointer data)
Definition gui_main.c:2060
more_arrow_pixmap_container
static GtkWidget * more_arrow_pixmap_container
Definition gui_main.c:171
map_widget
GtkWidget * map_widget
Definition gui_main.c:129
right_notebook
GtkWidget * right_notebook
Definition gui_main.c:128
quit_gtk_main
void quit_gtk_main(void)
Definition gui_main.c:2141
allied_chat_button_toggled
static void allied_chat_button_toggled(GtkToggleButton *button, gpointer user_data)
Definition gui_main.c:2333
vmode
static struct video_mode vmode
Definition gui_main.c:187
add_net_input
void add_net_input(int sock)
Definition gui_main.c:2097
toplevel_tabs
GtkWidget * toplevel_tabs
Definition gui_main.c:126
allied_chat_toggle_button
static GtkWidget * allied_chat_toggle_button
Definition gui_main.c:178
flake_ebox
GtkWidget * flake_ebox
Definition gui_main.c:157
overview_canvas_store_width
int overview_canvas_store_width
Definition gui_main.c:121
update_turn_done_tooltip
void update_turn_done_tooltip(void)
Definition gui_main.c:1054
tearoff_callback
static void tearoff_callback(GtkWidget *b, gpointer data)
Definition gui_main.c:769
unit_image
static GtkWidget * unit_image
Definition gui_main.c:165
main_message_area
GtkTextView * main_message_area
Definition gui_main.c:176
overview_canvas_store_height
int overview_canvas_store_height
Definition gui_main.c:122
screen_height
int screen_height(void)
Definition gui_main.c:2375
parse_options
static bool parse_options(int argc, char **argv)
Definition gui_main.c:286
conn_box
GtkWidget * conn_box
Definition gui_main.c:139
OVERVIEW_CANVAS_STORE_HEIGHT
#define OVERVIEW_CANVAS_STORE_HEIGHT
Definition gui_main.c:119
main_frame_civ_name
GtkWidget * main_frame_civ_name
Definition gui_main.c:136
MIGRATE_OPTION
#define MIGRATE_OPTION(opt)
gui_use_transliteration
const bool gui_use_transliteration
Definition gui_main.c:161
populate_unit_image_table
static void populate_unit_image_table(void)
Definition gui_main.c:841
GUI_NAME_FULL
#define GUI_NAME_FULL
Definition gui_main.h:22
GUI_NAME_SHORT
#define GUI_NAME_SHORT
Definition gui_main.h:23
GUI_GTK_OPTION
#define GUI_GTK_OPTION(optname)
Definition gui_main.h:25
setup_dialog
void setup_dialog(GtkWidget *shell, GtkWidget *parent)
Definition gui_stuff.c:281
gui_update_font_full
void gui_update_font_full(const char *font_name, const char *font_value, PangoFontDescription **font_desc)
Definition gui_stuff.c:1070
happiness_dialog_init
void happiness_dialog_init(void)
Definition happiness.c:86
happiness_dialog_done
void happiness_dialog_done(void)
Definition happiness.c:94
help_system_init
void help_system_init(void)
Definition helpdlg.c:156
intel_dialog_done
void intel_dialog_done(void)
Definition inteldlg.c:127
intel_dialog_init
void intel_dialog_init(void)
Definition inteldlg.c:118
luaconsole_dialog_init
void luaconsole_dialog_init(void)
Definition luaconsole.c:83
luaconsole_dialog_done
void luaconsole_dialog_done(void)
Definition luaconsole.c:101
butt_release_mapcanvas
gboolean butt_release_mapcanvas(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition mapctrl.c:216
move_overviewcanvas
gboolean move_overviewcanvas(GtkWidget *w, GdkEventMotion *ev, gpointer data)
Definition mapctrl.c:458
butt_down_overviewcanvas
gboolean butt_down_overviewcanvas(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition mapctrl.c:467
butt_down_mapcanvas
gboolean butt_down_mapcanvas(GtkWidget *w, GdkEventButton *ev, gpointer data)
Definition mapctrl.c:237
move_mapcanvas
gboolean move_mapcanvas(GtkWidget *w, GdkEventMotion *ev, gpointer data)
Definition mapctrl.c:400
leave_mapcanvas
gboolean leave_mapcanvas(GtkWidget *widget, GdkEventCrossing *event)
Definition mapctrl.c:429
update_city_descriptions
void update_city_descriptions(void)
Definition mapview.c:470
map_canvas_draw
gboolean map_canvas_draw(GtkWidget *w, cairo_t *cr, gpointer data)
Definition mapview.c:407
map_canvas_configure
gboolean map_canvas_configure(GtkWidget *w, GdkEventConfigure *ev, gpointer data)
Definition mapview.c:386
put_unit_image
void put_unit_image(struct unit *punit, GtkImage *p, int height)
Definition mapview.c:478
overview_canvas_draw
gboolean overview_canvas_draw(GtkWidget *w, cairo_t *cr, gpointer data)
Definition mapview.c:339
setup_menus
GtkWidget * setup_menus(GtkWidget *window)
Definition menu.c:2115
menus_free
void menus_free(void)
Definition menu.c:3138
meswin_dialog_popup
void meswin_dialog_popup(bool raise)
Definition messagewin.c:416
create_start_page
GtkWidget * create_start_page(void)
Definition pages.c:2605
create_network_page
GtkWidget * create_network_page(void)
Definition pages.c:1183
create_scenario_page
GtkWidget * create_scenario_page(void)
Definition pages.c:3168
statusbar
static GtkWidget * statusbar
Definition pages.c:89
destroy_server_scans
void destroy_server_scans(void)
Definition pages.c:751
create_load_page
GtkWidget * create_load_page(void)
Definition pages.c:2886
create_statusbar
GtkWidget * create_statusbar(void)
Definition pages.c:892
create_main_page
GtkWidget * create_main_page(void)
Definition pages.c:229
science_report_dialog_redraw
void science_report_dialog_redraw(void)
Definition repodlgs.c:761
spaceship_dialog_init
void spaceship_dialog_init(void)
Definition spaceshipdlg.c:87
spaceship_dialog_done
void spaceship_dialog_done(void)
Definition spaceshipdlg.c:95
sprite_get_pixbuf
GdkPixbuf * sprite_get_pixbuf(struct sprite *sprite)
Definition sprite.c:402
ingame_votebar
GtkWidget * ingame_votebar
Definition voteinfo_bar.c:50
voteinfo_bar_new
GtkWidget * voteinfo_bar_new(bool split_bar)
Definition voteinfo_bar.c:92
monitor_size
static bool monitor_size(GdkRectangle *rect_p)
Definition gui_main.c:2515
set_g_log_callbacks
static void set_g_log_callbacks(void)
Definition gui_main.c:1706
g_log_to_freelog_cb
static void g_log_to_freelog_cb(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
Definition gui_main.c:1650
set_g_log_callback_domain
static void set_g_log_callback_domain(const char *domain)
Definition gui_main.c:1694
migrate_options_from_gtk3
static void migrate_options_from_gtk3(void)
Definition gui_main.c:1795
g_log_writer_to_freelog_cb
static GLogWriterOutput g_log_writer_to_freelog_cb(GLogLevelFlags log_level, const GLogField *fields, gsize n_fields, gpointer user_data)
Definition gui_main.c:1678
dlg_tab_provider_prepare
void dlg_tab_provider_prepare(void)
Definition gui_stuff.c:1151
citizensinfo.h
editgui.h
gui_stuff.h
happiness.h
cma_fe.h
chatline.h
colors.h
connectdlg.h
dialogs.h
diplodlg.h
gotodlg.h
graphics.h
gui_main.h
helpdlg.h
inteldlg.h
luaconsole.h
mapctrl.h
mapview.h
menu.h
messagewin.h
optiondlg.h
pages.h
plrdlg.h
repodlgs.h
spaceshipdlg.h
voteinfo_bar.h
log_set_callback
log_callback_fn log_set_callback(log_callback_fn callback)
Definition log.c:290
log.h
fc_assert_ret
#define fc_assert_ret(condition)
Definition log.h:191
log_verbose
#define log_verbose(message,...)
Definition log.h:109
log_fatal
#define log_fatal(message,...)
Definition log.h:100
log_debug
#define log_debug(message,...)
Definition log.h:115
log_normal
#define log_normal(message,...)
Definition log.h:107
log_base
#define log_base(level, message,...)
Definition log.h:94
log_level
log_level
Definition log.h:28
LOG_ERROR
@ LOG_ERROR
Definition log.h:30
LOG_DEBUG
@ LOG_DEBUG
Definition log.h:34
LOG_FATAL
@ LOG_FATAL
Definition log.h:29
LOG_WARN
@ LOG_WARN
Definition log.h:31
log_error
#define log_error(message,...)
Definition log.h:103
map.h
update_line
void update_line(int canvas_x, int canvas_y)
Definition mapctrl_common.c:662
maybe_activate_keyboardless_goto
void maybe_activate_keyboardless_goto(int canvas_x, int canvas_y)
Definition mapctrl_common.c:504
rbutton_down
bool rbutton_down
Definition mapctrl_common.c:55
tiles_hilited_cities
bool tiles_hilited_cities
Definition mapctrl_common.c:60
scroll_mapview
void scroll_mapview(enum direction8 gui_dir)
Definition mapctrl_common.c:549
keyboardless_goto_button_down
bool keyboardless_goto_button_down
Definition mapctrl_common.c:69
update_selection_rectangle
void update_selection_rectangle(float canvas_x, float canvas_y)
Definition mapctrl_common.c:201
init_mapcanvas_and_overview
void init_mapcanvas_and_overview(void)
Definition mapview_common.c:3683
canvas_pos_to_tile
struct tile * canvas_pos_to_tile(float canvas_x, float canvas_y, float zoom)
Definition mapview_common.c:751
free_mapcanvas_and_overview
void free_mapcanvas_and_overview(void)
Definition mapview_common.c:3692
get_mapview_scroll_pos
void get_mapview_scroll_pos(int *scroll_x, int *scroll_y)
Definition mapview_common.c:1191
get_mapview_scroll_step
void get_mapview_scroll_step(int *xstep, int *ystep)
Definition mapview_common.c:1177
set_mapview_scroll_pos
void set_mapview_scroll_pos(int scroll_x, int scroll_y, float zoom)
Definition mapview_common.c:1200
center_tile_mapcanvas
void center_tile_mapcanvas(const struct tile *ptile)
Definition mapview_common.c:1222
set_frame_by_frame_animation
void set_frame_by_frame_animation(void)
Definition mapview_common.c:4081
link_marks_clear_all
void link_marks_clear_all(void)
Definition mapview_common.c:3952
mem.h
fc_malloc
#define fc_malloc(sz)
Definition mem.h:34
menus_init
void menus_init(void)
Definition update_queue.c:554
option_changed
void option_changed(struct option *poption)
Definition options.c:723
server_optset
const struct option_set * server_optset
Definition options.c:4009
client_optset
const struct option_set * client_optset
Definition options.c:1255
option_bool_get
bool option_bool_get(const struct option *poption)
Definition options.c:772
option_type
enum option_type option_type(const struct option *poption)
Definition options.c:633
option_font_target
const char * option_font_target(const struct option *poption)
Definition options.c:1138
string_to_video_mode
bool string_to_video_mode(const char *buf, struct video_mode *mode)
Definition options.c:6453
gui_options
struct client_options gui_options
Definition options.c:71
option_font_get
const char * option_font_get(const struct option *poption)
Definition options.c:1116
optset_option_by_name
struct option * optset_option_by_name(const struct option_set *poptset, const char *name)
Definition options.c:406
options.h
GUI_GTK_OVERVIEW_MIN_XSIZE
#define GUI_GTK_OVERVIEW_MIN_XSIZE
Definition options.h:574
options_iterate
#define options_iterate(poptset, poption)
Definition options.h:527
GUI_GTK_MSGCHAT_MERGED
@ GUI_GTK_MSGCHAT_MERGED
Definition options.h:68
GUI_GTK_MSGCHAT_SPLIT
@ GUI_GTK_MSGCHAT_SPLIT
Definition options.h:66
options_iterate_end
#define options_iterate_end
Definition options.h:532
get_info_label_text_popup
const char * get_info_label_text_popup(void)
Definition text.c:1002
level
struct setting_list * level[OLEVELS_NUM]
Definition settings.c:183
CLIP
#define CLIP(lower, current, upper)
Definition shared.h:57
callback
Definition gui_main.c:2186
callback::data
void * data
Definition gui_main.c:2188
callback::callback
void(* callback)(void *data)
Definition gui_main.c:2187
civclient::conn
struct connection conn
Definition client_main.h:96
client_options::gui_gtk3_migrated_from_2_5
bool gui_gtk3_migrated_from_2_5
Definition options.h:134
client_options::sound_effects_volume
int sound_effects_volume
Definition options.h:183
client_options::first_boot
bool first_boot
Definition options.h:124
client_options::gui_gtk3_fullscreen
bool gui_gtk3_fullscreen
Definition options.h:261
client_options::migrate_fullscreen
bool migrate_fullscreen
Definition options.h:138
client_options::gui_gtk3_migrated_from_gtk2
bool gui_gtk3_migrated_from_gtk2
Definition options.h:129
color
Definition colors.h:20
connection
Definition connection.h:141
connection::playing
struct player * playing
Definition connection.h:156
connection::notify_of_writable_data
void(* notify_of_writable_data)(struct connection *pc, bool data_available_and_socket_full)
Definition connection.h:186
connection::used
bool used
Definition connection.h:144
message
Definition messagewin_common.h:29
option
Definition options.c:454
sprite
Definition sprite.h:22
sprite::surface
cairo_surface_t * surface
Definition sprite.h:23
tileset
Definition tilespec.c:459
unit
Definition unit.h:138
unit::id
int id
Definition unit.h:145
video_mode
Definition options.h:45
video_mode::height
int height
Definition options.h:47
video_mode::width
int width
Definition options.h:46
view
Definition mapview_common.h:36
widget
Definition widget.h:112
fc_snprintf
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:969
cat_snprintf
int cat_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:995
support.h
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
text.h
tileset_load_tiles
void tileset_load_tiles(struct tileset *t)
Definition tilespec.c:3452
tileset_free_tiles
void tileset_free_tiles(struct tileset *t)
Definition tilespec.c:6346
tileset_use_preferred_theme
void tileset_use_preferred_theme(const struct tileset *t)
Definition tilespec.c:6768
get_icon_sprite
struct sprite * get_icon_sprite(const struct tileset *t, enum icon_type icon)
Definition tilespec.c:6678
tileset_init
void tileset_init(struct tileset *t)
Definition tilespec.c:6827
get_arrow_sprite
struct sprite * get_arrow_sprite(const struct tileset *t, enum arrow_type arrow)
Definition tilespec.c:6568
get_tax_sprite
struct sprite * get_tax_sprite(const struct tileset *t, Output_type_id otype)
Definition tilespec.c:6579
tileset_tile_width
int tileset_tile_width(const struct tileset *t)
Definition tilespec.c:716
tilespec.h
ARROW_RIGHT
@ ARROW_RIGHT
Definition tilespec.h:199
ICON_FREECIV
@ ICON_FREECIV
Definition tilespec.h:310
unit_tile
#define unit_tile(_pu)
Definition unit.h:388
unit_owner
#define unit_owner(_pu)
Definition unit.h:387
unitlist.h
version.h
enable
#define enable(id)
Definition widget.h:223
mouse_zoom
float mouse_zoom
Definition zoom.c:28
zoom_step_down
void zoom_step_down(void)
Definition zoom.c:130
zoom_step_up
void zoom_step_up(void)
Definition zoom.c:106
zoom.h