Freeciv-3.2
Loading...
Searching...
No Matches
helpdlg.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <math.h> /* sqrt */
22
23#include <gtk/gtk.h>
24
25/* utility */
26#include "fcintl.h"
27#include "mem.h"
28#include "shared.h"
29#include "support.h"
30
31/* common */
32#include "city.h"
33#include "game.h"
34#include "government.h"
35#include "movement.h"
36#include "nation.h"
37#include "specialist.h"
38#include "tech.h"
39#include "unit.h"
40#include "map.h"
41#include "research.h"
42#include "version.h"
43
44/* client */
45#include "client_main.h"
46#include "climisc.h"
47#include "helpdata.h"
48#include "options.h"
49#include "tilespec.h"
50
51/* client/gui-gtk-3.22 */
52#include "colors.h"
53#include "graphics.h"
54#include "gui_main.h"
55#include "gui_stuff.h"
56
57#include "helpdlg.h"
58
59#define TECH_TREE_DEPTH 20
60
61/*
62 * Globals.
63 */
64static GtkWidget *help_dialog_shell;
65static GtkWidget *help_view_sw;
66
67static GtkWidget *help_view;
68
69static GtkWidget *help_frame;
70static GtkTextBuffer *help_text;
71static GtkWidget *help_text_sw;
72static GtkWidget *help_vbox;
73static GtkWidget *help_tile;
74static GtkWidget *help_box;
75static GtkWidget *help_itable;
76static GtkWidget *help_wtable;
77static GtkWidget *help_utable;
78static GtkWidget *help_ttable;
79static GtkWidget *help_etable;
80static GtkWidget *help_tree;
81static GtkTreeStore *tstore;
82
83static GtkWidget *help_tree_sw;
84static GtkWidget *help_tree_expand;
85static GtkWidget *help_tree_collapse;
86static GtkWidget *help_tree_buttons_hbox;
87static GtkWidget *help_ilabel[6];
88static GtkWidget *help_wlabel[6];
89static GtkWidget *help_ulabel[5][5];
90static GtkWidget *help_tlabel[2][5];
91static GtkWidget *help_elabel[6];
92
93static bool help_advances[A_LAST];
94
95static GPtrArray *help_history;
96static int help_history_pos;
97
98struct help_page_selection
99{
100 enum { HPAGE_SRC_ENUM, HPAGE_SRC_REQ } type;
101 union {
102 enum help_page_type page;
103 const struct requirement *req;
104 } u;
105};
106
107static const char *help_ilabel_name[6] =
108{ N_("Base Cost:"), NULL, N_("Upkeep:"), NULL, N_("Requirement:"), NULL };
109static struct help_page_selection help_impr_req;
110
111static const char *help_wlabel_name[6] =
112{ N_("Base Cost:"), NULL, N_("Requirement:"), NULL, N_("Obsolete by:"), NULL };
113static struct help_page_selection help_wndr_req;
114
115static struct help_page_selection page_selections[HELP_LAST];
116
117static const char *help_ulabel_name[5][5] =
118{
119 { N_("Cost:"), NULL, NULL, N_("Attack:"), NULL },
120 { N_("Defense:"), NULL, NULL, N_("Move:"), NULL },
121 { N_("Firepower:"), NULL, NULL, N_("Hitpoints:"), NULL },
122 { N_("Basic Upkeep:"), NULL, NULL, N_("Vision:"), NULL },
123 { N_("Requirement:"), NULL, NULL, N_("Obsolete by:"), NULL }
124};
125
126static const char *help_tlabel_name[2][5] =
127{
128 { N_("Move/Defense:"), NULL, NULL, N_("Food/Res/Trade:"), NULL },
129 { N_("Resources:"), NULL, NULL, NULL, NULL }
130};
131
132static const char *help_elabel_name[6] =
133/* TRANS: Label for build cost for extras in help. Will be followed by
134 * something like "3 MP" (where MP = Movement Points) */
135{ N_("Build:"), NULL,
136/* TRANS: Extra conflicts in help. Will be followed by a list of extras
137 * that can't be built on the same tile as this one. */
138 N_("Conflicts with:"), NULL,
139/* TRANS: Extra bonus in help. Will be followed by food/production/trade
140 * stats like "0/0/+1", "0/+50%/0" */
141 N_("Bonus (F/P/T):"), NULL };
142
143#define REQ_LABEL_NONE _("?tech:None")
144#define REQ_LABEL_NEVER _("(Never)")
145
146static void create_help_dialog(void);
147static void help_update_dialog(const struct help_item *pitem);
148
149static void select_help_item_string(const char *item,
150 enum help_page_type htype);
151static void help_command_update(void);
152static void help_command_callback(GtkWidget *w, gint response_id);
153
154/**********************************************************************/
169
170/**********************************************************************/
173static void set_title_topic(char *topic)
174{
175 if (strcmp(topic, _(HELP_ABOUT_ITEM)) == 0) {
176 gtk_frame_set_label(GTK_FRAME(help_frame), freeciv_name_version());
177 } else {
178 gtk_frame_set_label(GTK_FRAME(help_frame), topic);
179 }
180 return;
181}
182
183/**********************************************************************/
192
193/**********************************************************************/
207
208/**********************************************************************/
216
217/**********************************************************************/
226static void create_tech_tree(int tech, int levels, GtkTreeIter *parent)
227{
228 const struct research *presearch;
229 int bg;
230 int turns_to_tech;
231 bool original;
232 GtkTreeIter l;
233 GValue value = { 0, };
234 enum tech_state state;
235
236 if (advance_required(tech, AR_ONE) == A_LAST
237 && advance_required(tech, AR_TWO) == A_LAST) {
238 bg = COLOR_REQTREE_UNKNOWN;
239
240 gtk_tree_store_append(tstore, &l, parent);
241 help_advances[tech] = TRUE;
242
243 g_value_init(&value, G_TYPE_STRING);
244 g_value_set_static_string(&value, _("Removed"));
245 gtk_tree_store_set_value(tstore, &l, 0, &value);
246 g_value_unset(&value);
247
248 gtk_tree_store_set(tstore, &l,
249 1, -1,
250 2, tech,
251 3, &get_color(tileset, bg)->color
252 -1);
253 return;
254 }
255
256 presearch = research_get(client_player());
257
258 state = research_invention_state(presearch, tech);
259 if (tech_state_is_valid(state)) {
260 switch (state) {
261 case TECH_UNKNOWN:
262 bg = COLOR_REQTREE_UNKNOWN;
263 break;
264 case TECH_KNOWN:
265 bg = COLOR_REQTREE_KNOWN;
266 break;
267 case TECH_PREREQS_KNOWN:
268 bg = COLOR_REQTREE_PREREQS_KNOWN;
269 break;
270 }
271 } else {
272 bg = COLOR_REQTREE_BACKGROUND;
273 }
274 turns_to_tech = research_goal_unknown_techs(presearch, tech);
275
276 /* l is the original in the tree. */
277 original = !help_advances[tech];
278
279 gtk_tree_store_append(tstore, &l, parent);
280 help_advances[tech] = TRUE;
281
282 g_value_init(&value, G_TYPE_STRING);
283 g_value_set_static_string(&value,
284 research_advance_name_translation(presearch,
285 tech));
286 gtk_tree_store_set_value(tstore, &l, 0, &value);
287 g_value_unset(&value);
288
289 gtk_tree_store_set(tstore, &l,
290 1, turns_to_tech,
291 2, tech,
292 3, &get_color(tileset, bg)->color,
293 -1);
294
295 if (--levels <= 0) {
296 return;
297 }
298
299 if (original) {
300 /* only add children to orginals */
301 if (advance_required(tech, AR_ONE) != A_NONE)
302 create_tech_tree(advance_required(tech, AR_ONE), levels, &l);
303 if (advance_required(tech, AR_TWO) != A_NONE)
304 create_tech_tree(advance_required(tech, AR_TWO), levels, &l);
305 }
306 return;
307}
308
309/**********************************************************************/
325
326/**********************************************************************/
333
334/**********************************************************************/
341
342/**********************************************************************/
345static void help_hyperlink_callback(GtkWidget *w)
346{
347 const char *s;
348 struct help_page_selection *select;
349 enum help_page_type type = HELP_LAST;
350
351 s = gtk_label_get_text(GTK_LABEL(w));
352 select = (struct help_page_selection *)(g_object_get_data(G_OBJECT(w), "page_type"));
353
354 switch (select->type) {
355 case HPAGE_SRC_ENUM:
356 type = select->u.page;
357 break;
358 case HPAGE_SRC_REQ:
359 type = help_type_by_requirement(select->u.req);
360 break;
361 }
362
363 if (type == HELP_LAST) {
364 return;
365 }
366
367 /* FIXME: May be able to skip, or may need to modify, advances[A_NONE]
368 below, depending on which i18n is done elsewhere.
369 */
370 if (strcmp(s, REQ_LABEL_NEVER) != 0
371 && strcmp(s, skip_intl_qualifier_prefix(REQ_LABEL_NONE)) != 0
372 && strcmp(s, advance_name_translation(advance_by_number(A_NONE))) != 0) {
373 select_help_item_string(s, type);
374 }
375}
376
377/**********************************************************************/
380static GtkWidget *help_hyperlink_new(GtkWidget *label,
381 struct help_page_selection *select)
382{
383 GtkWidget *button;
384
385 button = gtk_button_new();
386 gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
387 gtk_widget_set_halign(label, GTK_ALIGN_CENTER);
388 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
389 gtk_widget_set_name(label, "help_link");
390 gtk_container_add(GTK_CONTAINER(button), label);
391 gtk_widget_show(button);
392 g_signal_connect_swapped(button, "clicked",
393 G_CALLBACK(help_hyperlink_callback), label);
394 g_object_set_data(G_OBJECT(label), "page_type", select);
395
396 return button;
397}
398
399/**********************************************************************/
402static GtkWidget *help_hyperlink_new_page(GtkWidget *label,
403 enum help_page_type page)
404{
405 return help_hyperlink_new(label, &(page_selections[page]));
406}
407
408/**********************************************************************/
411static GtkWidget *help_slink_new(const gchar *txt,
412 struct help_page_selection *select)
413{
414 GtkWidget *button, *label;
415
416 label = gtk_label_new(txt);
417 gtk_widget_set_halign(label, GTK_ALIGN_CENTER);
418 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
419 button = help_hyperlink_new(label, select);
420
421 return button;
422}
423
424/**********************************************************************/
427static GtkWidget *help_slink_new_page(const gchar *txt,
428 enum help_page_type page)
429{
430 return help_slink_new(txt, &(page_selections[page]));
431}
432
433/**********************************************************************/
456
457/**********************************************************************/
465
466/**********************************************************************/
469static void activated_topic(GtkTreeView *view, gpointer data)
470{
471 GtkTreePath *path;
472 GtkTreeViewColumn *col;
473 GtkTreeModel *model;
474 GtkTreeIter it;
475 struct help_item *pitem;
476
477 model = gtk_tree_view_get_model(view);
478
479 gtk_tree_view_get_cursor(view, &path, &col);
480 gtk_tree_model_get_iter(model, &it, path);
481 gtk_tree_path_free(path);
482
483 if (!path) {
484 return;
485 }
486
487 gtk_tree_model_get(model, &it, 1, &pitem, -1);
488
489 if (help_history_pos >= 0
490 && g_ptr_array_index(help_history, help_history_pos) == (gpointer) pitem) {
491 return;
492 }
493
494 help_update_dialog(pitem);
495
496 /* add to history. */
497 if (help_history_pos < help_history->len - 1) {
498 g_ptr_array_set_size(help_history, help_history_pos + 1);
499 }
500 help_history_pos++;
501
502 g_ptr_array_add(help_history, (gpointer)pitem);
503 help_command_update();
504}
505
506/**********************************************************************/
509static void create_help_dialog(void)
510{
511 GtkWidget *hbox;
512 GtkWidget *button;
513 GtkWidget *text;
514 int i, j;
515 GtkCellRenderer *rend;
516 GtkTreeViewColumn *col;
517 GArray *array;
518 GtkTreeStore *store;
519 GtkTreeSelection *selection;
520
521 help_history = g_ptr_array_new();
522 help_history_pos = -1;
523
524 help_dialog_shell = gtk_dialog_new_with_buttons(_("Freeciv Help Browser"),
525 NULL,
526 0,
527 _("_Back"),
528 1,
529 _("_Forward"),
530 2,
531 _("_Close"),
532 GTK_RESPONSE_CLOSE,
533 NULL);
534 setup_dialog(help_dialog_shell, toplevel);
535 gtk_dialog_set_default_response(GTK_DIALOG(help_dialog_shell),
536 GTK_RESPONSE_CLOSE);
537 gtk_widget_set_name(help_dialog_shell, "Freeciv");
538
539 g_signal_connect(help_dialog_shell, "response",
540 G_CALLBACK(help_command_callback), NULL);
541 g_signal_connect(help_dialog_shell, "destroy",
542 G_CALLBACK(help_destroy_callback), NULL);
543
544 hbox = gtk_grid_new();
545 gtk_grid_set_column_spacing(GTK_GRID(hbox), 5);
546 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(help_dialog_shell))), hbox);
547 gtk_widget_show(hbox);
548
549 /* build tree store. */
550 store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
551
552 array = g_array_new(FALSE, FALSE, sizeof(GtkTreeIter));
553 help_items_iterate(pitem) {
554 GtkTreeIter *it, *parent;
555 const char *s;
556 int depth;
557
558 for (s = pitem->topic; *s == ' '; s++) {
559 /* nothing */
560 }
561 depth = s - pitem->topic;
562
563 array = g_array_set_size(array, depth+1);
564
565 if (depth > 0) {
566 parent = &g_array_index(array, GtkTreeIter, depth-1);
567 } else {
568 parent = NULL;
569 }
570
571 it = &g_array_index(array, GtkTreeIter, depth);
572 gtk_tree_store_append(store, it, parent);
573
574 gtk_tree_store_set(store, it, 0, pitem->topic, 1, pitem, -1);
575 } help_items_iterate_end;
576
577
578 /* create tree view. */
579 help_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
580 g_object_unref(store);
581 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(help_view));
582 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(help_view), FALSE);
583
584 g_signal_connect(help_view, "cursor-changed",
585 G_CALLBACK(activated_topic), NULL);
586
587 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(help_view));
588 gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
589
590 rend = gtk_cell_renderer_text_new();
591 col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL);
592 gtk_tree_view_append_column(GTK_TREE_VIEW(help_view), col);
593
594 help_view_sw = gtk_scrolled_window_new(NULL, NULL);
595 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(help_view_sw),
596 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
597 gtk_widget_set_size_request(help_view_sw, 190, -1);
598 gtk_container_add(GTK_CONTAINER(help_view_sw), help_view);
599 gtk_widget_show(help_view);
600 gtk_container_add(GTK_CONTAINER(hbox), help_view_sw);
601 gtk_widget_show(help_view_sw);
602
603 help_frame = gtk_frame_new("");
604 gtk_container_add(GTK_CONTAINER(hbox), help_frame);
605 gtk_widget_set_size_request(help_frame, 520, 350);
606 gtk_widget_show(help_frame);
607
608 help_box = gtk_grid_new();
609 gtk_grid_set_row_spacing(GTK_GRID(help_box), 5);
610 gtk_orientable_set_orientation(GTK_ORIENTABLE(help_box),
611 GTK_ORIENTATION_VERTICAL);
612 gtk_container_add(GTK_CONTAINER(help_frame), help_box);
613
614 help_tile = gtk_image_new();
615 gtk_container_add(GTK_CONTAINER(help_box), help_tile);
616
617 help_itable = gtk_grid_new();
618 gtk_container_add(GTK_CONTAINER(help_box), help_itable);
619
620 for (i = 0; i < 6; i++) {
621 help_ilabel[i] =
622 gtk_label_new(help_ilabel_name[i] != NULL ? _(help_ilabel_name[i]) : "");
623 gtk_widget_set_hexpand(help_ilabel[i], TRUE);
624
625 if (i == 5) {
626 button = help_hyperlink_new(help_ilabel[i], &help_impr_req);
627 gtk_grid_attach(GTK_GRID(help_itable), button, i, 0, 1, 1);
628 } else {
629 gtk_grid_attach(GTK_GRID(help_itable), help_ilabel[i], i, 0, 1, 1);
630 gtk_widget_set_name(help_ilabel[i], "help_label");
631 }
632
633 gtk_widget_show(help_ilabel[i]);
634 }
635
636 help_wtable = gtk_grid_new();
637 gtk_container_add(GTK_CONTAINER(help_box), help_wtable);
638
639 for (i = 0; i < 6; i++) {
640 help_wlabel[i] =
641 gtk_label_new(help_wlabel_name[i] ? _(help_wlabel_name[i]) : "");
642 gtk_widget_set_hexpand(help_wlabel[i], TRUE);
643
644 if (i == 3 || i == 5) {
645 button = help_hyperlink_new(help_wlabel[i], &help_wndr_req);
646 gtk_grid_attach(GTK_GRID(help_wtable), button, i, 0, 1, 1);
647 } else {
648 gtk_grid_attach(GTK_GRID(help_wtable), help_wlabel[i], i, 0, 1, 1);
649 gtk_widget_set_name(help_wlabel[i], "help_label");
650 }
651
652 gtk_widget_show(help_wlabel[i]);
653 }
654
655 help_utable = gtk_grid_new();
656 gtk_container_add(GTK_CONTAINER(help_box), help_utable);
657
658 for (i = 0; i < 5; i++) {
659 for (j = 0; j < 5; j++) {
660 help_ulabel[j][i] =
661 gtk_label_new(help_ulabel_name[j][i] ? _(help_ulabel_name[j][i]) : "");
662 gtk_widget_set_hexpand(help_ulabel[j][i], TRUE);
663
664 if (j == 4 && (i == 1 || i == 4)) {
665 if (i == 1) {
666 button = help_hyperlink_new_page(help_ulabel[j][i], HELP_TECH);
667 } else {
668 button = help_hyperlink_new_page(help_ulabel[j][i], HELP_UNIT);
669 }
670
671 gtk_grid_attach(GTK_GRID(help_utable), button, i, j, 1, 1);
672 } else {
673 gtk_grid_attach(GTK_GRID(help_utable), help_ulabel[j][i],
674 i, j, 1, 1);
675 gtk_widget_set_name(help_ulabel[j][i], "help_label");
676 }
677 gtk_widget_show(help_ulabel[j][i]);
678 }
679 }
680
681 help_ttable = gtk_grid_new();
682 gtk_container_add(GTK_CONTAINER(help_box), help_ttable);
683
684 for (j = 0; j < 2; j++) {
685 for (i = 0; i < 5; i++) {
686 help_tlabel[j][i] =
687 gtk_label_new(help_tlabel_name[j][i] ? _(help_tlabel_name[j][i]) : "");
688 gtk_widget_set_hexpand(help_tlabel[j][i], TRUE);
689 gtk_widget_set_name(help_tlabel[j][i], "help_label");
690
691 /* Ugly (but these numbers are hardcoded in help_update_terrain() too) */
692 if (j == 1 && i == 1) {
693 /* Extra wide cell for terrain specials */
694 gtk_grid_attach(GTK_GRID(help_ttable), help_tlabel[j][i],
695 i, j, 4, 1);
696 gtk_widget_show(help_tlabel[j][i]);
697 break; /* skip rest of row */
698 } else {
699 gtk_grid_attach(GTK_GRID(help_ttable), help_tlabel[j][i],
700 i, j, 1, 1);
701 gtk_widget_show(help_tlabel[j][i]);
702 }
703 }
704 }
705
706 help_etable = gtk_grid_new();
707 gtk_container_add(GTK_CONTAINER(help_box), help_etable);
708
709 for (i = 0; i < 6; i++) {
710 help_elabel[i] =
711 gtk_label_new(help_elabel_name[i] ? _(help_elabel_name[i]) : "");
712 gtk_widget_set_hexpand(help_elabel[i], TRUE);
713 gtk_grid_attach(GTK_GRID(help_etable), help_elabel[i], i % 4, i / 4, 1, 1);
714 gtk_widget_set_name(help_elabel[i], "help_label");
715 gtk_widget_show(help_elabel[i]);
716 }
717
718 help_vbox = gtk_grid_new();
719 gtk_grid_set_row_spacing(GTK_GRID(help_vbox), 1);
720 gtk_orientable_set_orientation(GTK_ORIENTABLE(help_vbox),
721 GTK_ORIENTATION_VERTICAL);
722 gtk_container_set_border_width(GTK_CONTAINER(help_vbox), 5);
723 gtk_container_add(GTK_CONTAINER(help_box), help_vbox);
724
725 text = gtk_text_view_new();
726 gtk_widget_set_hexpand(text, TRUE);
727 gtk_widget_set_vexpand(text, TRUE);
728 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text), FALSE);
729 gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
730 gtk_container_set_border_width(GTK_CONTAINER(text), 5);
731 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
732 gtk_widget_set_name(text, "help_text");
733 help_text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
734 gtk_widget_show(text);
735
736 help_text_sw = gtk_scrolled_window_new(NULL, NULL);
737 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(help_text_sw),
738 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
739 gtk_container_add(GTK_CONTAINER(help_text_sw), text);
740 gtk_container_add(GTK_CONTAINER(help_box), help_text_sw);
741
742 /* build tech store. */
743 tstore = gtk_tree_store_new(4,
744 G_TYPE_STRING, /* tech name */
745 G_TYPE_INT, /* turns to tech */
746 G_TYPE_INT, /* tech id */
747 GDK_TYPE_RGBA); /* color */
748 help_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tstore));
749 gtk_widget_set_hexpand(help_tree, TRUE);
750 gtk_widget_set_vexpand(help_tree, TRUE);
751 g_object_unref(tstore);
752 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(help_tree), FALSE);
753
754 g_signal_connect(help_tree, "row_activated",
755 G_CALLBACK(help_tech_tree_activated_callback), NULL);
756
757
758 col = gtk_tree_view_column_new();
759
760 rend = gtk_cell_renderer_text_new();
761 g_object_set(rend, "weight", PANGO_WEIGHT_BOLD, NULL);
762 gtk_tree_view_column_pack_start(col, rend, TRUE);
763 gtk_tree_view_column_set_attributes(col, rend,
764 "text", 0,
765 "background-rgba", 3,
766 NULL);
767 rend = gtk_cell_renderer_text_new();
768 g_object_set(rend, "weight", PANGO_WEIGHT_BOLD, "xalign", 1.0, NULL);
769 gtk_tree_view_column_pack_start(col, rend, FALSE);
770 gtk_tree_view_column_set_attributes(col, rend,
771 "text", 1,
772 "background-rgba", 3,
773 NULL);
774
775 gtk_tree_view_append_column(GTK_TREE_VIEW(help_tree), col);
776
777
778 help_tree_sw = gtk_scrolled_window_new(NULL, NULL);
779 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(help_tree_sw),
780 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
781 gtk_container_add(GTK_CONTAINER(help_tree_sw), help_tree);
782 gtk_widget_show(help_tree);
783 gtk_container_add(GTK_CONTAINER(help_box), help_tree_sw);
784
785 help_tree_expand
786 = gtk_button_new_with_label(_("Expand All"));
787 help_tree_collapse = gtk_button_new_with_label(_("Collapse All"));
788
789 g_signal_connect(help_tree_expand, "clicked",
790 G_CALLBACK(help_tech_tree_expand_callback), help_tree);
791 g_signal_connect(help_tree_collapse, "clicked",
792 G_CALLBACK(help_tech_tree_collapse_callback), help_tree);
793
794 help_tree_buttons_hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
795 gtk_container_add(GTK_CONTAINER(help_tree_buttons_hbox), help_tree_expand);
796 gtk_container_add(GTK_CONTAINER(help_tree_buttons_hbox), help_tree_collapse);
797 gtk_container_add(GTK_CONTAINER(help_box), help_tree_buttons_hbox);
798 gtk_widget_show_all(help_tree_buttons_hbox);
799}
800
801/**********************************************************************/
804static void set_help_tile_from_sprite(struct sprite *spr)
805{
806 if (spr == NULL) {
807 return;
808 }
809
810 gtk_image_set_from_surface(GTK_IMAGE(help_tile), spr->surface);
811 gtk_widget_show(help_tile);
812}
813
814/**********************************************************************/
844
845/**********************************************************************/
872
873/**********************************************************************/
876static void help_update_improvement(const struct help_item *pitem,
877 char *title)
878{
879 char buf[8192];
880 struct impr_type *imp = improvement_by_translated_name(title);
881
882 if (imp && !is_great_wonder(imp)) {
883 const char *req = skip_intl_qualifier_prefix(REQ_LABEL_NONE);
884 char req_buf[512];
885
886 sprintf(buf, "%d", impr_base_build_shield_cost(imp));
887 gtk_label_set_text(GTK_LABEL(help_ilabel[1]), buf);
888 sprintf(buf, "%d", imp->upkeep);
889 gtk_label_set_text(GTK_LABEL(help_ilabel[3]), buf);
890
891 /* FIXME: this should show ranges, negated reqs, and all the
892 * MAX_NUM_REQS reqs.
893 * Currently it's limited to 1 req but this code is partially prepared
894 * to be extended. Remember MAX_NUM_REQS is a compile-time
895 * definition. */
896 help_impr_req.u.req = NULL;
897 requirement_vector_iterate(&imp->reqs, preq) {
898 if (!preq->present) {
899 continue;
900 }
901 req = universal_name_translation(&preq->source, req_buf, sizeof(req_buf));
902 help_impr_req.u.req = preq;
903 break;
904 } requirement_vector_iterate_end;
905 gtk_label_set_text(GTK_LABEL(help_ilabel[5]), req);
906/* create_tech_tree(help_improvement_tree, 0, imp->tech_req, 3);*/
907 } else {
908 gtk_label_set_text(GTK_LABEL(help_ilabel[1]), "0");
909 gtk_label_set_text(GTK_LABEL(help_ilabel[3]), "0");
910 gtk_label_set_text(GTK_LABEL(help_ilabel[5]), REQ_LABEL_NEVER);
911/* create_tech_tree(help_improvement_tree, 0, advance_count(), 3);*/
912 }
913
914 set_help_tile_from_sprite(get_building_sprite(tileset, imp));
915
916 gtk_widget_show(help_itable);
917
918 helptext_building(buf, sizeof(buf), client.conn.playing, pitem->text, imp);
919 gtk_text_buffer_set_text(help_text, buf, -1);
920 gtk_widget_show(help_text_sw);
921}
922
923/**********************************************************************/
926static void help_update_wonder(const struct help_item *pitem,
927 char *title)
928{
929 char buf[8192];
930 struct impr_type *imp = improvement_by_translated_name(title);
931
932 if (imp && is_great_wonder(imp)) {
933 int i;
934 char req_buf[512];
935
936 sprintf(buf, "%d", impr_base_build_shield_cost(imp));
937 gtk_label_set_text(GTK_LABEL(help_wlabel[1]), buf);
938
939 /* FIXME: this should show ranges, negated reqs, and all the
940 * MAX_NUM_REQS reqs.
941 * Currently it's limited to 1 req but this code is partially prepared
942 * to be extended. Remember MAX_NUM_REQS is a compile-time
943 * definition. */
944 i = 0;
945 help_wndr_req.u.req = NULL;
946 requirement_vector_iterate(&imp->reqs, preq) {
947 if (!preq->present) {
948 continue;
949 }
950 gtk_label_set_text(GTK_LABEL(help_wlabel[3 + i]),
951 universal_name_translation(&preq->source,
952 req_buf, sizeof(req_buf)));
953 help_wndr_req.u.req = preq;
954 i++;
955 break;
956 } requirement_vector_iterate_end;
957
958 gtk_label_set_text(GTK_LABEL(help_wlabel[5]), REQ_LABEL_NEVER);
959 requirement_vector_iterate(&imp->obsolete_by, pobs) {
960 if (pobs->source.kind == VUT_ADVANCE && pobs->present) {
961 gtk_label_set_text(GTK_LABEL(help_wlabel[5]),
962 advance_name_translation
963 (pobs->source.value.advance));
964
965 break;
966 }
967 } requirement_vector_iterate_end;
968
969/* create_tech_tree(help_improvement_tree, 0, imp->tech_req, 3);*/
970 } else {
971 /* can't find wonder */
972 gtk_label_set_text(GTK_LABEL(help_wlabel[1]), "0");
973 gtk_label_set_text(GTK_LABEL(help_wlabel[3]), REQ_LABEL_NEVER);
974 gtk_label_set_text(GTK_LABEL(help_wlabel[5]), skip_intl_qualifier_prefix(REQ_LABEL_NONE));
975/* create_tech_tree(help_improvement_tree, 0, advance_count(), 3); */
976 }
977
978 set_help_tile_from_sprite(get_building_sprite(tileset, imp));
979
980 gtk_widget_show(help_wtable);
981
982 helptext_building(buf, sizeof(buf), client.conn.playing, pitem->text, imp);
983 gtk_text_buffer_set_text(help_text, buf, -1);
984 gtk_widget_show(help_text_sw);
985}
986
987/**********************************************************************/
990static void help_update_unit_type(const struct help_item *pitem,
991 char *title)
992{
993 char buf[8192];
994 struct unit_type *utype = unit_type_by_translated_name(title);
995
996 if (utype) {
997 sprintf(buf, "%d", utype_build_shield_cost_base(utype));
998 gtk_label_set_text(GTK_LABEL(help_ulabel[0][1]), buf);
999 sprintf(buf, "%d", utype->attack_strength);
1000 gtk_label_set_text(GTK_LABEL(help_ulabel[0][4]), buf);
1001 sprintf(buf, "%d", utype->defense_strength);
1002 gtk_label_set_text(GTK_LABEL(help_ulabel[1][1]), buf);
1003 sprintf(buf, "%s", move_points_text(utype->move_rate, TRUE));
1004 gtk_label_set_text(GTK_LABEL(help_ulabel[1][4]), buf);
1005 sprintf(buf, "%d", utype->firepower);
1006 gtk_label_set_text(GTK_LABEL(help_ulabel[2][1]), buf);
1007 sprintf(buf, "%d", utype->hp);
1008 gtk_label_set_text(GTK_LABEL(help_ulabel[2][4]), buf);
1009 gtk_label_set_text(GTK_LABEL(help_ulabel[3][1]),
1010 helptext_unit_upkeep_str(utype));
1011 sprintf(buf, "%d", (int)sqrt((double)utype->vision_radius_sq));
1012 gtk_label_set_text(GTK_LABEL(help_ulabel[3][4]), buf);
1013 gtk_label_set_text(GTK_LABEL(help_ulabel[4][1]),
1014 advance_name_translation(utype_primary_tech_req(utype)));
1015/* create_tech_tree(help_improvement_tree, 0, advance_number(utype->require_advance), 3);*/
1016 if (U_NOT_OBSOLETED == utype->obsoleted_by) {
1017 gtk_label_set_text(GTK_LABEL(help_ulabel[4][4]), skip_intl_qualifier_prefix(REQ_LABEL_NONE));
1018 } else {
1019 gtk_label_set_text(GTK_LABEL(help_ulabel[4][4]),
1020 utype_name_translation(utype->obsoleted_by));
1021 }
1022
1023 helptext_unit(buf, sizeof(buf), client.conn.playing, pitem->text, utype,
1024 TRUE);
1025
1026 gtk_text_buffer_set_text(help_text, buf, -1);
1027 gtk_widget_show(help_text_sw);
1028
1029 set_help_tile_from_sprite(get_unittype_sprite(tileset, utype,
1030 ACTIVITY_LAST,
1031 direction8_invalid()));
1032 } else {
1033 gtk_label_set_text(GTK_LABEL(help_ulabel[0][1]), "0");
1034 gtk_label_set_text(GTK_LABEL(help_ulabel[0][4]), "0");
1035 gtk_label_set_text(GTK_LABEL(help_ulabel[1][1]), "0");
1036 gtk_label_set_text(GTK_LABEL(help_ulabel[1][4]), "0");
1037 gtk_label_set_text(GTK_LABEL(help_ulabel[2][1]), "0");
1038 gtk_label_set_text(GTK_LABEL(help_ulabel[2][4]), "0");
1039 gtk_label_set_text(GTK_LABEL(help_ulabel[3][1]), "0");
1040 gtk_label_set_text(GTK_LABEL(help_ulabel[3][4]), "0");
1041
1042 gtk_label_set_text(GTK_LABEL(help_ulabel[4][1]), REQ_LABEL_NEVER);
1043/* create_tech_tree(help_improvement_tree, 0, A_LAST, 3);*/
1044 gtk_label_set_text(GTK_LABEL(help_ulabel[4][4]), skip_intl_qualifier_prefix(REQ_LABEL_NONE));
1045
1046 gtk_text_buffer_set_text(help_text, buf, -1);
1047 gtk_widget_show(help_text_sw);
1048 }
1049 gtk_widget_show(help_utable);
1050}
1051
1052/**********************************************************************/
1055static char *fc_chomp(char *str, size_t len)
1056{
1057 gchar *i;
1058
1059 if (!str || !*str) {
1060 return str;
1061 }
1062
1063 i = str + len;
1064 for (i = g_utf8_find_prev_char(str, i);
1065 (i && g_unichar_isspace(g_utf8_get_char(i)));
1066 i = g_utf8_find_prev_char(str, i)) {
1067 *i = '\0';
1068 }
1069 return str;
1070}
1071
1072/**********************************************************************/
1075static void help_update_tech(const struct help_item *pitem, char *title)
1076{
1077 int i, j;
1078 GtkWidget *w, *hbox;
1079 char buf[8192];
1080 struct advance *padvance = advance_by_translated_name(title);
1081
1082 if (padvance && !is_future_tech(i = advance_number(padvance))) {
1083 GtkTextBuffer *txt;
1084 size_t len;
1085
1086 gtk_container_foreach(GTK_CONTAINER(help_vbox), (GtkCallback)gtk_widget_destroy, NULL);
1087
1088 for (j = 0; j < ARRAY_SIZE(help_advances); j++) {
1089 help_advances[j] = FALSE;
1090 }
1091 gtk_tree_store_clear(tstore);
1092 create_tech_tree(i, TECH_TREE_DEPTH, NULL);
1093 gtk_widget_show(help_tree_sw);
1094 gtk_widget_show(help_tree_buttons_hbox);
1095
1096 helptext_advance(buf, sizeof(buf), client.conn.playing, pitem->text, i);
1097 len = strlen(buf);
1098 fc_chomp(buf, len);
1099
1100 set_help_tile_from_sprite(get_tech_sprite(tileset, i));
1101
1102 w = gtk_text_view_new();
1103 gtk_widget_set_hexpand(w, TRUE);
1104 gtk_widget_set_vexpand(w, TRUE);
1105 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(w), FALSE);
1106 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(w), GTK_WRAP_WORD);
1107 gtk_widget_set_name(w, "help_text");
1108 gtk_container_set_border_width(GTK_CONTAINER(w), 5);
1109 gtk_text_view_set_editable(GTK_TEXT_VIEW(w), FALSE);
1110 gtk_container_add(GTK_CONTAINER(help_vbox), w);
1111 gtk_widget_show(w);
1112
1113 txt = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
1114 if (txt) {
1115 gtk_text_buffer_set_text(txt, buf, -1);
1116 }
1117
1118 w = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
1119 g_object_set(w, "margin", 5, NULL);
1120 gtk_widget_set_hexpand(w, TRUE);
1121 gtk_widget_set_vexpand(w, TRUE);
1122 gtk_container_add(GTK_CONTAINER(help_vbox), w);
1123 gtk_widget_show(w);
1124
1125 governments_iterate(pgov) {
1126 /* FIXME: need a more general mechanism for this, since this
1127 * helptext needs to be shown in all possible req source types. */
1128 requirement_vector_iterate(&pgov->reqs, preq) {
1129 if (VUT_ADVANCE == preq->source.kind
1130 && preq->source.value.advance == padvance) {
1131 hbox = gtk_grid_new();
1132 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1133 w = gtk_label_new(_("Allows"));
1134 gtk_container_add(GTK_CONTAINER(hbox), w);
1135 w = help_slink_new_page(government_name_translation(pgov),
1136 HELP_GOVERNMENT);
1137 gtk_container_add(GTK_CONTAINER(hbox), w);
1138 gtk_widget_show_all(hbox);
1139 }
1140 } requirement_vector_iterate_end;
1141 } governments_iterate_end;
1142
1143 improvement_iterate(pimprove) {
1144 if (valid_improvement(pimprove)) {
1145 requirement_vector_iterate(&pimprove->reqs, preq) {
1146 if (VUT_ADVANCE == preq->source.kind
1147 && preq->source.value.advance == padvance) {
1148 hbox = gtk_grid_new();
1149 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1150 w = gtk_label_new(_("Allows"));
1151 gtk_container_add(GTK_CONTAINER(hbox), w);
1152 w = help_slink_new_page(improvement_name_translation(pimprove),
1153 is_great_wonder(pimprove)
1154 ? HELP_WONDER
1155 : HELP_IMPROVEMENT);
1156 gtk_container_add(GTK_CONTAINER(hbox), w);
1157 gtk_widget_show_all(hbox);
1158 }
1159 } requirement_vector_iterate_end;
1160 requirement_vector_iterate(&pimprove->obsolete_by, pobs) {
1161 if (pobs->source.kind == VUT_ADVANCE
1162 && pobs->source.value.advance == padvance
1163 && pobs->present) {
1164 hbox = gtk_grid_new();
1165 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1166 w = gtk_label_new(_("Obsoletes"));
1167 gtk_container_add(GTK_CONTAINER(hbox), w);
1168 w = help_slink_new_page(improvement_name_translation(pimprove),
1169 is_great_wonder(pimprove)
1170 ? HELP_WONDER
1171 : HELP_IMPROVEMENT);
1172 gtk_container_add(GTK_CONTAINER(hbox), w);
1173 gtk_widget_show_all(hbox);
1174 }
1175 } requirement_vector_iterate_end;
1176 }
1177 } improvement_iterate_end;
1178
1179 unit_type_iterate(punittype) {
1180
1181 if (!is_tech_req_for_utype(punittype, padvance)) {
1182 continue;
1183 }
1184
1185 hbox = gtk_grid_new();
1186 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1187 w = gtk_label_new(_("Allows"));
1188 gtk_container_add(GTK_CONTAINER(hbox), w);
1189 w = help_slink_new_page(utype_name_translation(punittype), HELP_UNIT);
1190 gtk_container_add(GTK_CONTAINER(hbox), w);
1191 gtk_widget_show_all(hbox);
1192 } unit_type_iterate_end;
1193
1194 advance_iterate_all(ptest) {
1195 if (padvance == advance_requires(ptest, AR_ONE)) {
1196 if (advance_by_number(A_NONE) == advance_requires(ptest, AR_TWO)) {
1197 hbox = gtk_grid_new();
1198 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1199 w = gtk_label_new(_("Allows"));
1200 gtk_container_add(GTK_CONTAINER(hbox), w);
1201 w = help_slink_new_page(advance_name_translation(ptest), HELP_TECH);
1202 gtk_container_add(GTK_CONTAINER(hbox), w);
1203 gtk_widget_show_all(hbox);
1204 } else {
1205 hbox = gtk_grid_new();
1206 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1207 w = gtk_label_new(_("Allows"));
1208 gtk_container_add(GTK_CONTAINER(hbox), w);
1209 w = help_slink_new_page(advance_name_translation(ptest), HELP_TECH);
1210 gtk_container_add(GTK_CONTAINER(hbox), w);
1211 w = gtk_label_new(_("with"));
1212 gtk_container_add(GTK_CONTAINER(hbox), w);
1213 w = help_slink_new_page(advance_name_translation(advance_requires(ptest,
1214 AR_TWO)),
1215 HELP_TECH);
1216 gtk_container_add(GTK_CONTAINER(hbox), w);
1217 w = gtk_label_new(Q_("?techhelp:"));
1218 gtk_container_add(GTK_CONTAINER(hbox), w);
1219 gtk_widget_show_all(hbox);
1220 }
1221 }
1222 if (padvance == advance_requires(ptest, AR_TWO)) {
1223 hbox = gtk_grid_new();
1224 gtk_container_add(GTK_CONTAINER(help_vbox), hbox);
1225 w = gtk_label_new(_("Allows"));
1226 gtk_container_add(GTK_CONTAINER(hbox), w);
1227 w = help_slink_new_page(advance_name_translation(ptest), HELP_TECH);
1228 gtk_container_add(GTK_CONTAINER(hbox), w);
1229 w = gtk_label_new(_("with"));
1230 gtk_container_add(GTK_CONTAINER(hbox), w);
1231 w = help_slink_new_page(advance_name_translation(advance_requires(ptest, AR_ONE)),
1232 HELP_TECH);
1233 gtk_container_add(GTK_CONTAINER(hbox), w);
1234 w = gtk_label_new(Q_("?techhelp:"));
1235 gtk_container_add(GTK_CONTAINER(hbox), w);
1236 gtk_widget_show_all(hbox);
1237 }
1238 } advance_iterate_all_end;
1239 gtk_widget_show(help_vbox);
1240 }
1241}
1242
1243/**********************************************************************/
1265
1266/**********************************************************************/
1269static void help_extras_of_act_for_terrain(struct terrain *pterr,
1270 enum unit_activity act,
1271 char *label)
1272{
1273 enum extra_cause cause = activity_to_extra_cause(act);
1274
1275 extra_type_by_cause_iterate(cause, pextra) {
1276 if (pextra->buildable
1277 && requirement_fulfilled_by_terrain(pterr, &(pextra->reqs))) {
1278 add_act_help_for_terrain(label,
1279 extra_name_translation(pextra), HELP_EXTRA,
1280 helptext_extra_for_terrain_str(pextra, pterr,
1281 act));
1282 }
1283 } extra_type_by_cause_iterate_end;
1284}
1285
1286/**********************************************************************/
1289static void help_update_terrain(const struct help_item *pitem,
1290 char *title)
1291{
1292 char buf[8192];
1293 struct terrain *pterrain = terrain_by_translated_name(title);
1294
1295 if (pterrain) {
1296 struct universal for_terr = { .kind = VUT_TERRAIN, .value = { .terrain = pterrain }};
1297
1298 set_help_tile_from_terrain(pterrain);
1299
1300 {
1301 /* 25 => "1.25"; 50 => "1.5"; 100 => "2.0" */
1302 int defbonus = pterrain->defense_bonus + 100;
1303 int frac = defbonus % 100;
1304
1305 if ((frac % 10) == 0) {
1306 frac /= 10;
1307 }
1308 sprintf(buf, "%d/%d.%d",
1309 pterrain->movement_cost, defbonus / 100, frac);
1310 }
1311 gtk_label_set_text(GTK_LABEL(help_tlabel[0][1]), buf);
1312
1313 sprintf(buf, "%d/%d/%d",
1314 pterrain->output[O_FOOD],
1315 pterrain->output[O_SHIELD],
1316 pterrain->output[O_TRADE]);
1317 gtk_label_set_text(GTK_LABEL(help_tlabel[0][4]), buf);
1318
1319 buf[0] = '\0';
1320 if (*(pterrain->resources)) {
1321 struct extra_type **r;
1322
1323 /* TODO: include resource frequency information */
1324 for (r = pterrain->resources; *r; r++) {
1325 /* TRANS: " Whales (2/1/2)," */
1326 sprintf (buf + strlen (buf), " %s (%d/%d/%d),",
1327 extra_name_translation(*r),
1328 pterrain->output[O_FOOD] + (*r)->data.resource->output[O_FOOD],
1329 pterrain->output[O_SHIELD] + (*r)->data.resource->output[O_SHIELD],
1330 pterrain->output[O_TRADE] + (*r)->data.resource->output[O_TRADE]);
1331 }
1332 buf[strlen (buf) - 1] = '.';
1333 } else {
1334 /* TRANS: "Resources: (none)" */
1335 sprintf (buf + strlen (buf), _("(none)"));
1336 }
1337 gtk_label_set_text(GTK_LABEL(help_tlabel[1][1]), buf);
1338
1339 gtk_container_foreach(GTK_CONTAINER(help_vbox), (GtkCallback)gtk_widget_destroy, NULL);
1340
1341 if (pterrain->cultivate_result != T_NONE
1342 && action_id_univs_not_blocking(ACTION_CULTIVATE,
1343 NULL, &for_terr)) {
1344 fc_snprintf(buf, sizeof(buf),
1345 PL_("%d turn", "%d turns", pterrain->cultivate_time),
1346 pterrain->cultivate_time);
1347 add_act_help_for_terrain(_("Cultivate Rslt/Time"),
1348 terrain_name_translation(pterrain->cultivate_result),
1349 HELP_TERRAIN, buf);
1350 }
1351
1352 if (pterrain->plant_result != T_NONE
1353 && action_id_univs_not_blocking(ACTION_PLANT, NULL, &for_terr)) {
1354 fc_snprintf(buf, sizeof(buf),
1355 PL_("%d turn", "%d turns", pterrain->plant_time),
1356 pterrain->plant_time);
1357 add_act_help_for_terrain(_("Plant Rslt/Time"),
1358 terrain_name_translation(pterrain->plant_result),
1359 HELP_TERRAIN, buf);
1360 }
1361
1362 if (pterrain->transform_result != T_NONE
1363 && action_id_univs_not_blocking(ACTION_TRANSFORM_TERRAIN,
1364 NULL, &for_terr)) {
1365 fc_snprintf(buf, sizeof(buf),
1366 PL_("%d turn", "%d turns", pterrain->transform_time),
1367 pterrain->transform_time);
1368 add_act_help_for_terrain(_("Trans. Rslt/Time"),
1369 terrain_name_translation(pterrain->transform_result),
1370 HELP_TERRAIN, buf);
1371 }
1372
1373 if (action_id_univs_not_blocking(ACTION_IRRIGATE, NULL, &for_terr)) {
1374 help_extras_of_act_for_terrain(pterrain, ACTIVITY_IRRIGATE,
1375 _("Build as irrigation"));
1376 }
1377 if (action_id_univs_not_blocking(ACTION_MINE, NULL, &for_terr)) {
1378 help_extras_of_act_for_terrain(pterrain, ACTIVITY_MINE,
1379 _("Build as mine"));
1380 }
1381 if (action_id_univs_not_blocking(ACTION_ROAD, NULL, &for_terr)) {
1382 help_extras_of_act_for_terrain(pterrain, ACTIVITY_GEN_ROAD,
1383 _("Build as road"));
1384 }
1385 if (action_id_univs_not_blocking(ACTION_BASE, NULL, &for_terr)) {
1386 help_extras_of_act_for_terrain(pterrain, ACTIVITY_BASE,
1387 _("Build as base"));
1388 }
1389
1390 gtk_widget_show(help_vbox);
1391 }
1392
1393 helptext_terrain(buf, sizeof(buf), client.conn.playing, pitem->text, pterrain);
1394
1395 gtk_text_buffer_set_text(help_text, buf, -1);
1396 gtk_widget_show(help_text_sw);
1397
1398 gtk_widget_show(help_ttable);
1399}
1400
1401/**********************************************************************/
1404static void help_update_extra(const struct help_item *pitem, char *title)
1405{
1406 char buf[8192];
1407 struct extra_type *pextra = extra_type_by_translated_name(title);
1408
1409 buf[0] = '\0';
1410 if (pextra == NULL) {
1411 strcat(buf, pitem->text);
1412 } else {
1413 struct road_type *proad = extra_road_get(pextra);
1414 bool is_resource = is_extra_caused_by(pextra, EC_RESOURCE);
1415
1416 set_help_tile_from_extra(pextra);
1417
1418 /* Cost to build */
1419 if (pextra->buildable) {
1420 if (pextra->build_time != 0) {
1421 /* TRANS: "MP" = movement points */
1422 sprintf(buf, _("%d MP"), pextra->build_time);
1423 } else {
1424 /* TRANS: Build time depends on terrain. */
1425 sprintf(buf, _("Terrain specific"));
1426 }
1427 } else {
1428 sprintf(buf, "-");
1429 }
1430 gtk_label_set_text(GTK_LABEL(help_elabel[1]), buf);
1431 /* Conflicting extras */
1432 buf[0] = '\0';
1433 if (is_resource) {
1434 /* TRANS: (Resource extra) Conflicts with: */
1435 strcat(buf, _("Other Resources"));
1436 }
1437 extra_type_iterate(pextra2) {
1438 if (!can_extras_coexist(pextra, pextra2)
1439 && (!is_resource || !is_extra_caused_by(pextra2, EC_RESOURCE))) {
1440 if (buf[0] != '\0') {
1441 strcat(buf, "/");
1442 }
1443 strcat(buf, extra_name_translation(pextra2));
1444 }
1445 } extra_type_iterate_end;
1446 /* TRANS: "Conflicts with: (none)" (extras) */
1447 gtk_label_set_text(GTK_LABEL(help_elabel[3]), buf[0] ? buf : _("(none)"));
1448
1449 /* Bonus */
1450 if (proad != NULL) {
1451 const char *bonus = NULL;
1452
1453 output_type_iterate(o) {
1454 if (proad->tile_incr[o] > 0) {
1455 /* TRANS: Road bonus depends on terrain. */
1456 bonus = _("Terrain specific");
1457 break;
1458 }
1459 } output_type_iterate_end;
1460 if (!bonus) {
1461 bonus = helptext_road_bonus_str(NULL, proad);
1462 }
1463 if (!bonus) {
1464 /* TRANS: No output bonus from a road */
1465 bonus = Q_("?bonus:None");
1466 }
1467 gtk_label_set_text(GTK_LABEL(help_elabel[5]), bonus);
1468 } else {
1469 gtk_label_set_text(GTK_LABEL(help_elabel[5]), Q_("?bonus:None"));
1470 }
1471
1472 helptext_extra(buf, sizeof(buf), client.conn.playing, pitem->text, pextra);
1473 }
1474 gtk_widget_show(help_etable);
1475
1476 gtk_text_buffer_set_text(help_text, buf, -1);
1477 gtk_widget_show(help_text_sw);
1478}
1479
1480/**********************************************************************/
1483static void help_update_goods(const struct help_item *pitem,
1484 char *title)
1485{
1486 char buf[8192];
1487 struct goods_type *pgood = goods_by_translated_name(title);
1488
1489 if (!pgood) {
1490 strcat(buf, pitem->text);
1491 } else {
1492 helptext_goods(buf, sizeof(buf), client.conn.playing, pitem->text,
1493 pgood);
1494 }
1495
1496 gtk_text_buffer_set_text(help_text, buf, -1);
1497 gtk_widget_show(help_text_sw);
1498}
1499
1500/**********************************************************************/
1503static void help_update_specialist(const struct help_item *pitem,
1504 char *title)
1505{
1506 char buf[8192];
1507 struct specialist *pspec = specialist_by_translated_name(title);
1508
1509 if (!pspec) {
1510 strcat(buf, pitem->text);
1511 } else {
1512 helptext_specialist(buf, sizeof(buf), client.conn.playing, pitem->text,
1513 pspec);
1514 }
1515
1516 gtk_text_buffer_set_text(help_text, buf, -1);
1517 gtk_widget_show(help_text_sw);
1518}
1519
1520/**********************************************************************/
1523static void help_update_government(const struct help_item *pitem,
1524 char *title)
1525{
1526 char buf[8192];
1527 struct government *gov = government_by_translated_name(title);
1528
1529 if (!gov) {
1530 strcat(buf, pitem->text);
1531 } else {
1532 helptext_government(buf, sizeof(buf), client.conn.playing, pitem->text, gov);
1533 }
1534
1535 gtk_text_buffer_set_text(help_text, buf, -1);
1536 gtk_widget_show(help_text_sw);
1537}
1538
1539/**********************************************************************/
1542static void help_update_nation(const struct help_item *pitem, char *title,
1543 struct nation_type *pnation)
1544{
1545 char buf[4096];
1546
1547 if (!pnation) {
1548 strcat(buf, pitem->text);
1549 } else {
1550 helptext_nation(buf, sizeof(buf), pnation, pitem->text);
1551
1552 set_help_tile_from_sprite(get_nation_flag_sprite(tileset, pnation));
1553 }
1554
1555 gtk_text_buffer_set_text(help_text, buf, -1);
1556 gtk_widget_show(help_text_sw);
1557}
1558
1559/**********************************************************************/
1562static void help_update_dialog(const struct help_item *pitem)
1563{
1564 char *top;
1565
1566 /* figure out what kind of item is required for pitem ingo */
1567
1568 for (top = pitem->topic; *top == ' '; top++) {
1569 /* nothing */
1570 }
1571
1572 help_box_hide();
1573 gtk_text_buffer_set_text(help_text, "", -1);
1574
1575 switch (pitem->type) {
1576 case HELP_IMPROVEMENT:
1577 help_update_improvement(pitem, top);
1578 break;
1579 case HELP_WONDER:
1580 help_update_wonder(pitem, top);
1581 break;
1582 case HELP_UNIT:
1583 help_update_unit_type(pitem, top);
1584 break;
1585 case HELP_TECH:
1586 help_update_tech(pitem, top);
1587 break;
1588 case HELP_TERRAIN:
1589 help_update_terrain(pitem, top);
1590 break;
1591 case HELP_EXTRA:
1592 help_update_extra(pitem, top);
1593 break;
1594 case HELP_GOODS:
1595 help_update_goods(pitem, top);
1596 break;
1597 case HELP_SPECIALIST:
1598 help_update_specialist(pitem, top);
1599 break;
1600 case HELP_GOVERNMENT:
1601 help_update_government(pitem, top);
1602 break;
1603 case HELP_NATIONS:
1604 help_update_nation(pitem, top, nation_by_translated_plural(top));
1605 break;
1606 case HELP_TEXT:
1607 default:
1608 /* it was a pure text item */
1609 gtk_text_buffer_set_text(help_text, pitem->text, -1);
1610 gtk_widget_show(help_text_sw);
1611 break;
1612 }
1613 set_title_topic(pitem->topic);
1614
1615 gtk_widget_show(help_box);
1616}
1617
1618/**********************************************************************/
1621static void help_item_zoom(GtkTreePath *path)
1622{
1623 GtkTreeModel *model;
1624 GtkTreeIter it, child, item;
1625 GtkTreeSelection *selection;
1626
1627 model = gtk_tree_view_get_model(GTK_TREE_VIEW(help_view));
1628 gtk_tree_model_get_iter(model, &item, path);
1629
1630 for (child = item; gtk_tree_model_iter_parent(model, &it, &child); child=it) {
1631 GtkTreePath *it_path;
1632
1633 it_path = gtk_tree_model_get_path(model, &it);
1634 gtk_tree_view_expand_row(GTK_TREE_VIEW(help_view), it_path, TRUE);
1635 gtk_tree_path_free(it_path);
1636 }
1637
1638 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(help_view));
1639 gtk_tree_selection_select_iter(selection, &item);
1640 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(help_view), path, NULL,
1641 TRUE, 0.0, 0.0);
1642}
1643
1644/**********************************************************************/
1647static GtkTreePath *help_item_path(const struct help_item *pitem)
1648{
1649 GtkTreePath *path;
1650 bool next;
1651
1652 path = gtk_tree_path_new_first();
1653 next = FALSE;
1654 help_items_iterate(pitem2) {
1655 const char *s;
1656 int depth;
1657
1658 for (s = pitem2->topic; *s == ' '; s++) {
1659 /* nothing */
1660 }
1661 depth = s - pitem2->topic + 1;
1662
1663 while (depth < gtk_tree_path_get_depth(path)) {
1664 gtk_tree_path_up(path);
1665 gtk_tree_path_next(path);
1666 next = FALSE;
1667 }
1668 while (depth > gtk_tree_path_get_depth(path)) {
1669 gtk_tree_path_down(path);
1670 next = FALSE;
1671 }
1672
1673 if (next) {
1674 gtk_tree_path_next(path);
1675 }
1676
1677 if (pitem == pitem2)
1678 break;
1679
1680 next = TRUE;
1681 } help_items_iterate_end;
1682
1683 return path;
1684}
1685
1686/**********************************************************************/
1689static void select_help_item_string(const char *item, enum help_page_type htype)
1690{
1691 const struct help_item *pitem;
1692 int idx;
1693 GtkTreePath *path;
1694 GtkTreeViewColumn *col;
1695
1696 if (!(pitem = get_help_item_spec(item, htype, &idx))) {
1697 return;
1698 }
1699
1700 path = help_item_path(pitem);
1701 help_item_zoom(path);
1702
1703 col = gtk_tree_view_get_column(GTK_TREE_VIEW(help_view), 0);
1704 gtk_tree_view_set_cursor(GTK_TREE_VIEW(help_view), path, col, FALSE);
1705 gtk_tree_path_free(path);
1706}
1707
1708/**********************************************************************/
1711static void help_command_update(void)
1712{
1713 GtkDialog *dialog = GTK_DIALOG(help_dialog_shell);
1714
1715 if (help_history_pos < 0) {
1716 gtk_dialog_set_response_sensitive(dialog, 1, FALSE);
1717 gtk_dialog_set_response_sensitive(dialog, 2, FALSE);
1718 } else {
1719 gtk_dialog_set_response_sensitive(dialog, 1, TRUE);
1720 gtk_dialog_set_response_sensitive(dialog, 2, TRUE);
1721
1722 if (help_history_pos == 0) {
1723 gtk_dialog_set_response_sensitive(dialog, 1, FALSE);
1724 }
1725 if (help_history_pos >= help_history->len - 1) {
1726 gtk_dialog_set_response_sensitive(dialog, 2, FALSE);
1727 }
1728 }
1729}
1730
1731/**********************************************************************/
1734static void help_command_callback(GtkWidget *w, gint response_id)
1735{
1736 GtkTreePath *path;
1737 const struct help_item *pitem;
1738
1739 if (response_id == 1) {
1740 if (help_history_pos > 0) {
1741 help_history_pos--;
1742
1743 pitem = g_ptr_array_index(help_history, help_history_pos);
1744 path = help_item_path(pitem);
1745 help_item_zoom(path);
1746 help_update_dialog(pitem);
1747 help_command_update();
1748 }
1749 } else if (response_id == 2) {
1750 if (help_history_pos < help_history->len - 1) {
1751 help_history_pos++;
1752
1753 pitem = g_ptr_array_index(help_history, help_history_pos);
1754 path = help_item_path(pitem);
1755 help_item_zoom(path);
1756 help_update_dialog(pitem);
1757 help_command_update();
1758 }
1759 } else {
1760 gtk_widget_destroy(help_dialog_shell);
1761 }
1762}
action_id_univs_not_blocking
#define action_id_univs_not_blocking(act_id, act_uni, tgt_uni)
Definition actions.h:945
str
#define str
Definition astring.c:76
output_type_iterate
#define output_type_iterate(output)
Definition city.h:845
output_type_iterate_end
#define output_type_iterate_end
Definition city.h:851
client
struct civclient client
Definition client_main.c:150
client_main.h
client_player
#define client_player()
Definition client_main.h:106
get_color
struct color * get_color(const struct tileset *t, enum color_std stdcolor)
Definition colors_common.c:100
incite_cost
char * incite_cost
Definition comments.c:75
extra_type_by_translated_name
struct extra_type * extra_type_by_translated_name(const char *name)
Definition extras.c:235
activity_to_extra_cause
enum extra_cause activity_to_extra_cause(enum unit_activity act)
Definition extras.c:1076
can_extras_coexist
bool can_extras_coexist(const struct extra_type *pextra1, const struct extra_type *pextra2)
Definition extras.c:1003
extra_name_translation
const char * extra_name_translation(const struct extra_type *pextra)
Definition extras.c:194
extra_type_iterate
#define extra_type_iterate(_p)
Definition extras.h:315
extra_type_iterate_end
#define extra_type_iterate_end
Definition extras.h:321
is_extra_caused_by
#define is_extra_caused_by(e, c)
Definition extras.h:203
extra_road_get
#define extra_road_get(_e_)
Definition extras.h:191
extra_type_by_cause_iterate_end
#define extra_type_by_cause_iterate_end
Definition extras.h:339
extra_type_by_cause_iterate
#define extra_type_by_cause_iterate(_cause, _extra)
Definition extras.h:333
O_SHIELD
@ O_SHIELD
Definition fc_types.h:101
O_FOOD
@ O_FOOD
Definition fc_types.h:101
O_TRADE
@ O_TRADE
Definition fc_types.h:101
skip_intl_qualifier_prefix
const char * skip_intl_qualifier_prefix(const char *str)
Definition fcintl.c:48
Q_
#define Q_(String)
Definition fcintl.h:70
PL_
#define PL_(String1, String2, n)
Definition fcintl.h:71
_
#define _(String)
Definition fcintl.h:67
N_
#define N_(String)
Definition fcintl.h:69
government_name_translation
const char * government_name_translation(const struct government *pgovern)
Definition government.c:143
government_by_translated_name
struct government * government_by_translated_name(const char *name)
Definition government.c:40
governments_iterate
#define governments_iterate(NAME_pgov)
Definition government.h:124
governments_iterate_end
#define governments_iterate_end
Definition government.h:127
FC_STATIC_CANVAS_INIT
#define FC_STATIC_CANVAS_INIT
Definition canvas.h:28
toplevel
GtkWidget * toplevel
Definition gui_main.c:125
set_relative_window_position
void set_relative_window_position(GtkWindow *ref, GtkWindow *w, int px, int py)
Definition gui_stuff.c:60
setup_dialog
void setup_dialog(GtkWidget *shell, GtkWidget *parent)
Definition gui_stuff.c:287
help_tree_sw
static GtkWidget * help_tree_sw
Definition helpdlg.c:83
set_title_topic
static void set_title_topic(char *topic)
Definition helpdlg.c:173
activated_topic
static void activated_topic(GtkTreeView *view, gpointer data)
Definition helpdlg.c:469
help_tree
static GtkWidget * help_tree
Definition helpdlg.c:80
help_tree_expand
static GtkWidget * help_tree_expand
Definition helpdlg.c:84
help_ulabel
static GtkWidget * help_ulabel[5][5]
Definition helpdlg.c:89
help_update_specialist
static void help_update_specialist(const struct help_item *pitem, char *title)
Definition helpdlg.c:1503
help_hyperlink_callback
static void help_hyperlink_callback(GtkWidget *w)
Definition helpdlg.c:345
help_elabel
static GtkWidget * help_elabel[6]
Definition helpdlg.c:91
help_etable
static GtkWidget * help_etable
Definition helpdlg.c:79
help_destroy_callback
static void help_destroy_callback(GtkWidget *w, gpointer data)
Definition helpdlg.c:460
set_help_tile_from_extra
static void set_help_tile_from_extra(const struct extra_type *pextra)
Definition helpdlg.c:848
help_frame
static GtkWidget * help_frame
Definition helpdlg.c:69
help_tech_tree_activated_callback
static void help_tech_tree_activated_callback(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
Definition helpdlg.c:312
help_update_tech
static void help_update_tech(const struct help_item *pitem, char *title)
Definition helpdlg.c:1075
help_item_zoom
static void help_item_zoom(GtkTreePath *path)
Definition helpdlg.c:1621
help_slink_new_page
static GtkWidget * help_slink_new_page(const gchar *txt, enum help_page_type page)
Definition helpdlg.c:427
help_tlabel
static GtkWidget * help_tlabel[2][5]
Definition helpdlg.c:90
help_item_path
static GtkTreePath * help_item_path(const struct help_item *pitem)
Definition helpdlg.c:1647
help_tree_collapse
static GtkWidget * help_tree_collapse
Definition helpdlg.c:85
help_update_nation
static void help_update_nation(const struct help_item *pitem, char *title, struct nation_type *pnation)
Definition helpdlg.c:1542
create_help_dialog
static void create_help_dialog(void)
Definition helpdlg.c:509
help_text
static GtkTextBuffer * help_text
Definition helpdlg.c:70
help_update_wonder
static void help_update_wonder(const struct help_item *pitem, char *title)
Definition helpdlg.c:926
help_hyperlink_new_page
static GtkWidget * help_hyperlink_new_page(GtkWidget *label, enum help_page_type page)
Definition helpdlg.c:402
help_dialog_shell
static GtkWidget * help_dialog_shell
Definition helpdlg.c:64
help_text_sw
static GtkWidget * help_text_sw
Definition helpdlg.c:71
help_history
static GPtrArray * help_history
Definition helpdlg.c:95
help_elabel_name
static const char * help_elabel_name[6]
Definition helpdlg.c:132
create_tech_tree
static void create_tech_tree(int tech, int levels, GtkTreeIter *parent)
Definition helpdlg.c:226
help_update_extra
static void help_update_extra(const struct help_item *pitem, char *title)
Definition helpdlg.c:1404
help_ilabel
static GtkWidget * help_ilabel[6]
Definition helpdlg.c:87
set_help_tile_from_sprite
static void set_help_tile_from_sprite(struct sprite *spr)
Definition helpdlg.c:804
help_wlabel_name
static const char * help_wlabel_name[6]
Definition helpdlg.c:111
help_ulabel_name
static const char * help_ulabel_name[5][5]
Definition helpdlg.c:117
help_tech_tree_collapse_callback
static void help_tech_tree_collapse_callback(GtkWidget *w, gpointer data)
Definition helpdlg.c:337
set_help_tile_from_terrain
static void set_help_tile_from_terrain(struct terrain *pterr)
Definition helpdlg.c:817
help_view
static GtkWidget * help_view
Definition helpdlg.c:67
help_update_goods
static void help_update_goods(const struct help_item *pitem, char *title)
Definition helpdlg.c:1483
help_system_init
void help_system_init(void)
Definition helpdlg.c:157
help_box_hide
static void help_box_hide(void)
Definition helpdlg.c:436
help_update_unit_type
static void help_update_unit_type(const struct help_item *pitem, char *title)
Definition helpdlg.c:990
popdown_help_dialog
void popdown_help_dialog(void)
Definition helpdlg.c:186
help_update_terrain
static void help_update_terrain(const struct help_item *pitem, char *title)
Definition helpdlg.c:1289
help_update_dialog
static void help_update_dialog(const struct help_item *pitem)
Definition helpdlg.c:1562
fc_chomp
static char * fc_chomp(char *str, size_t len)
Definition helpdlg.c:1055
popup_help_dialog_string
void popup_help_dialog_string(const char *item)
Definition helpdlg.c:212
help_history_pos
static int help_history_pos
Definition helpdlg.c:96
help_wndr_req
static struct help_page_selection help_wndr_req
Definition helpdlg.c:113
help_wlabel
static GtkWidget * help_wlabel[6]
Definition helpdlg.c:88
help_box
static GtkWidget * help_box
Definition helpdlg.c:74
help_extras_of_act_for_terrain
static void help_extras_of_act_for_terrain(struct terrain *pterr, enum unit_activity act, char *label)
Definition helpdlg.c:1269
popup_help_dialog_typed
void popup_help_dialog_typed(const char *item, enum help_page_type htype)
Definition helpdlg.c:196
REQ_LABEL_NEVER
#define REQ_LABEL_NEVER
Definition helpdlg.c:144
help_command_update
static void help_command_update(void)
Definition helpdlg.c:1711
page_selections
static struct help_page_selection page_selections[HELP_LAST]
Definition helpdlg.c:115
TECH_TREE_DEPTH
#define TECH_TREE_DEPTH
Definition helpdlg.c:59
help_tlabel_name
static const char * help_tlabel_name[2][5]
Definition helpdlg.c:126
help_impr_req
static struct help_page_selection help_impr_req
Definition helpdlg.c:109
REQ_LABEL_NONE
#define REQ_LABEL_NONE
Definition helpdlg.c:143
help_wtable
static GtkWidget * help_wtable
Definition helpdlg.c:76
help_slink_new
static GtkWidget * help_slink_new(const gchar *txt, struct help_page_selection *select)
Definition helpdlg.c:411
help_vbox
static GtkWidget * help_vbox
Definition helpdlg.c:72
help_tech_tree_expand_callback
static void help_tech_tree_expand_callback(GtkWidget *w, gpointer data)
Definition helpdlg.c:329
help_tile
static GtkWidget * help_tile
Definition helpdlg.c:73
help_hyperlink_new
static GtkWidget * help_hyperlink_new(GtkWidget *label, struct help_page_selection *select)
Definition helpdlg.c:380
help_update_government
static void help_update_government(const struct help_item *pitem, char *title)
Definition helpdlg.c:1523
help_ttable
static GtkWidget * help_ttable
Definition helpdlg.c:78
help_update_improvement
static void help_update_improvement(const struct help_item *pitem, char *title)
Definition helpdlg.c:876
help_ilabel_name
static const char * help_ilabel_name[6]
Definition helpdlg.c:107
help_tree_buttons_hbox
static GtkWidget * help_tree_buttons_hbox
Definition helpdlg.c:86
help_view_sw
static GtkWidget * help_view_sw
Definition helpdlg.c:65
select_help_item_string
static void select_help_item_string(const char *item, enum help_page_type htype)
Definition helpdlg.c:1689
help_advances
static bool help_advances[A_LAST]
Definition helpdlg.c:93
help_utable
static GtkWidget * help_utable
Definition helpdlg.c:77
help_itable
static GtkWidget * help_itable
Definition helpdlg.c:75
tstore
static GtkTreeStore * tstore
Definition helpdlg.c:81
add_act_help_for_terrain
static void add_act_help_for_terrain(const char *act_label, const char *result_link_label, enum help_page_type result_link_type, const char *descr_label)
Definition helpdlg.c:1246
help_command_callback
static void help_command_callback(GtkWidget *w, gint response_id)
Definition helpdlg.c:1734
title
const char * title
Definition repodlgs.c:1314
type
GType type
Definition repodlgs.c:1313
gui_stuff.h
gui_main.h
helptext_government
void helptext_government(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct government *gov)
Definition helpdata.c:4340
helptext_advance
void helptext_advance(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, int i)
Definition helpdata.c:3299
help_type_by_requirement
enum help_page_type help_type_by_requirement(const struct requirement *req)
Definition helpdata.c:5205
helptext_unit
char * helptext_unit(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, const struct unit_type *utype, bool class_help)
Definition helpdata.c:1932
helptext_extra
void helptext_extra(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct extra_type *pextra)
Definition helpdata.c:3794
helptext_goods
void helptext_goods(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct goods_type *pgood)
Definition helpdata.c:4259
helptext_road_bonus_str
const char * helptext_road_bonus_str(const struct terrain *pterrain, const struct road_type *proad)
Definition helpdata.c:3630
helptext_unit_upkeep_str
char * helptext_unit_upkeep_str(const struct unit_type *utype)
Definition helpdata.c:5002
helptext_extra_for_terrain_str
const char * helptext_extra_for_terrain_str(struct extra_type *pextra, struct terrain *pterrain, enum unit_activity act)
Definition helpdata.c:3760
helptext_specialist
void helptext_specialist(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct specialist *pspec)
Definition helpdata.c:4305
get_help_item_spec
const struct help_item * get_help_item_spec(const char *name, enum help_page_type htype, int *pos)
Definition helpdata.c:1288
helptext_building
char * helptext_building(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, const struct impr_type *pimprove)
Definition helpdata.c:1381
helptext_terrain
void helptext_terrain(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct terrain *pterrain)
Definition helpdata.c:3520
helptext_nation
void helptext_nation(char *buf, size_t bufsz, struct nation_type *pnation, const char *user_text)
Definition helpdata.c:5039
help_items_iterate
#define help_items_iterate(pitem)
Definition helpdata.h:72
help_items_iterate_end
#define help_items_iterate_end
Definition helpdata.h:76
HELP_ABOUT_ITEM
#define HELP_ABOUT_ITEM
help_page_type
help_page_type
Definition helpdlg_g.h:20
HELP_ANY
@ HELP_ANY
Definition helpdlg_g.h:20
HELP_TERRAIN
@ HELP_TERRAIN
Definition helpdlg_g.h:21
HELP_EXTRA
@ HELP_EXTRA
Definition helpdlg_g.h:21
HELP_NATIONS
@ HELP_NATIONS
Definition helpdlg_g.h:24
HELP_LAST
@ HELP_LAST
Definition helpdlg_g.h:25
HELP_IMPROVEMENT
@ HELP_IMPROVEMENT
Definition helpdlg_g.h:20
HELP_UNIT
@ HELP_UNIT
Definition helpdlg_g.h:20
HELP_SPECIALIST
@ HELP_SPECIALIST
Definition helpdlg_g.h:22
HELP_GOVERNMENT
@ HELP_GOVERNMENT
Definition helpdlg_g.h:22
HELP_GOODS
@ HELP_GOODS
Definition helpdlg_g.h:22
HELP_WONDER
@ HELP_WONDER
Definition helpdlg_g.h:21
HELP_TECH
@ HELP_TECH
Definition helpdlg_g.h:21
HELP_TEXT
@ HELP_TEXT
Definition helpdlg_g.h:20
valid_improvement
const struct impr_type * valid_improvement(const struct impr_type *pimprove)
Definition improvement.c:211
impr_base_build_shield_cost
int impr_base_build_shield_cost(const struct impr_type *pimprove)
Definition improvement.c:261
is_great_wonder
bool is_great_wonder(const struct impr_type *pimprove)
Definition improvement.c:776
improvement_by_translated_name
struct impr_type * improvement_by_translated_name(const char *name)
Definition improvement.c:352
improvement_name_translation
const char * improvement_name_translation(const struct impr_type *pimprove)
Definition improvement.c:243
improvement_iterate_end
#define improvement_iterate_end
Definition improvement.h:205
improvement_iterate
#define improvement_iterate(_p)
Definition improvement.h:199
put_drawn_sprites
void put_drawn_sprites(struct canvas *pcanvas, float zoom, int canvas_x, int canvas_y, int count, struct drawn_sprite *pdrawn, bool fog)
Definition mapview_common.c:1328
move_points_text
const char * move_points_text(int mp, bool reduce)
Definition movement.c:1015
nation_by_translated_plural
struct nation_type * nation_by_translated_plural(const char *name)
Definition nation.c:106
len
int len
Definition packhand.c:127
universal_name_translation
const char * universal_name_translation(const struct universal *psource, char *buf, size_t bufsz)
Definition requirements.c:6776
requirement_fulfilled_by_terrain
#define requirement_fulfilled_by_terrain(_ter_, _rqs_)
Definition requirements.h:419
requirement_vector_iterate_end
#define requirement_vector_iterate_end
Definition requirements.h:94
requirement_vector_iterate
#define requirement_vector_iterate(req_vec, preq)
Definition requirements.h:92
research_goal_unknown_techs
int research_goal_unknown_techs(const struct research *presearch, Tech_type_id goal)
Definition research.c:750
research_advance_name_translation
const char * research_advance_name_translation(const struct research *presearch, Tech_type_id tech)
Definition research.c:273
research_get
struct research * research_get(const struct player *pplayer)
Definition research.c:128
research_invention_state
enum tech_state research_invention_state(const struct research *presearch, Tech_type_id tech)
Definition research.c:619
ARRAY_SIZE
#define ARRAY_SIZE(x)
Definition shared.h:85
specialist_by_translated_name
struct specialist * specialist_by_translated_name(const char *name)
Definition specialist.c:130
canvas::surface
cairo_surface_t * surface
Definition canvas.h:23
civclient::conn
struct connection conn
Definition client_main.h:96
color
Definition colors.h:21
connection::playing
struct player * playing
Definition connection.h:151
drawn_sprite
Definition tilespec.h:110
extra_type
Definition extras.h:88
extra_type::buildable
bool buildable
Definition extras.h:116
extra_type::build_time
int build_time
Definition extras.h:118
goods_type
Definition traderoutes.h:183
help_item
Definition helpdata.h:25
help_item::text
char * text
Definition helpdata.h:26
help_page_selection
Definition helpdlg.c:99
help_page_selection::page
enum help_page_type page
Definition helpdlg.c:102
help_page_selection::req
const struct requirement * req
Definition helpdlg.c:103
help_page_selection::type
enum help_page_selection::@155 type
help_page_selection::u
union help_page_selection::@156 u
help_page_selection::HPAGE_SRC_REQ
@ HPAGE_SRC_REQ
Definition helpdlg.c:100
help_page_selection::HPAGE_SRC_ENUM
@ HPAGE_SRC_ENUM
Definition helpdlg.c:100
impr_type
Definition improvement.h:50
item
Definition climisc.h:82
nation_type
Definition nation.h:98
road_type
Definition road.h:71
terrain::cultivate_result
struct terrain * cultivate_result
Definition terrain.h:215
terrain::resources
struct extra_type ** resources
Definition terrain.h:204
terrain::plant_time
int plant_time
Definition terrain.h:219
terrain::plant_result
struct terrain * plant_result
Definition terrain.h:218
terrain::defense_bonus
int defense_bonus
Definition terrain.h:200
terrain::cultivate_time
int cultivate_time
Definition terrain.h:216
terrain::movement_cost
int movement_cost
Definition terrain.h:199
terrain::output
int output[O_LAST]
Definition terrain.h:202
terrain::transform_time
int transform_time
Definition terrain.h:231
terrain::transform_result
struct terrain * transform_result
Definition terrain.h:229
unit_type
Definition unittype.h:500
unit_type::defense_strength
int defense_strength
Definition unittype.h:516
unit_type::firepower
int firepower
Definition unittype.h:525
unit_type::obsoleted_by
const struct unit_type * obsoleted_by
Definition unittype.h:529
unit_type::vision_radius_sq
int vision_radius_sq
Definition unittype.h:522
unit_type::move_rate
int move_rate
Definition unittype.h:517
unit_type::hp
int hp
Definition unittype.h:524
unit_type::attack_strength
int attack_strength
Definition unittype.h:515
universal::kind
enum universals_n kind
Definition fc_types.h:902
fc_snprintf
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:974
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
advance_by_number
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
is_future_tech
bool is_future_tech(Tech_type_id tech)
Definition tech.c:281
advance_by_translated_name
struct advance * advance_by_translated_name(const char *name)
Definition tech.c:185
advance_requires
struct advance * advance_requires(const struct advance *padvance, enum tech_req require)
Definition tech.c:136
advance_name_translation
const char * advance_name_translation(const struct advance *padvance)
Definition tech.c:290
advance_required
Tech_type_id advance_required(const Tech_type_id tech, enum tech_req require)
Definition tech.c:121
advance_number
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:98
advance_iterate_all_end
#define advance_iterate_all_end
Definition tech.h:279
AR_TWO
@ AR_TWO
Definition tech.h:112
AR_ONE
@ AR_ONE
Definition tech.h:111
advance_iterate_all
#define advance_iterate_all(_p)
Definition tech.h:278
A_NONE
#define A_NONE
Definition tech.h:43
A_LAST
#define A_LAST
Definition tech.h:45
terrain_by_translated_name
struct terrain * terrain_by_translated_name(const char *name)
Definition terrain.c:202
terrain_name_translation
const char * terrain_name_translation(const struct terrain *pterrain)
Definition terrain.c:238
T_NONE
#define T_NONE
Definition terrain.h:56
get_building_sprite
struct sprite * get_building_sprite(const struct tileset *t, const struct impr_type *pimprove)
Definition tilespec.c:6783
fill_basic_extra_sprite_array
int fill_basic_extra_sprite_array(const struct tileset *t, struct drawn_sprite *sprs, const struct extra_type *pextra)
Definition tilespec.c:7200
fill_basic_terrain_layer_sprite_array
int fill_basic_terrain_layer_sprite_array(struct tileset *t, struct drawn_sprite *sprs, int layer, struct terrain *pterrain)
Definition tilespec.c:7167
tileset_tile_height
int tileset_tile_height(const struct tileset *t)
Definition tilespec.c:765
get_unittype_sprite
struct sprite * get_unittype_sprite(const struct tileset *t, const struct unit_type *punittype, enum unit_activity activity, enum direction8 facing)
Definition tilespec.c:6805
get_nation_flag_sprite
struct sprite * get_nation_flag_sprite(const struct tileset *t, const struct nation_type *pnation)
Definition tilespec.c:6756
tileset_tile_width
int tileset_tile_width(const struct tileset *t)
Definition tilespec.c:753
get_tech_sprite
struct sprite * get_tech_sprite(const struct tileset *t, Tech_type_id tech)
Definition tilespec.c:6774
goods_by_translated_name
struct goods_type * goods_by_translated_name(const char *name)
Definition traderoutes.c:654
is_tech_req_for_utype
bool is_tech_req_for_utype(const struct unit_type *ptype, struct advance *padv)
Definition unittype.c:2724
utype_build_shield_cost_base
int utype_build_shield_cost_base(const struct unit_type *punittype)
Definition unittype.c:1468
utype_primary_tech_req
struct advance * utype_primary_tech_req(const struct unit_type *ptype)
Definition unittype.c:2710
unit_type_by_translated_name
struct unit_type * unit_type_by_translated_name(const char *name)
Definition unittype.c:1752
utype_name_translation
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1560
unit_type_iterate
#define unit_type_iterate(_p)
Definition unittype.h:855
unit_type_iterate_end
#define unit_type_iterate_end
Definition unittype.h:862
U_NOT_OBSOLETED
#define U_NOT_OBSOLETED
Definition unittype.h:528
freeciv_name_version
const char * freeciv_name_version(void)
Definition version.c:35
Generated on Sun Dec 22 2024 23:00:32 for Freeciv-3.2 by doxygen 1.9.8