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

Freeciv-3.1

Loading...
Searching...
No Matches
mapview.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18#include <stdio.h>
19
20#ifdef HAVE_UNISTD_H
21#include <unistd.h>
22#endif
23
24#include <gtk/gtk.h>
25
26/* utility */
27#include "fcintl.h"
28#include "log.h"
29#include "mem.h"
30#include "rand.h"
31#include "support.h"
32#include "timing.h"
33
34/* common */
35#include "game.h"
36#include "government.h" /* government_graphic() */
37#include "map.h"
38#include "player.h"
39
40/* client */
41#include "client_main.h"
42#include "climap.h"
43#include "climisc.h"
44#include "colors.h"
45#include "control.h" /* get_unit_in_focus() */
46#include "editor.h"
47#include "options.h"
48#include "overview_common.h"
49#include "tilespec.h"
50#include "text.h"
51#include "zoom.h"
52
53/* client/gui-gtk-4.0 */
54#include "citydlg.h" /* For reset_city_dialogs() */
55#include "editgui.h"
56#include "graphics.h"
57#include "gui_main.h"
58#include "gui_stuff.h"
59#include "mapctrl.h"
60#include "repodlgs.h"
61#include "wldlg.h"
62
63#include "mapview.h"
64
65 static GtkAdjustment *map_hadj, *map_vadj;
66 static int cursor_timer_id = 0, cursor_type = -1, cursor_frame = 0;
67 static int mapview_frozen_level = 0;
68
69 static int mc_actual_width = -1;
70 static int mc_actual_height = -1;
71
72/**********************************************************************/
78 void update_turn_done_button(bool do_restore)
79{
80 static bool flip = FALSE;
81
82 if (!get_turn_done_button_state()) {
83 return;
84 }
85
86 if ((do_restore && flip) || !do_restore) {
87 static GtkCssProvider *tdb_provider = NULL;
88
89 if (tdb_provider == NULL) {
90 tdb_provider = gtk_css_provider_new();
91
92 gtk_css_provider_load_from_data(tdb_provider,
93 ".td_lighted {\n"
94 "color: rgba(235, 127, 235, 255);\n"
95 "background-color: rgba(127, 127, 127, 255);\n"
96 "}\n",
97 -1);
98
99 /* Turn Done button is persistent, so we only need to do this
100 * once too. */
101 gtk_style_context_add_provider_for_display(
102 gtk_widget_get_display(toplevel),
103 GTK_STYLE_PROVIDER(tdb_provider),
104 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
105 }
106
107 if (flip) {
108 gtk_widget_add_css_class(turn_done_button, "td_lighted");
109 } else {
110 gtk_widget_remove_css_class(turn_done_button, "td_lighted");
111 }
112
113 flip = !flip;
114 }
115}
116
117/**********************************************************************/
120 void update_timeout_label(void)
121{
122 gtk_label_set_text(GTK_LABEL(timeout_label), get_timeout_label_text());
123
124 if (current_turn_timeout() > 0) {
125 gtk_widget_set_tooltip_text(timeout_label,
126 _("Time to forced turn change,\n"
127 "or estimated time to finish turn change "
128 "processing."));
129 } else {
130 gtk_widget_set_tooltip_text(timeout_label,
131 _("Turn timeout disabled.\n"
132 "Between turns this shows estimated time "
133 "to finish turn change processing."));
134 }
135}
136
137/**********************************************************************/
140 void update_info_label(void)
141{
142 GtkWidget *label;
143 const struct player *pplayer = client_player();
144
145 label = gtk_frame_get_label_widget(GTK_FRAME(main_frame_civ_name));
146 if (pplayer != NULL) {
147 const gchar *name;
148 gunichar c;
149
150 /* Capitalize the first character of the translated nation
151 * plural name so that the frame label looks good. */
152 name = nation_plural_for_player(pplayer);
153 c = g_utf8_get_char_validated(name, -1);
154 if ((gunichar) -1 != c && (gunichar) -2 != c) {
155 const char *obstext = NULL;
156 int obstextlen = 0;
157
158 if (client_is_observer()) {
159 obstext = _(" (observer)");
160 obstextlen = strlen(obstext);
161 }
162
163 {
164 gchar nation[MAX_LEN_NAME + obstextlen];
165 gchar *next;
166 gint len;
167
168 len = g_unichar_to_utf8(g_unichar_toupper(c), nation);
169 nation[len] = '\0';
170 next = g_utf8_find_next_char(name, NULL);
171 if (NULL != next) {
172 sz_strlcat(nation, next);
173 }
174 if (obstext != NULL) {
175 sz_strlcat(nation, obstext);
176 }
177 gtk_label_set_text(GTK_LABEL(label), nation);
178 }
179 } else {
180 gtk_label_set_text(GTK_LABEL(label), name);
181 }
182 } else {
183 gtk_label_set_text(GTK_LABEL(label), "-");
184 }
185
186 gtk_label_set_text(GTK_LABEL(main_label_info),
187 get_info_label_text(!GUI_GTK_OPTION(small_display_layout)));
188
189 set_indicator_icons(client_research_sprite(),
190 client_warming_sprite(),
191 client_cooling_sprite(),
192 client_government_sprite());
193
194 if (NULL != pplayer) {
195 int d = 0;
196
197 for (; d < pplayer->economic.luxury / 10; d++) {
198 struct sprite *spr = get_tax_sprite(tileset, O_LUXURY);
199
200 picture_set_from_surface(GTK_PICTURE(econ_label[d]), spr->surface);
201 }
202
203 for (; d < (pplayer->economic.science
204 + pplayer->economic.luxury) / 10; d++) {
205 struct sprite *spr = get_tax_sprite(tileset, O_SCIENCE);
206
207 picture_set_from_surface(GTK_PICTURE(econ_label[d]), spr->surface);
208 }
209
210 for (; d < 10; d++) {
211 struct sprite *spr = get_tax_sprite(tileset, O_GOLD);
212
213 picture_set_from_surface(GTK_PICTURE(econ_label[d]), spr->surface);
214 }
215 }
216
217 update_timeout_label();
218
219 /* Update tooltips. */
220 gtk_widget_set_tooltip_text(econ_widget,
221 _("Shows your current luxury/science/tax rates; "
222 "click to toggle them."));
223
224 gtk_widget_set_tooltip_text(bulb_label, get_bulb_tooltip());
225 gtk_widget_set_tooltip_text(sun_label, get_global_warming_tooltip());
226 gtk_widget_set_tooltip_text(flake_label, get_nuclear_winter_tooltip());
227 gtk_widget_set_tooltip_text(government_label, get_government_tooltip());
228}
229
230/**********************************************************************/
233 static gboolean anim_cursor_cb(gpointer data)
234{
235 if (!cursor_timer_id) {
236 return FALSE;
237 }
238
239 cursor_frame++;
240 if (cursor_frame == NUM_CURSOR_FRAMES) {
241 cursor_frame = 0;
242 }
243
244 if (cursor_type == CURSOR_DEFAULT) {
245 gtk_widget_set_cursor(toplevel, NULL);
246 cursor_timer_id = 0;
247 return FALSE;
248 }
249
250 gtk_widget_set_cursor(toplevel,
251 fc_cursors[cursor_type][cursor_frame]);
252 control_mouse_cursor(NULL);
253 return TRUE;
254}
255
256/**********************************************************************/
259 void update_mouse_cursor(enum cursor_type new_cursor_type)
260{
261 cursor_type = new_cursor_type;
262 if (!cursor_timer_id) {
263 cursor_timer_id = g_timeout_add(CURSOR_INTERVAL, anim_cursor_cb, NULL);
264 }
265}
266
267/**********************************************************************/
277 void update_unit_info_label(struct unit_list *punits)
278{
279 GtkWidget *label;
280
281 label = gtk_frame_get_label_widget(GTK_FRAME(unit_info_frame));
282 gtk_label_set_text(GTK_LABEL(label),
283 get_unit_info_label_text1(punits));
284
285 gtk_label_set_text(GTK_LABEL(unit_info_label),
286 get_unit_info_label_text2(punits, 0));
287
288 update_unit_pix_label(punits);
289}
290
291/**********************************************************************/
294GdkPixbuf *get_thumb_pixbuf(int onoff)
295{
296 return sprite_get_pixbuf(get_treaty_thumb_sprite(tileset, BOOL_VAL(onoff)));
297}
298
299/**********************************************************************/
304 void set_indicator_icons(struct sprite *bulb, struct sprite *sol,
305 struct sprite *flake, struct sprite *gov)
306{
307 picture_set_from_surface(GTK_PICTURE(bulb_label), bulb->surface);
308 picture_set_from_surface(GTK_PICTURE(sun_label), sol->surface);
309 picture_set_from_surface(GTK_PICTURE(flake_label), flake->surface);
310 picture_set_from_surface(GTK_PICTURE(government_label), gov->surface);
311}
312
313/**********************************************************************/
319 void get_overview_area_dimensions(int *width, int *height)
320{
321 *width = GUI_GTK_OVERVIEW_MIN_XSIZE;
322 *height = GUI_GTK_OVERVIEW_MIN_YSIZE;
323}
324
325/**********************************************************************/
328 void overview_size_changed(void)
329{
330 gtk_widget_set_size_request(overview_canvas,
331 gui_options.overview.width,
332 gui_options.overview.height);
333 update_map_canvas_scrollbars_size();
334}
335
336/**********************************************************************/
339 struct canvas *get_overview_window(void)
340{
341#if 0
342 static struct canvas store;
343 GtkNative *nat = gtk_widget_get_native(overview_canvas);
344
345 store.surface = NULL;
346 store.drawable = gdk_cairo_create(gtk_native_get_surface(nat));
347
348 return &store;
349#endif /* 0 */
350 if (can_client_change_view()) {
351 gtk_widget_queue_draw(overview_canvas);
352 }
353 return NULL;
354}
355
356/**********************************************************************/
359 void overview_canvas_draw(GtkDrawingArea *w, cairo_t *cr,
360 int width, int height, gpointer data)
361{
362 gpointer source = (can_client_change_view()) ?
363 (gpointer)gui_options.overview.window : NULL;
364
365 if (source) {
366 cairo_surface_t *surface = gui_options.overview.window->surface;
367
368 cairo_set_source_surface(cr, surface, 0, 0);
369 cairo_paint(cr);
370 }
371}
372
373/**********************************************************************/
376 void mapview_freeze(void)
377{
378 mapview_frozen_level++;
379}
380
381/**********************************************************************/
384 void mapview_thaw(void)
385{
386 if (1 < mapview_frozen_level) {
387 mapview_frozen_level--;
388 } else {
389 fc_assert(0 < mapview_frozen_level);
390 mapview_frozen_level = 0;
391 dirty_all();
392 }
393}
394
395/**********************************************************************/
398 bool mapview_is_frozen(void)
399{
400 return (0 < mapview_frozen_level);
401}
402
403/**********************************************************************/
406 void map_canvas_resize(GtkWidget *w, int width, int height,
407 gpointer data)
408{
409 mc_actual_width = width;
410 mc_actual_height = height;
411
412 map_canvas_size_refresh();
413}
414
415/**********************************************************************/
418 void map_canvas_size_refresh(void)
419{
420 map_canvas_resized(mc_actual_width / mouse_zoom,
421 mc_actual_height / mouse_zoom);
422}
423
424/**********************************************************************/
427 void map_canvas_draw(GtkDrawingArea *w, cairo_t *cr,
428 int width, int height, gpointer data)
429{
430 if (can_client_change_view() && !map_is_empty() && !mapview_is_frozen()) {
431 /* First we mark the area to be updated as dirty. Then we unqueue
432 * any pending updates, to make sure only the most up-to-date data
433 * is written (otherwise drawing bugs happen when old data is copied
434 * to screen). Then we draw all changed areas to the screen. */
435 unqueue_mapview_updates(FALSE);
436 cairo_scale(cr, mouse_zoom, mouse_zoom);
437 cairo_set_source_surface(cr, mapview.store->surface, 0, 0);
438 cairo_paint(cr);
439 }
440}
441
442/**********************************************************************/
446 void dirty_rect(int canvas_x, int canvas_y,
447 int pixel_width, int pixel_height)
448{
449 dirty_all();
450}
451
452/**********************************************************************/
455 void dirty_all(void)
456{
457 if (gtk_widget_get_realized(map_canvas)) {
458 gtk_widget_queue_draw(map_canvas);
459 }
460}
461
462/**********************************************************************/
467 void flush_dirty(void)
468{
469}
470
471/**********************************************************************/
476 void gui_flush(void)
477{
478 cairo_surface_flush(mapview.store->surface);
479}
480
481/**********************************************************************/
484 void update_city_descriptions(void)
485{
486 update_map_canvas_visible();
487}
488
489/**********************************************************************/
492 void put_unit_picture(struct unit *punit, GtkPicture *p, int height)
493{
494 struct canvas store = FC_STATIC_CANVAS_INIT;
495 int width;
496
497 if (height <= 0) {
498 height = tileset_full_tile_height(tileset);
499 }
500 width = tileset_full_tile_width(tileset);
501
502 store.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
503 width, height);
504
505 put_unit(punit, &store, 1.0, 0, 0);
506
507 picture_set_from_surface(p, store.surface);
508 cairo_surface_destroy(store.surface);
509}
510
511/**********************************************************************/
517 void put_unit_picture_city_overlays(struct unit *punit, GtkPicture *p,
518 int height,
519 int *upkeep_cost, int happy_cost)
520{
521 struct canvas store = FC_STATIC_CANVAS_INIT;
522 int width = tileset_full_tile_width(tileset);
523
524 store.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
525 width, height);
526
527 put_unit(punit, &store, 1.0, 0, 0);
528
529 put_unit_city_overlays(punit, &store, 0, tileset_unit_layout_offset_y(tileset),
530 upkeep_cost, happy_cost);
531
532 picture_set_from_surface(p, store.surface);
533 cairo_surface_destroy(store.surface);
534}
535
536/**********************************************************************/
539 void pixmap_put_overlay_tile(GdkSurface *pixmap, float zoom,
540 int canvas_x, int canvas_y,
541 struct sprite *ssprite)
542{
543#if 0
544 cairo_t *cr;
545 GdkDrawingContext *ctx;
546
547 if (!ssprite) {
548 return;
549 }
550
551 ctx = gdk_window_begin_draw_frame(pixmap, NULL,
552 gdk_window_get_clip_region(pixmap));
553 cr = gdk_drawing_context_get_cairo_context(ctx);
554 cairo_scale(cr, zoom, zoom);
555 cairo_set_source_surface(cr, ssprite->surface, canvas_x, canvas_y);
556 cairo_paint(cr);
557 gdk_window_end_draw_frame(pixmap, ctx);
558#endif
559}
560
561/**********************************************************************/
564 void pixmap_put_overlay_tile_draw(struct canvas *pcanvas,
565 int canvas_x, int canvas_y,
566 struct sprite *ssprite,
567 bool fog)
568{
569 cairo_t *cr;
570 int sswidth, ssheight;
571 const double bright = 0.65; /* Fogged brightness compared to unfogged */
572
573 if (!ssprite) {
574 return;
575 }
576
577 get_sprite_dimensions(ssprite, &sswidth, &ssheight);
578
579 if (fog) {
580 struct color *fogcol = color_alloc(0.0, 0.0, 0.0); /* black */
581 cairo_surface_t *fog_surface;
582 struct sprite *fogged;
583 unsigned char *mask_in;
584 unsigned char *mask_out;
585 int i, j;
586
587 /* Create sprites initially fully transparent */
588 fogcol->color.alpha = 0.0;
589 fogged = create_sprite(sswidth, ssheight, fogcol);
590 fog_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, sswidth, ssheight);
591
592 /* Calculate black fog mask from the original sprite's alpha channel;
593 * we don't want to blacken transparent parts of the sprite. */
594 mask_in = cairo_image_surface_get_data(ssprite->surface);
595 mask_out = cairo_image_surface_get_data(fog_surface);
596
597 for (i = 0; i < sswidth; i++) {
598 for (j = 0; j < ssheight; j++) {
599 /* In order to darken pixels of ssprite to 'bright' fraction of
600 * their original value, we need to overlay blackness of
601 * (1-bright) transparency. */
602 if (!is_bigendian()) {
603 mask_out[(j * sswidth + i) * 4 + 3]
604 = (1-bright) * mask_in[(j * sswidth + i) * 4 + 3];
605 } else {
606 mask_out[(j * sswidth + i) * 4 + 0]
607 = (1-bright) * mask_in[(j * sswidth + i) * 4 + 0];
608 }
609 }
610 }
611
612 cairo_surface_mark_dirty(fog_surface);
613
614 /* First copy original sprite canvas to intermediate sprite canvas */
615 cr = cairo_create(fogged->surface);
616 cairo_set_source_surface(cr, ssprite->surface, 0, 0);
617 cairo_paint(cr);
618
619 /* Then apply created fog to the intermediate sprite to darken it */
620 cairo_set_source_surface(cr, fog_surface, 0, 0);
621 cairo_paint(cr);
622 cairo_destroy(cr);
623
624 /* Put intermediate sprite to the target canvas */
625 canvas_put_sprite(pcanvas, canvas_x, canvas_y,
626 fogged, 0, 0, sswidth, ssheight);
627
628 /* Free intermediate stuff */
629 cairo_surface_destroy(fog_surface);
630 free_sprite(fogged);
631 color_free(fogcol);
632 } else {
633 canvas_put_sprite(pcanvas, canvas_x, canvas_y,
634 ssprite, 0, 0, sswidth, ssheight);
635 }
636}
637
638/**********************************************************************/
641 void put_cross_overlay_tile(struct tile *ptile)
642{
643 float canvas_x, canvas_y;
644
645 if (tile_to_canvas_pos(&canvas_x, &canvas_y, map_zoom, ptile)) {
646 GtkNative *nat = gtk_widget_get_native(map_canvas);
647
648 pixmap_put_overlay_tile(gtk_native_get_surface(nat), map_zoom,
649 canvas_x / map_zoom, canvas_y / map_zoom,
650 get_attention_crosshair_sprite(tileset));
651 }
652}
653
654/**********************************************************************/
657 void update_overview_scroll_window_pos(int x, int y)
658{
659 gdouble ov_scroll_x, ov_scroll_y;
660 GtkAdjustment *ov_hadj, *ov_vadj;
661
662 ov_hadj = gtk_scrolled_window_get_hadjustment(
663 GTK_SCROLLED_WINDOW(overview_scrolled_window));
664 ov_vadj = gtk_scrolled_window_get_vadjustment(
665 GTK_SCROLLED_WINDOW(overview_scrolled_window));
666
667 ov_scroll_x = MIN(x - (overview_canvas_store_width / 2),
668 gtk_adjustment_get_upper(ov_hadj)
669 - gtk_adjustment_get_page_size(ov_hadj));
670 ov_scroll_y = MIN(y - (overview_canvas_store_height / 2),
671 gtk_adjustment_get_upper(ov_vadj)
672 - gtk_adjustment_get_page_size(ov_vadj));
673
674 gtk_adjustment_set_value(ov_hadj, ov_scroll_x);
675 gtk_adjustment_set_value(ov_vadj, ov_scroll_y);
676}
677
678/**********************************************************************/
681 void update_map_canvas_scrollbars(void)
682{
683 int scroll_x, scroll_y;
684
685 get_mapview_scroll_pos(&scroll_x, &scroll_y);
686 gtk_adjustment_set_value(map_hadj, scroll_x);
687 gtk_adjustment_set_value(map_vadj, scroll_y);
688 if (can_client_change_view()) {
689 gtk_widget_queue_draw(overview_canvas);
690 }
691}
692
693/**********************************************************************/
696 void update_map_canvas_scrollbars_size(void)
697{
698 float xmin, ymin, xmax, ymax;
699 int xsize, ysize, xstep, ystep;
700
701 get_mapview_scroll_window(&xmin, &ymin, &xmax, &ymax, &xsize, &ysize);
702 get_mapview_scroll_step(&xstep, &ystep);
703
704 map_hadj = gtk_adjustment_new(-1, xmin, xmax, xstep, xsize, xsize);
705 map_vadj = gtk_adjustment_new(-1, ymin, ymax, ystep, ysize, ysize);
706
707 gtk_scrollbar_set_adjustment(GTK_SCROLLBAR(map_horizontal_scrollbar),
708 map_hadj);
709 gtk_scrollbar_set_adjustment(GTK_SCROLLBAR(map_vertical_scrollbar),
710 map_vadj);
711
712 g_signal_connect(map_hadj, "value_changed",
713 G_CALLBACK(scrollbar_jump_callback),
714 GINT_TO_POINTER(TRUE));
715 g_signal_connect(map_vadj, "value_changed",
716 G_CALLBACK(scrollbar_jump_callback),
717 GINT_TO_POINTER(FALSE));
718}
719
720/**********************************************************************/
723 void scrollbar_jump_callback(GtkAdjustment *adj, gpointer hscrollbar)
724{
725 int scroll_x, scroll_y;
726
727 if (!can_client_change_view()) {
728 return;
729 }
730
731 get_mapview_scroll_pos(&scroll_x, &scroll_y);
732
733 if (hscrollbar) {
734 scroll_x = gtk_adjustment_get_value(adj);
735 } else {
736 scroll_y = gtk_adjustment_get_value(adj);
737 }
738
739 set_mapview_scroll_pos(scroll_x, scroll_y, mouse_zoom);
740}
741
742/**********************************************************************/
751 void draw_selection_rectangle(int canvas_x, int canvas_y, int w, int h)
752{
753 struct color *pcolor;
754
755 if (w == 0 || h == 0) {
756 return;
757 }
758
759 pcolor = get_color(tileset, COLOR_MAPVIEW_SELECTION);
760 if (!pcolor) {
761 return;
762 }
763
764 canvas_put_line(mapview.store, pcolor, LINE_SELECT_RECT,
765 canvas_x, canvas_y, w, 0);
766 canvas_put_line(mapview.store, pcolor, LINE_SELECT_RECT,
767 canvas_x, canvas_y, 0, h);
768 canvas_put_line(mapview.store, pcolor, LINE_SELECT_RECT,
769 canvas_x, canvas_y + h, w, 0);
770 canvas_put_line(mapview.store, pcolor, LINE_SELECT_RECT,
771 canvas_x + w, canvas_y, 0, h);
772}
773
774/**********************************************************************/
777 void tileset_changed(void)
778{
779 science_report_dialog_redraw();
780 reset_city_dialogs();
781 reset_unit_table();
782 blank_max_unit_size();
783 editgui_tileset_changed();
784
785 /* keep the icon of the executable on Windows (see PR#36491) */
786#ifndef FREECIV_MSWINDOWS
787 {
788 /* Only call this after tileset_load_tiles is called. */
789 gtk_window_set_icon_name(GTK_WINDOW(toplevel), "freeciv");
790 }
791#endif /* FREECIV_MSWINDOWS */
792}
793
794/**********************************************************************/
797 void start_turn(void)
798{}
height
struct canvas int int struct sprite int int int int height
Definition canvas_g.h:44
pcolor
struct canvas int int struct sprite bool int int fog_y struct canvas struct sprite struct color * pcolor
Definition canvas_g.h:57
canvas_y
struct canvas int int canvas_y
Definition canvas_g.h:43
canvas_x
struct canvas int canvas_x
Definition canvas_g.h:43
canvas_put_sprite
canvas_put_sprite
Definition canvas_g.h:42
width
struct canvas int int struct sprite int int int width
Definition canvas_g.h:44
pcanvas
struct canvas * pcanvas
Definition canvas_g.h:42
LINE_SELECT_RECT
@ LINE_SELECT_RECT
Definition canvas_g.h:26
fog
struct canvas int int struct sprite bool fog
Definition canvas_g.h:51
client_is_observer
bool client_is_observer(void)
Definition client_main.c:1086
can_client_change_view
bool can_client_change_view(void)
Definition client_main.c:1313
client_main.h
client_player
#define client_player()
Definition client_main.h:106
climap.h
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
get_color
struct color * get_color(const struct tileset *t, enum color_std stdcolor)
Definition colors_common.c:100
update_unit_pix_label
void update_unit_pix_label(struct unit_list *punitlist)
Definition control.c:966
control_mouse_cursor
void control_mouse_cursor(struct tile *ptile)
Definition control.c:1188
control.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.h
get_turn_done_button_state
bool get_turn_done_button_state()
Definition mapctrl_common.c:519
MAX_LEN_NAME
#define MAX_LEN_NAME
Definition fc_types.h:66
O_SCIENCE
@ O_SCIENCE
Definition fc_types.h:91
O_LUXURY
@ O_LUXURY
Definition fc_types.h:91
O_GOLD
@ O_GOLD
Definition fc_types.h:91
fcintl.h
_
#define _(String)
Definition fcintl.h:67
current_turn_timeout
int current_turn_timeout(void)
Definition game.c:828
game.h
government.h
canvas_put_line
void canvas_put_line(struct canvas *pcanvas, struct color *pcolor, enum line_type ltype, int start_x, int start_y, int dx, int dy)
Definition canvas.c:223
FC_STATIC_CANVAS_INIT
#define FC_STATIC_CANVAS_INIT
Definition canvas.h:27
reset_city_dialogs
void reset_city_dialogs(void)
Definition citydlg.c:357
color_alloc
struct color * color_alloc(int r, int g, int b)
Definition colors.c:38
color_free
void color_free(struct color *color)
Definition colors.c:53
editgui_tileset_changed
void editgui_tileset_changed(void)
Definition editgui.c:1861
source
static GtkWidget * source
Definition gotodlg.c:58
fc_cursors
GdkCursor * fc_cursors[CURSOR_LAST][NUM_CURSOR_FRAMES]
Definition graphics.c:48
map_vertical_scrollbar
GtkWidget * map_vertical_scrollbar
Definition gui_main.c:108
main_label_info
GtkWidget * main_label_info
Definition gui_main.c:137
unit_info_label
GtkWidget * unit_info_label
Definition gui_main.c:150
timeout_label
GtkWidget * timeout_label
Definition gui_main.c:147
overview_scrolled_window
GtkWidget * overview_scrolled_window
Definition gui_main.c:111
government_label
GtkWidget * government_label
Definition gui_main.c:146
sun_label
GtkWidget * sun_label
Definition gui_main.c:144
turn_done_button
GtkWidget * turn_done_button
Definition gui_main.c:148
reset_unit_table
void reset_unit_table(void)
Definition gui_main.c:972
unit_info_frame
GtkWidget * unit_info_frame
Definition gui_main.c:152
flake_label
GtkWidget * flake_label
Definition gui_main.c:145
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
map_horizontal_scrollbar
GtkWidget * map_horizontal_scrollbar
Definition gui_main.c:107
map_canvas
GtkWidget * map_canvas
Definition gui_main.c:106
econ_label
GtkWidget * econ_label[10]
Definition gui_main.c:142
overview_canvas_store_width
int overview_canvas_store_width
Definition gui_main.c:121
overview_canvas_store_height
int overview_canvas_store_height
Definition gui_main.c:122
main_frame_civ_name
GtkWidget * main_frame_civ_name
Definition gui_main.c:136
GUI_GTK_OPTION
#define GUI_GTK_OPTION(optname)
Definition gui_main.h:25
update_timeout_label
void update_timeout_label(void)
Definition mapview.c:101
flush_dirty
void flush_dirty(void)
Definition mapview.c:450
cursor_frame
static int cursor_frame
Definition mapview.c:66
update_info_label
void update_info_label(void)
Definition mapview.c:121
update_turn_done_button
void update_turn_done_button(bool do_restore)
Definition mapview.c:75
scrollbar_jump_callback
void scrollbar_jump_callback(GtkAdjustment *adj, gpointer hscrollbar)
Definition mapview.c:700
dirty_all
void dirty_all(void)
Definition mapview.c:438
tileset_changed
void tileset_changed(void)
Definition mapview.c:764
put_cross_overlay_tile
void put_cross_overlay_tile(struct tile *ptile)
Definition mapview.c:622
draw_selection_rectangle
void draw_selection_rectangle(int canvas_x, int canvas_y, int w, int h)
Definition mapview.c:728
update_map_canvas_scrollbars_size
void update_map_canvas_scrollbars_size(void)
Definition mapview.c:675
get_overview_area_dimensions
void get_overview_area_dimensions(int *width, int *height)
Definition mapview.c:300
mapview_freeze
void mapview_freeze(void)
Definition mapview.c:356
get_thumb_pixbuf
GdkPixbuf * get_thumb_pixbuf(int onoff)
Definition mapview.c:275
start_turn
void start_turn(void)
Definition mapview.c:787
update_unit_info_label
void update_unit_info_label(struct unit_list *punits)
Definition mapview.c:258
update_overview_scroll_window_pos
void update_overview_scroll_window_pos(int x, int y)
Definition mapview.c:636
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
pixmap_put_overlay_tile
void pixmap_put_overlay_tile(GdkWindow *pixmap, float zoom, int canvas_x, int canvas_y, struct sprite *ssprite)
Definition mapview.c:525
gui_flush
void gui_flush(void)
Definition mapview.c:462
pixmap_put_overlay_tile_draw
void pixmap_put_overlay_tile_draw(struct canvas *pcanvas, int canvas_x, int canvas_y, struct sprite *ssprite, bool fog)
Definition mapview.c:545
update_map_canvas_scrollbars
void update_map_canvas_scrollbars(void)
Definition mapview.c:660
mapview_is_frozen
bool mapview_is_frozen(void)
Definition mapview.c:378
anim_cursor_cb
static gboolean anim_cursor_cb(gpointer data)
Definition mapview.c:214
overview_size_changed
void overview_size_changed(void)
Definition mapview.c:309
map_canvas_size_refresh
void map_canvas_size_refresh(void)
Definition mapview.c:397
cursor_timer_id
static int cursor_timer_id
Definition mapview.c:66
map_vadj
static GtkAdjustment * map_vadj
Definition mapview.c:65
mapview_frozen_level
static int mapview_frozen_level
Definition mapview.c:67
mapview_thaw
void mapview_thaw(void)
Definition mapview.c:364
get_overview_window
struct canvas * get_overview_window(void)
Definition mapview.c:320
update_mouse_cursor
void update_mouse_cursor(enum cursor_type new_cursor_type)
Definition mapview.c:240
map_hadj
static GtkAdjustment * map_hadj
Definition mapview.c:65
set_indicator_icons
void set_indicator_icons(struct sprite *bulb, struct sprite *sol, struct sprite *flake, struct sprite *gov)
Definition mapview.c:285
overview_canvas_draw
gboolean overview_canvas_draw(GtkWidget *w, cairo_t *cr, gpointer data)
Definition mapview.c:339
CURSOR_INTERVAL
#define CURSOR_INTERVAL
Definition mapview.h:32
science_report_dialog_redraw
void science_report_dialog_redraw(void)
Definition repodlgs.c:761
get_sprite_dimensions
void get_sprite_dimensions(struct sprite *sprite, int *width, int *height)
Definition sprite.c:107
free_sprite
void free_sprite(struct sprite *s)
Definition sprite.c:278
sprite_get_pixbuf
GdkPixbuf * sprite_get_pixbuf(struct sprite *sprite)
Definition sprite.c:402
blank_max_unit_size
void blank_max_unit_size(void)
Definition wldlg.c:79
editgui.h
econ_widget
GtkWidget * econ_widget
Definition gui_main.c:153
gui_stuff.h
mc_actual_width
static int mc_actual_width
Definition mapview.c:69
mc_actual_height
static int mc_actual_height
Definition mapview.c:70
map_canvas_resize
void map_canvas_resize(GtkWidget *w, int width, int height, gpointer data)
Definition mapview.c:406
put_unit_picture_city_overlays
void put_unit_picture_city_overlays(struct unit *punit, GtkPicture *p, int height, int *upkeep_cost, int happy_cost)
Definition mapview.c:517
put_unit_picture
void put_unit_picture(struct unit *punit, GtkPicture *p, int height)
Definition mapview.c:492
picture_set_from_surface
void picture_set_from_surface(GtkPicture *pic, cairo_surface_t *surf)
Definition sprite.c:544
citydlg.h
colors.h
graphics.h
gui_main.h
mapctrl.h
mapview.h
repodlgs.h
wldlg.h
name
const char * name
Definition inputfile.c:127
log.h
fc_assert
#define fc_assert(condition)
Definition log.h:176
map_is_empty
bool map_is_empty(void)
Definition map.c:149
map.h
get_timeout_label_text
const char * get_timeout_label_text()
Definition text.c:1590
update_map_canvas_visible
void update_map_canvas_visible(void)
Definition mapview_common.c:1843
mapview
struct view mapview
Definition mapview_common.c:74
put_unit
void put_unit(const struct unit *punit, struct canvas *pcanvas, float zoom, int canvas_x, int canvas_y)
Definition mapview_common.c:1374
get_mapview_scroll_pos
void get_mapview_scroll_pos(int *scroll_x, int *scroll_y)
Definition mapview_common.c:1191
get_mapview_scroll_window
void get_mapview_scroll_window(float *xmin, float *ymin, float *xmax, float *ymax, int *xsize, int *ysize)
Definition mapview_common.c:1093
unqueue_mapview_updates
void unqueue_mapview_updates(bool write_to_screen)
Definition mapview_common.c:3068
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
put_unit_city_overlays
void put_unit_city_overlays(struct unit *punit, struct canvas *pcanvas, int canvas_x, int canvas_y, int *upkeep_cost, int happy_cost)
Definition mapview_common.c:1438
map_canvas_resized
bool map_canvas_resized(int width, int height)
Definition mapview_common.c:3593
tile_to_canvas_pos
bool tile_to_canvas_pos(float *canvas_x, float *canvas_y, float zoom, const struct tile *ptile)
Definition mapview_common.c:694
dirty_rect
dirty_rect
Definition mapview_g.h:47
pixel_width
int int int pixel_width
Definition mapview_g.h:48
mem.h
nation_plural_for_player
const char * nation_plural_for_player(const struct player *pplayer)
Definition nation.c:177
gui_options
struct client_options gui_options
Definition options.c:71
options.h
GUI_GTK_OVERVIEW_MIN_XSIZE
#define GUI_GTK_OVERVIEW_MIN_XSIZE
Definition options.h:574
GUI_GTK_OVERVIEW_MIN_YSIZE
#define GUI_GTK_OVERVIEW_MIN_YSIZE
Definition options.h:575
overview_common.h
len
int len
Definition packhand.c:125
get_government_tooltip
const char * get_government_tooltip(void)
Definition text.c:1511
get_nuclear_winter_tooltip
const char * get_nuclear_winter_tooltip(void)
Definition text.c:1484
get_bulb_tooltip
const char * get_bulb_tooltip(void)
Definition text.c:1400
get_info_label_text
const char * get_info_label_text(bool)
Definition text.c:950
get_global_warming_tooltip
const char * get_global_warming_tooltip(void)
Definition text.c:1457
player.h
rand.h
MIN
#define MIN(x, y)
Definition shared.h:55
BOOL_VAL
#define BOOL_VAL(x)
Definition shared.h:70
create_sprite
create_sprite
Definition sprite_g.h:30
canvas
Definition canvas.h:21
canvas::zoom
float zoom
Definition canvas.h:24
canvas::surface
cairo_surface_t * surface
Definition canvas.h:22
canvas::drawable
cairo_t * drawable
Definition canvas.h:23
client_options::overview
struct overview overview
Definition options.h:402
color
Definition colors.h:20
color::color
GdkRGBA color
Definition colors.h:21
overview::width
int width
Definition options.h:93
overview::window
struct canvas * window
Definition options.h:99
overview::height
int height
Definition options.h:93
player_economic::luxury
int luxury
Definition player.h:73
player_economic::science
int science
Definition player.h:72
player
Definition player.h:249
player::economic
struct player_economic economic
Definition player.h:284
player::nation
struct nation_type * nation
Definition player.h:260
sprite
Definition sprite.h:22
sprite::surface
cairo_surface_t * surface
Definition sprite.h:23
tile
Definition tile.h:49
tileset
Definition tilespec.c:459
unit
Definition unit.h:138
view::store
struct canvas * store
Definition mapview_common.h:42
support.h
is_bigendian
static bool is_bigendian(void)
Definition support.h:201
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
sz_strlcat
#define sz_strlcat(dest, src)
Definition support.h:162
get_unit_info_label_text2
const char * get_unit_info_label_text2(struct unit_list *punits, int linebreaks)
Definition text.c:1112
get_unit_info_label_text1
const char * get_unit_info_label_text1(struct unit_list *punits)
Definition text.c:1087
text.h
get_attention_crosshair_sprite
struct sprite * get_attention_crosshair_sprite(const struct tileset *t)
Definition tilespec.c:6689
tileset_full_tile_height
int tileset_full_tile_height(const struct tileset *t)
Definition tilespec.c:752
tileset_unit_layout_offset_y
int tileset_unit_layout_offset_y(const struct tileset *t)
Definition tilespec.c:845
get_treaty_thumb_sprite
struct sprite * get_treaty_thumb_sprite(const struct tileset *t, bool on_off)
Definition tilespec.c:6609
tileset_full_tile_width
int tileset_full_tile_width(const struct tileset *t)
Definition tilespec.c:739
get_tax_sprite
struct sprite * get_tax_sprite(const struct tileset *t, Output_type_id otype)
Definition tilespec.c:6579
tilespec.h
NUM_CURSOR_FRAMES
#define NUM_CURSOR_FRAMES
Definition tilespec.h:300
cursor_type
cursor_type
Definition tilespec.h:285
CURSOR_DEFAULT
@ CURSOR_DEFAULT
Definition tilespec.h:297
timing.h
mouse_zoom
float mouse_zoom
Definition zoom.c:28
map_zoom
float map_zoom
Definition zoom.c:25
zoom.h