Freeciv-3.3
Loading...
Searching...
No Matches
editgui.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 2005 - The Freeciv Project
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 <math.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22
23#include <gtk/gtk.h>
24#include <gdk/gdkkeysyms.h>
25
26/* utility */
27#include "fcintl.h"
28#include "log.h"
29#include "shared.h"
30#include "support.h"
31
32/* common */
33#include "connection.h"
34#include "game.h"
35#include "government.h"
36#include "packets.h"
37
38/* client */
39#include "chatline_common.h"
40#include "client_main.h"
41#include "dialogs_g.h"
42#include "editor.h"
43#include "mapview_common.h"
44#include "tilespec.h"
45
46/* client/gui-gtk-4.0 */
47#include "canvas.h"
48#include "editgui.h"
49#include "editprop.h"
50#include "gui_main.h"
51#include "gui_stuff.h"
52#include "plrdlg.h"
53#include "sprite.h"
54
55
63
71
79
84
86 struct editbar *editbar_parent;
87
89
92};
93
94static struct tool_value_selector *
97static void editinfobox_refresh(struct editinfobox *ei);
99 gpointer user_data);
105
106static struct editbar *editor_toolbar;
108
109/************************************************************************/
113static void refresh_all_buttons(struct editbar *eb)
114{
117 GtkWidget *tb = NULL;
118 int i;
119
120 if (eb == NULL) {
121 return;
122 }
123
126
127 for (i = 0; i < NUM_EDITOR_TOOL_MODES; i++) {
128 tb = eb->mode_buttons[i];
129 if (tb == NULL) {
130 continue;
131 }
138 }
139
141 && eb->tool_buttons[ett] != NULL) {
142 tb = eb->tool_buttons[ett];
148 }
149}
150
151/************************************************************************/
156{
157 gboolean active;
160
162 if (!(etm < NUM_EDITOR_TOOL_MODES)) {
163 return;
164 }
165
168
171}
172
173/************************************************************************/
178{
179 if (!(ett < NUM_EDITOR_TOOL_TYPES)) {
180 return;
181 }
182
184 GtkWidget *dialog;
185
189 _("The current ruleset does not define any "
190 "objects corresponding to this editor tool."));
192 blocking_dialog(dialog);
194 } else {
196 }
197}
198
199/************************************************************************/
204{
205 gboolean active;
207
210
211 if (active) {
214 }
215}
216
217/************************************************************************/
225{
226 GtkListStore *store;
227 GdkPixbuf *flag;
229 GtkWidget *combo;
230 int index = -1, i;
231
232 if (eb == NULL || eb->player_pov_store == NULL) {
233 return;
234 }
235
236 store = eb->player_pov_store;
238
240 gtk_list_store_set(store, &iter, PPV_COL_NAME, _("Global Observer"),
241 PPV_COL_PLAYER_NO, -1, -1);
242
243 i = 1;
244 players_iterate(pplayer) {
247 PPV_COL_PLAYER_NO, player_number(pplayer), -1);
248
249 if (pplayer->nation != NO_NATION_SELECTED) {
250 flag = get_flag(pplayer->nation);
251
252 if (flag != NULL) {
253 gtk_list_store_set(store, &iter, PPV_COL_FLAG, flag, -1);
254 g_object_unref(flag);
255 }
256 }
257 if (pplayer == client_player()) {
258 index = i;
259 }
260 i++;
262
264 index = 0;
265 }
266
267 combo = eb->player_pov_combobox;
269}
270
271/************************************************************************/
279 gpointer user_data)
280{
281 struct editbar *eb = user_data;
282 int id;
283 struct player *pplayer;
285 GtkTreeModel *model;
286
287 if (eb == NULL || eb->widget == NULL
288 || !gtk_widget_get_visible(eb->widget)) {
289 return;
290 }
291
292 if (!gtk_combo_box_get_active_iter(combo, &iter)) {
293 return;
294 }
295
296 model = gtk_combo_box_get_model(combo);
297 gtk_tree_model_get(model, &iter, PPV_COL_PLAYER_NO, &id, -1);
298
299 if ((client_is_global_observer() && id == -1)
300 || client_player_number() == id) {
301 return;
302 }
303
304 /* Ugh... hard-coded server command strings. :( */
305 if (id == -1) {
306 send_chat("/observe");
307 return;
308 }
309
310 pplayer = player_by_number(id);
311 if (pplayer != NULL) {
312 send_chat_printf("/take \"%s\"", pplayer->name);
313 }
314}
315
316/************************************************************************/
321{
322 gint res;
323 GtkWidget *dialog;
326 GtkTreeModel *model;
327 int id;
328
329 if (tvs == nullptr) {
330 return -1;
331 }
332
333 dialog = tvs->dialog;
334 res = blocking_dialog(dialog);
336
337 if (res != GTK_RESPONSE_ACCEPT) {
338 return -1;
339 }
340
342 if (!gtk_tree_selection_get_selected(sel, &model, &iter)) {
343 return -1;
344 }
345
346 gtk_tree_model_get(model, &iter, TVS_COL_ID, &id, -1);
347
348 return id;
349}
350
351/************************************************************************/
358{
359 struct editbar *eb;
360 struct tool_value_selector *tvs;
361 int res = -1;
362
364 if (eb == NULL || !(ett < NUM_EDITOR_TOOL_TYPES)) {
365 return FALSE;
366 }
367
369 return FALSE;
370 }
371
372 tvs = eb->tool_selectors[ett];
373 if (!tvs) {
374 return FALSE;
375 }
376
378
379 if (res >= 0) {
382 }
383
384 return TRUE;
385}
386
387/************************************************************************/
391 int n_press,
392 double x, double y, gpointer data)
393{
395}
396
397/************************************************************************/
403{
405 GtkWidget *pic, *button, *hbox;
407 struct sprite *sprite;
408 int i;
411
412 if (!eb || !(ett < NUM_EDITOR_TOOL_TYPES)) {
413 return;
414 }
415
416 for (i = 0; i < NUM_EDITOR_TOOL_TYPES; i++) {
417 if (eb->tool_buttons[i] != NULL) {
418 parent = GTK_TOGGLE_BUTTON(eb->tool_buttons[i]);
419 break;
420 }
421 }
422
423 if (parent == NULL) {
424 button = gtk_toggle_button_new();
425 } else {
426 button = gtk_toggle_button_new();
429 }
430
436
440 gtk_size_group_add_widget(eb->size_group, button);
443
444 g_signal_connect(button, "toggled",
447
451 g_signal_connect(controller, "pressed",
455
456 hbox = eb->widget;
457 gtk_box_append(GTK_BOX(hbox), button);
458 eb->tool_buttons[ett] = button;
459
461 eb->tool_selectors[ett] = create_tool_value_selector(eb, ett);
462 }
463}
464
465/************************************************************************/
478
479/************************************************************************/
485{
487 GtkWidget *pic, *button, *hbox;
488 struct sprite *sprite;
489 const char *tooltip;
490
491 if (!eb || !(etm < NUM_EDITOR_TOOL_MODES)) {
492 return;
493 }
494
495 button = gtk_toggle_button_new();
496
502
506 if (tooltip != NULL) {
508 }
509 gtk_size_group_add_widget(eb->size_group, button);
512
513 g_signal_connect(button, "toggled",
516
517 hbox = eb->widget;
518 gtk_box_append(GTK_BOX(hbox), button);
519 eb->mode_buttons[etm] = button;
520}
521
522/************************************************************************/
525static struct editbar *editbar_create(void)
526{
527 struct editbar *eb;
528 GtkWidget *hbox, *button, *combo, *pic, *separator, *vgrid;
529 GtkListStore *store;
532 const struct editor_sprites *sprites;
533 int grid_row = 0;
534
535 eb = fc_calloc(1, sizeof(struct editbar));
536
538 eb->widget = hbox;
540
541 sprites = get_editor_sprites(tileset);
542
544
547
558
561
562 /* Player POV indicator. */
567
571 G_TYPE_INT);
572 eb->player_pov_store = store;
573
575
579 cell, "pixbuf", PPV_COL_FLAG);
580
584 cell, "text", PPV_COL_NAME);
585
586 gtk_widget_set_size_request(combo, 140, -1);
587 g_signal_connect(combo, "changed",
589
591 _("Switch player point-of-view. Use this to edit "
592 "from the perspective of different players, or "
593 "even as a global observer."));
594 gtk_grid_attach(GTK_GRID(vgrid), combo, 0, grid_row++, 1, 1);
595 eb->player_pov_combobox = combo;
596
597 /* Property editor button. */
598 button = gtk_button_new();
603 gtk_widget_set_tooltip_text(button, _("Show the property editor."));
604 gtk_size_group_add_widget(eb->size_group, button);
607 g_signal_connect(button, "clicked",
609 gtk_box_append(GTK_BOX(hbox), button);
610
611 return eb;
612}
613
614/************************************************************************/
620{
623 GtkTreeModel *model;
624 int value, store_value;
625 struct tool_value_selector *tvs;
626
628 return;
629 }
630
631 tvs = eb->tool_selectors[ett];
632
633 if (!tvs) {
634 return;
635 }
636
637 value = editor_tool_get_value(ett);
638 model = GTK_TREE_MODEL(tvs->store);
639 if (!gtk_tree_model_get_iter_first(model, &iter)) {
640 return;
641 }
642
643 do {
645 if (value == store_value) {
648 break;
649 }
650 } while (gtk_tree_model_iter_next(model, &iter));
651}
652
653/************************************************************************/
658{
659 int ett;
660
661 if (!eb) {
662 return;
663 }
664
665 for (ett = 0; ett < NUM_EDITOR_TOOL_TYPES; ett++) {
668 }
669 }
670}
671
672/************************************************************************/
675static void editbar_refresh(struct editbar *eb)
676{
677 if (eb == nullptr || eb->widget == nullptr) {
678 return;
679 }
680
681 if (!editor_is_active()) {
683 return;
684 }
685
689
691}
692
693/************************************************************************/
702static GdkPixbuf *create_terrain_pixbuf(struct terrain *pterrain)
703{
704 int w, h, i;
707 cairo_t *cr;
708
711
713
716 cairo_paint(cr);
717 cairo_destroy(cr);
718
719 for (i = 0; i < 3; i++) {
720 struct drawn_sprite sprs[80];
722 i, pterrain);
723
724 put_drawn_sprites(&canvas, 1.0, 0, 0, count, sprs, FALSE);
725 }
726
729
730 return pixbuf;
731}
732
733/************************************************************************/
737{
739 GtkTreeModel *model = GTK_TREE_MODEL(store);
740
741 if (gtk_tree_model_get_iter_first(model, &iter)) {
742 do {
744
746 if (pixbuf != NULL) {
748 }
749 } while (gtk_tree_model_iter_next(model, &iter));
750 }
751
753}
754
755/************************************************************************/
758static void clear_tool_stores(struct editbar *eb)
759{
760 clear_tool_store(eb->tool_selectors[ETT_TERRAIN]->store);
761 clear_tool_store(eb->tool_selectors[ETT_TERRAIN_RESOURCE]->store);
762 clear_tool_store(eb->tool_selectors[ETT_TERRAIN_SPECIAL]->store);
763 clear_tool_store(eb->tool_selectors[ETT_ROAD]->store);
764 clear_tool_store(eb->tool_selectors[ETT_MILITARY_BASE]->store);
765 clear_tool_store(eb->tool_selectors[ETT_UNIT]->store);
766}
767
768/************************************************************************/
772{
774 GtkListStore *store;
776 struct sprite *sprite;
777 struct tool_value_selector *tvs;
778
779 if (eb == NULL || tileset == NULL) {
780 return;
781 }
782
784
785 /* Reload terrains. */
786
787 tvs = eb->tool_selectors[ETT_TERRAIN];
788 store = tvs->store;
789
790 terrain_type_iterate(pterrain) {
793 TVS_COL_ID, terrain_number(pterrain),
795 -1);
796 pixbuf = create_terrain_pixbuf(pterrain);
797 if (pixbuf != NULL) {
800 }
802
803
804 /* Reload terrain resources. */
805
806 tvs = eb->tool_selectors[ETT_TERRAIN_RESOURCE];
807 store = tvs->store;
808
812 TVS_COL_ID, extra_index(pextra),
814 -1);
815 pixbuf = create_extra_pixbuf(pextra);
816 if (pixbuf != NULL) {
819 }
821
822 /* Reload terrain specials. */
823
824 tvs = eb->tool_selectors[ETT_TERRAIN_SPECIAL];
825 store = tvs->store;
826
830 TVS_COL_ID, extra_index(pextra),
832 -1);
833 pixbuf = create_extra_pixbuf(pextra);
834 if (pixbuf != NULL) {
837 }
839
840 /* Reload roads. */
841
842 tvs = eb->tool_selectors[ETT_ROAD];
843 store = tvs->store;
844
848 TVS_COL_ID, extra_index(pextra),
850 -1);
851 pixbuf = create_extra_pixbuf(pextra);
852 if (pixbuf != NULL) {
855 }
857
858 /* Reload military bases. */
859
860 tvs = eb->tool_selectors[ETT_MILITARY_BASE];
861 store = tvs->store;
862
866 TVS_COL_ID, extra_index(pextra),
868 -1);
869 pixbuf = create_extra_pixbuf(pextra);
870 if (pixbuf != NULL) {
873 }
875
876
877 /* Reload unit types. */
878
879 tvs = eb->tool_selectors[ETT_UNIT];
880 store = tvs->store;
881
887 -1);
890 if (sprite == NULL) {
891 continue;
892 }
894 if (pixbuf != NULL) {
897 }
899}
900
901/************************************************************************/
905{
906 int modifiers = EKM_NONE;
907
910 }
913 }
916 }
917
918 return modifiers;
919}
920
921/************************************************************************/
937
938/************************************************************************/
953
954/************************************************************************/
967
968/************************************************************************/
980
981/************************************************************************/
984static struct tool_value_selector *
987{
988 struct tool_value_selector *tvs;
989 GtkWidget *vbox, *view, *scrollwin;
994
995 tvs = fc_calloc(1, sizeof(struct tool_value_selector));
996
997 tvs->editbar_parent = eb;
998
999 tvs->dialog = gtk_dialog_new_with_buttons(_("Select Tool Value"),
1002 _("_OK"), GTK_RESPONSE_ACCEPT,
1003 _("_Cancel"), GTK_RESPONSE_REJECT,
1004 NULL);
1006
1009 G_TYPE_INT,
1011 tvs->store = store;
1012
1021
1025 g_signal_connect(view, "row-activated",
1027
1030
1033 cell, "pixbuf",
1040
1043 "text", TVS_COL_ID, NULL);
1050
1053 "text", TVS_COL_NAME, NULL);
1060
1062 tvs->view = view;
1063
1064 /* Show everything but the window itself. */
1066
1067 return tvs;
1068}
1069
1070/************************************************************************/
1075 int n_press,
1076 double x, double y)
1077{
1079
1080 return TRUE;
1081}
1082
1083/************************************************************************/
1088 int n_press,
1089 double x, double y)
1090{
1093
1094 return TRUE;
1095}
1096
1097/************************************************************************/
1102{
1103 struct editinfobox *ei;
1104 int which, value;
1105 enum editor_tool_type ett;
1106
1108
1109 if (!ei) {
1110 return;
1111 }
1112
1115 ett = editor_get_tool();
1116
1117 switch (which) {
1118 case SPIN_BUTTON_SIZE:
1119 editor_tool_set_size(ett, value);
1120 break;
1121 case SPIN_BUTTON_COUNT:
1122 editor_tool_set_count(ett, value);
1123 break;
1124 default:
1125 return;
1126 break;
1127 }
1128
1130}
1131
1132/************************************************************************/
1138{
1139 struct editinfobox *ei = userdata;
1141 GtkTreeModel *model;
1142 int player_no = -1;
1143
1144 if (ei == NULL) {
1145 return;
1146 }
1147
1148 if (!gtk_combo_box_get_active_iter(combo, &iter)) {
1149 return;
1150 }
1151
1152 model = gtk_combo_box_get_model(combo);
1153 gtk_tree_model_get(model, &iter, TAP_COL_PLAYER_NO, &player_no, -1);
1154
1156}
1157
1158/************************************************************************/
1162{
1163 GtkWidget *label, *vbox, *frame, *hgrid, *vbox2, *pic;
1164 GtkWidget *spin, *combo;
1165 GtkListStore *store;
1168 struct editinfobox *ei;
1169 char buf[128];
1170 int grid_col = 0;
1171
1172 ei = fc_calloc(1, sizeof(*ei));
1173
1174 /* If you turn this to something else than GtkFrame, also adjust
1175 * editgui.c replace_widget() code that replaces widget in it. */
1176 frame = gtk_frame_new(_("Editor Tool"));
1178 gtk_widget_set_margin_end(frame, 4);
1179 gtk_widget_set_margin_top(frame, 4);
1181 ei->widget = frame;
1182
1188 gtk_frame_set_child(GTK_FRAME(frame), vbox);
1189
1190 /* Tool section */
1191 hgrid = gtk_grid_new();
1194
1195 pic = gtk_picture_new();
1196 gtk_widget_set_tooltip_text(pic, _("Click to change value if applicable."));
1197
1199 g_signal_connect(controller, "pressed",
1201 NULL);
1203
1204 gtk_grid_attach(GTK_GRID(hgrid), pic, grid_col++, 0, 1, 1);
1205 ei->tool_pic = pic;
1206
1209
1210 label = gtk_label_new(NULL);
1213 gtk_box_append(GTK_BOX(vbox2), label);
1214 ei->tool_label = label;
1215
1216 label = gtk_label_new(NULL);
1219 gtk_box_append(GTK_BOX(vbox2), label);
1220 ei->tool_value_label = label;
1221
1222 /* Mode section */
1223 hgrid = gtk_grid_new();
1224 grid_col = 0;
1227
1228 pic = gtk_picture_new();
1229 gtk_widget_set_tooltip_text(pic, _("Click to change tool mode."));
1230
1232 g_signal_connect(controller, "pressed",
1234 NULL);
1236
1237 gtk_grid_attach(GTK_GRID(hgrid), pic, grid_col++, 0, 1, 1);
1238 ei->mode_pic = pic;
1239
1242
1243 label = gtk_label_new(NULL);
1244 fc_snprintf(buf, sizeof(buf), "<span weight=\"bold\">%s</span>",
1245 _("Mode"));
1249 gtk_box_append(GTK_BOX(vbox2), label);
1250
1251 label = gtk_label_new(NULL);
1254 gtk_box_append(GTK_BOX(vbox2), label);
1255 ei->mode_label = label;
1256
1257 /* Spinner section */
1258 hgrid = gtk_grid_new();
1259 grid_col = 0;
1262 ei->size_hbox = hgrid;
1265 _("Use this to change the \"size\" parameter for the tool. "
1266 "This parameter controls for example the half-width "
1267 "of the square of tiles that will be affected by the "
1268 "tool, or the size of a created city."));
1269 g_signal_connect(spin, "value-changed",
1273 ei->size_spin_button = spin;
1274 label = gtk_label_new(_("Size"));
1275 gtk_grid_attach(GTK_GRID(hgrid), label, grid_col++, 0, 1, 1);
1276
1277 hgrid = gtk_grid_new();
1278 grid_col = 0;
1281 ei->count_hbox = hgrid;
1284 _("Use this to change the tool's \"count\" parameter. "
1285 "This controls for example how many units are placed "
1286 "at once with the unit tool."));
1287 g_signal_connect(spin, "value-changed",
1291 ei->count_spin_button = spin;
1292 label = gtk_label_new(_("Count"));
1293 gtk_grid_attach(GTK_GRID(hgrid), label, grid_col++, 0, 1, 1);
1294
1295 /* combo section */
1299 G_TYPE_INT);
1300 ei->tool_applied_player_store = store;
1302
1306 cell, "pixbuf", TAP_COL_FLAG);
1307
1311 cell, "text", TAP_COL_NAME);
1312
1313 gtk_widget_set_size_request(combo, 132, -1);
1314 g_signal_connect(combo, "changed",
1316
1318 _("Use this to change the \"applied player\" tool parameter. "
1319 "This controls for example under which player units and cities "
1320 "are created."));
1321 gtk_box_append(GTK_BOX(vbox), combo);
1322 ei->tool_applied_player_combobox = combo;
1323
1324 /* We add a ref to the editinfobox widget so that it is
1325 * not destroyed when replaced by the unit info box when
1326 * we leave edit mode. See editinfobox_refresh() call to replace_widget() */
1327 g_object_ref(ei->widget);
1328
1329 /* The edit info box starts with no parent, so we have to
1330 * show its internal widgets manually. */
1331 gtk_widget_set_visible(ei->widget, TRUE);
1332
1333 return ei;
1334}
1335
1336/************************************************************************/
1341{
1342 enum editor_tool_type ett;
1343 GtkListStore *store;
1344 GtkWidget *combo;
1346 GdkPixbuf *flag;
1347 int apno, index, i;
1348
1349 if (!ei) {
1350 return;
1351 }
1352
1353 ett = editor_get_tool();
1354 combo = ei->tool_applied_player_combobox;
1355 store = ei->tool_applied_player_store;
1356
1357 if (!combo || !store) {
1358 return;
1359 }
1360
1363 return;
1364 }
1365
1366 gtk_list_store_clear(store);
1367
1369 index = -1;
1370 i = 0;
1371
1372 players_iterate(pplayer) {
1373 gtk_list_store_append(store, &iter);
1374 gtk_list_store_set(store, &iter,
1376 TAP_COL_NAME, player_name(pplayer), -1);
1377
1378 if (pplayer->nation != NO_NATION_SELECTED) {
1379 flag = get_flag(pplayer->nation);
1380
1381 if (flag != NULL) {
1382 gtk_list_store_set(store, &iter, TAP_COL_FLAG, flag, -1);
1383 g_object_unref(flag);
1384 }
1385 }
1386 if (apno == player_number(pplayer)) {
1387 index = i;
1388 }
1389 i++;
1391
1392 if (index == -1) {
1393 if (player_count() > 0) {
1394 index = 0;
1395 }
1397 }
1400}
1401
1402/************************************************************************/
1409 int value)
1410{
1411 struct sprite *sprite = NULL;
1413 struct terrain *pterrain;
1414 struct unit_type *putype;
1415 const struct editor_sprites *sprites;
1416
1417 sprites = get_editor_sprites(tileset);
1418 if (!sprites) {
1419 return NULL;
1420 }
1421
1422 switch (ett) {
1423 case ETT_TERRAIN:
1424 pterrain = terrain_by_number(value);
1425 if (pterrain) {
1426 pixbuf = create_terrain_pixbuf(pterrain);
1427 }
1428 break;
1431 case ETT_ROAD:
1432 case ETT_MILITARY_BASE:
1433 if (value >= 0) {
1435 }
1436 break;
1437 case ETT_UNIT:
1438 putype = utype_by_number(value);
1439 if (putype) {
1442 }
1443 break;
1444 case ETT_CITY:
1445 sprite = sprites->city;
1446 break;
1447 case ETT_VISION:
1448 sprite = sprites->vision;
1449 break;
1450 case ETT_STARTPOS:
1451 sprite = sprites->startpos;
1452 break;
1453 case ETT_COPYPASTE:
1454 sprite = sprites->copypaste;
1455 break;
1456 default:
1457 break;
1458 }
1459
1460 if (sprite) {
1462 /*
1463 if (pixbuf) {
1464 g_object_ref(pixbuf);
1465 }
1466 */
1467 sprite = NULL;
1468 }
1469
1470 return pixbuf;
1471}
1472
1473/************************************************************************/
1480{
1481 struct sprite *sprite = NULL;
1483
1485
1486 if (sprite) {
1488 /*
1489 if (pixbuf) {
1490 g_object_ref(pixbuf);
1491 }
1492 */
1493 }
1494
1495 return pixbuf;
1496}
1497
1498/************************************************************************/
1504{
1506
1508 if (parent == nullptr) {
1509 return;
1510 }
1511
1513
1514 if (GTK_IS_FRAME(parent)) {
1516 } else {
1518
1521 }
1522
1524}
1525
1526/************************************************************************/
1530{
1532 GtkLabel *label;
1533 enum editor_tool_type ett;
1534 enum editor_tool_mode etm;
1535 int value;
1536 char buf[256];
1537
1538 if (ei == NULL) {
1539 return;
1540 }
1541
1542 if (!editor_is_active()) {
1544 return;
1545 }
1546
1547 ett = editor_get_tool();
1549 value = editor_tool_get_value(ett);
1550
1551 label = GTK_LABEL(ei->mode_label);
1553
1556 if (pixbuf) {
1558 pixbuf = NULL;
1559 }
1560
1561 fc_snprintf(buf, sizeof(buf), "<span weight=\"bold\">%s</span>",
1563 gtk_label_set_markup(GTK_LABEL(ei->tool_label), buf);
1564
1565 if (etm == ETM_COPY || etm == ETM_PASTE) {
1566 struct edit_buffer *ebuf;
1567 struct sprite *spr;
1568 char status[256];
1569
1571 edit_buffer_get_status_string(ebuf, status, sizeof(status));
1572 gtk_label_set_text(GTK_LABEL(ei->tool_value_label), status);
1573
1577 if (pixbuf) {
1579 pixbuf = NULL;
1580 }
1581 } else {
1584 if (pixbuf) {
1586 pixbuf = NULL;
1587 }
1588 gtk_label_set_text(GTK_LABEL(ei->tool_value_label),
1590 }
1591
1593
1595 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ei->size_spin_button),
1597 gtk_widget_set_visible(ei->size_hbox, TRUE);
1598 } else {
1599 gtk_widget_set_visible(ei->size_hbox, FALSE);
1600 }
1601
1603 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ei->count_spin_button),
1605 gtk_widget_set_visible(ei->count_hbox, TRUE);
1606 } else {
1607 gtk_widget_set_visible(ei->count_hbox, FALSE);
1608 }
1609
1611}
1612
1613/************************************************************************/
1617{
1618 return FALSE; /* Don't gobble. */
1619}
1620
1621/************************************************************************/
1625{
1626 enum editor_tool_type ett;
1627
1628 ett = editor_get_tool();
1629 switch (keyval) {
1630 case GDK_KEY_D:
1632 break;
1633 case GDK_KEY_C:
1636 break;
1637 case GDK_KEY_V:
1640 break;
1641 case GDK_KEY_T:
1643 break;
1644 case GDK_KEY_R:
1646 break;
1647 case GDK_KEY_S:
1649 break;
1650 case GDK_KEY_P:
1652 break;
1653 case GDK_KEY_M:
1655 break;
1656 case GDK_KEY_U:
1658 break;
1659 default:
1660 return TRUE; /* Gobble? */
1661 break;
1662 }
1663
1665
1666 return TRUE;
1667}
1668
1669/************************************************************************/
1673{
1675
1676 /* Check ctrl before shift - this is correct also for the case where
1677 * they are both active. */
1678 if (state & GDK_CONTROL_MASK) {
1680 }
1681
1682 if (state & GDK_SHIFT_MASK) {
1684 }
1685
1686 ett = editor_get_tool();
1687
1688 switch (keyval) {
1689 case GDK_KEY_t:
1691 break;
1692 case GDK_KEY_r:
1694 break;
1695 case GDK_KEY_s:
1697 break;
1698 case GDK_KEY_p:
1699 new_ett = ETT_ROAD;
1700 break;
1701 case GDK_KEY_m:
1703 break;
1704 case GDK_KEY_u:
1705 new_ett = ETT_UNIT;
1706 break;
1707 case GDK_KEY_c:
1708 new_ett = ETT_CITY;
1709 break;
1710 case GDK_KEY_v:
1712 break;
1713 case GDK_KEY_b:
1715 break;
1716 case GDK_KEY_plus:
1717 case GDK_KEY_equal:
1718 case GDK_KEY_KP_Add:
1721
1723 } else if (editor_tool_has_count(ett)) {
1724 int count = editor_tool_get_count(ett);
1725
1726 editor_tool_set_count(ett, count + 1);
1727 }
1728 break;
1729 case GDK_KEY_minus:
1730 case GDK_KEY_underscore:
1734
1736 } else if (editor_tool_has_count(ett)) {
1737 int count = editor_tool_get_count(ett);
1738
1739 editor_tool_set_count(ett, count - 1);
1740 }
1741 break;
1742 case GDK_KEY_1:
1743 case GDK_KEY_2:
1744 case GDK_KEY_3:
1745 case GDK_KEY_4:
1746 case GDK_KEY_5:
1747 case GDK_KEY_6:
1748 case GDK_KEY_7:
1749 case GDK_KEY_8:
1750 case GDK_KEY_9:
1753 } else if (editor_tool_has_count(ett)) {
1755 }
1756 break;
1757 case GDK_KEY_space:
1759 break;
1760 case GDK_KEY_Tab:
1762 break;
1763 case GDK_KEY_F1:
1764 case GDK_KEY_F2:
1765 case GDK_KEY_F3:
1766 case GDK_KEY_F4:
1767 case GDK_KEY_F5:
1768 case GDK_KEY_F6:
1769 case GDK_KEY_F7:
1770 case GDK_KEY_F8:
1771 case GDK_KEY_F9:
1772 case GDK_KEY_F10:
1773 case GDK_KEY_F11:
1774 case GDK_KEY_F12:
1775 return FALSE; /* Allow default handler. */
1776 break;
1777 default:
1778 return TRUE; /* Gobbled... */
1779 break;
1780 }
1781
1784 }
1785
1787
1788 return TRUE;
1789}
1790
1791/************************************************************************/
1795{
1796 return editor_toolbar;
1797}
1798
1799/************************************************************************/
1803{
1804 struct property_editor *pe;
1805 struct editbar *eb;
1806 struct editinfobox *ei;
1807
1809 if (eb != NULL) {
1811 }
1812
1814 if (ei != NULL) {
1816 }
1817
1819 if (!editor_is_active()) {
1822 }
1823}
1824
1825/************************************************************************/
1829{
1830 if (editor_toolbar == NULL) {
1832 }
1833 if (editor_infobox == NULL) {
1835 }
1836}
1837
1838/************************************************************************/
1842{
1843 struct editbar *eb = editgui_get_editbar();
1845
1846 if (ei != NULL) {
1847 /* We have extra ref for ei->widget that has protected
1848 * it from getting destroyed when editinfobox_refresh()
1849 * moves widgets around. Free that extra ref here. */
1850 g_object_unref(ei->widget);
1851 }
1852
1854}
1855
1856/************************************************************************/
1860{
1861 return editor_infobox;
1862}
1863
1864/************************************************************************/
1873
1874/************************************************************************/
1892
1893/************************************************************************/
1897{
1898 struct property_editor *pe;
1899
1902 property_editor_clear(pe); /* And clear it. */
1903}
1904
1905/************************************************************************/
1913void editgui_notify_object_changed(int objtype, int object_id, bool removal)
1914{
1915 struct property_editor *pe;
1916
1917 if (!editor_is_active()) {
1918 return;
1919 }
1920
1922 property_editor_handle_object_changed(pe, objtype, object_id, removal);
1923}
1924
1925/************************************************************************/
1929{
1930 struct property_editor *pe;
1931
1932 if (!editor_is_active()) {
1933 return;
1934 }
1935
1938}
int send_chat_printf(const char *format,...)
int send_chat(const char *message)
bool client_is_global_observer(void)
int client_player_number(void)
#define client_player()
char * incite_cost
Definition comments.c:76
int objtype
Definition editgui_g.h:28
editgui_notify_object_changed
Definition editgui_g.h:27
int int id
Definition editgui_g.h:28
int edit_buffer_get_status_string(const struct edit_buffer *ebuf, char *buf, int buflen)
Definition editor.c:1870
bool editor_is_active(void)
Definition editor.c:346
int editor_tool_get_size(enum editor_tool_type ett)
Definition editor.c:1218
void editor_set_tool(enum editor_tool_type ett)
Definition editor.c:270
void editor_mouse_button_press(int canvas_x, int canvas_y, int button, int modifiers)
Definition editor.c:661
void editor_mouse_move(int canvas_x, int canvas_y, int modifiers)
Definition editor.c:866
enum editor_tool_mode editor_tool_get_mode(enum editor_tool_type ett)
Definition editor.c:335
void editor_tool_set_count(enum editor_tool_type ett, int count)
Definition editor.c:1263
void editor_tool_toggle_mode(enum editor_tool_type ett, enum editor_tool_mode etm)
Definition editor.c:1041
const char * editor_tool_get_value_name(enum editor_tool_type emt, int value)
Definition editor.c:1172
int editor_tool_get_value(enum editor_tool_type ett)
Definition editor.c:409
struct edit_buffer * editor_get_copy_buffer(void)
Definition editor.c:1767
void editor_tool_set_applied_player(enum editor_tool_type ett, int player_no)
Definition editor.c:1352
const char * editor_tool_get_mode_name(enum editor_tool_type ett, enum editor_tool_mode etm)
Definition editor.c:1778
void editor_tool_cycle_mode(enum editor_tool_type ett)
Definition editor.c:1058
int editor_tool_get_count(enum editor_tool_type ett)
Definition editor.c:1252
void editor_tool_set_size(enum editor_tool_type ett, int size)
Definition editor.c:1229
const char * editor_get_mode_tooltip(enum editor_tool_mode etm)
Definition editor.c:1815
bool editor_tool_is_usable(enum editor_tool_type ett)
Definition editor.c:359
enum editor_tool_type editor_get_tool(void)
Definition editor.c:286
bool editor_tool_has_applied_player(enum editor_tool_type ett)
Definition editor.c:1365
bool editor_tool_has_size(enum editor_tool_type ett)
Definition editor.c:1207
void editor_tool_set_value(enum editor_tool_type ett, int value)
Definition editor.c:397
bool editor_tool_has_value(enum editor_tool_type ett)
Definition editor.c:385
const char * editor_tool_get_tooltip(enum editor_tool_type ett)
Definition editor.c:1327
void editor_mouse_button_release(int canvas_x, int canvas_y, int button, int modifiers)
Definition editor.c:798
struct sprite * editor_tool_get_sprite(enum editor_tool_type ett)
Definition editor.c:1275
void editor_apply_tool_to_selection(void)
Definition editor.c:1128
bool editor_tool_has_mode(enum editor_tool_type ett, enum editor_tool_mode etm)
Definition editor.c:313
int editor_tool_get_applied_player(enum editor_tool_type ett)
Definition editor.c:1341
bool editor_tool_has_count(enum editor_tool_type ett)
Definition editor.c:1241
struct sprite * editor_get_mode_sprite(enum editor_tool_mode etm)
Definition editor.c:1837
const char * editor_tool_get_name(enum editor_tool_type ett)
Definition editor.c:1159
void editor_tool_set_mode(enum editor_tool_type ett, enum editor_tool_mode etm)
Definition editor.c:298
editor_tool_mode
Definition editor.h:52
@ ETM_PASTE
Definition editor.h:56
@ NUM_EDITOR_TOOL_MODES
Definition editor.h:58
@ ETM_ERASE
Definition editor.h:54
@ ETM_PAINT
Definition editor.h:53
@ ETM_COPY
Definition editor.h:55
@ OBJTYPE_PLAYER
Definition editor.h:30
@ OBJTYPE_GAME
Definition editor.h:31
@ EKM_CTRL
Definition editor.h:120
@ EKM_SHIFT
Definition editor.h:118
@ EKM_ALT
Definition editor.h:119
@ EKM_NONE
Definition editor.h:117
editor_tool_type
Definition editor.h:36
@ ETT_ROAD
Definition editor.h:40
@ ETT_TERRAIN_SPECIAL
Definition editor.h:39
@ ETT_UNIT
Definition editor.h:42
@ ETT_VISION
Definition editor.h:44
@ ETT_STARTPOS
Definition editor.h:46
@ NUM_EDITOR_TOOL_TYPES
Definition editor.h:49
@ ETT_CITY
Definition editor.h:43
@ ETT_COPYPASTE
Definition editor.h:47
@ ETT_TERRAIN_RESOURCE
Definition editor.h:38
@ ETT_MILITARY_BASE
Definition editor.h:41
@ ETT_TERRAIN
Definition editor.h:37
struct extra_type * extra_by_number(int id)
Definition extras.c:183
const char * extra_name_translation(const struct extra_type *pextra)
Definition extras.c:194
#define extra_index(_e_)
Definition extras.h:183
#define extra_type_by_cause_iterate_end
Definition extras.h:339
#define extra_type_by_cause_iterate(_cause, _extra)
Definition extras.h:333
#define EC_SPECIAL
Definition fc_types.h:822
#define _(String)
Definition fcintl.h:67
#define FC_STATIC_CANVAS_INIT
Definition canvas.h:28
static void refresh_all_buttons(struct editbar *eb)
Definition editgui.c:113
static void editbar_player_properties_button_clicked(GtkButton *b, gpointer userdata)
Definition editgui.c:463
tool_applied_player_columns
Definition editgui.c:72
@ TAP_COL_FLAG
Definition editgui.c:73
@ TAP_COL_NAME
Definition editgui.c:74
@ TAP_COL_PLAYER_NO
Definition editgui.c:75
@ TAP_NUM_COLS
Definition editgui.c:77
static bool editgui_run_tool_selection(enum editor_tool_type ett)
Definition editgui.c:356
static void editinfobox_refresh(struct editinfobox *ei)
Definition editgui.c:1519
void editgui_popup_properties(const struct tile_list *tiles, int objtype)
Definition editgui.c:1875
void editgui_notify_object_created(int tag, int id)
Definition editgui.c:1922
static void clear_tool_stores(struct editbar *eb)
Definition editgui.c:752
static int convert_modifiers(int gdk_event_state)
Definition editgui.c:898
static void try_to_set_editor_tool(enum editor_tool_type ett)
Definition editgui.c:177
static void clear_tool_store(GtkListStore *store)
Definition editgui.c:730
gboolean handle_edit_mouse_button_release(GdkEventButton *ev)
Definition editgui.c:956
static gboolean handle_edit_key_press_with_ctrl(GdkEventKey *ev)
Definition editgui.c:1606
gboolean handle_edit_key_press(GdkEventKey *ev)
Definition editgui.c:1662
static int tool_value_selector_run(struct tool_value_selector *tvs)
Definition editgui.c:319
static void editbar_add_mode_button(struct editbar *eb, enum editor_tool_mode etm)
Definition editgui.c:478
static void editbar_tool_button_toggled(GtkToggleButton *tb, gpointer userdata)
Definition editgui.c:201
static void editbar_add_tool_button(struct editbar *eb, enum editor_tool_type ett)
Definition editgui.c:407
void editgui_create_widgets(void)
Definition editgui.c:1822
static struct editbar * editbar_create(void)
Definition editgui.c:519
void editgui_popdown_all(void)
Definition editgui.c:1890
static void editbar_reload_tileset(struct editbar *eb)
Definition editgui.c:765
static void tool_value_selector_treeview_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer user_data)
Definition editgui.c:980
static void editinfobox_spin_button_value_changed(GtkSpinButton *spinbutton, gpointer userdata)
Definition editgui.c:1106
static void refresh_tool_applied_player_combo(struct editinfobox *ei)
Definition editgui.c:1338
static void editbar_mode_button_toggled(GtkToggleButton *tb, gpointer userdata)
Definition editgui.c:154
static void editinfobox_tool_applied_player_changed(GtkComboBox *combo, gpointer userdata)
Definition editgui.c:1142
static gboolean handle_edit_key_press_with_shift(GdkEventKey *ev)
Definition editgui.c:1614
static void refresh_all_tool_value_selectors(struct editbar *eb)
Definition editgui.c:651
spin_button_types
Definition editgui.c:80
@ SPIN_BUTTON_COUNT
Definition editgui.c:82
@ SPIN_BUTTON_SIZE
Definition editgui.c:81
gboolean handle_edit_mouse_button_press(GdkEventButton *ev)
Definition editgui.c:940
static struct tool_value_selector * create_tool_value_selector(struct editbar *eb_parent, enum editor_tool_type ett)
Definition editgui.c:994
static GdkPixbuf * create_terrain_pixbuf(struct terrain *pterrain)
Definition editgui.c:696
static void replace_widget(GtkWidget *old, GtkWidget *new)
Definition editgui.c:1501
static void editbar_player_pov_combobox_changed(GtkComboBox *combo, gpointer user_data)
Definition editgui.c:277
struct editinfobox * editgui_get_editinfobox(void)
Definition editgui.c:1853
gboolean handle_edit_mouse_move(GdkEventMotion *ev)
Definition editgui.c:971
tool_value_selector_columns
Definition editgui.c:56
@ TVS_COL_ID
Definition editgui.c:58
@ TVS_COL_NAME
Definition editgui.c:59
@ TVS_COL_IMAGE
Definition editgui.c:57
@ TVS_NUM_COLS
Definition editgui.c:61
player_pov_combo_columns
Definition editgui.c:64
@ PPV_COL_FLAG
Definition editgui.c:65
@ PPV_COL_PLAYER_NO
Definition editgui.c:67
@ PPV_COL_NAME
Definition editgui.c:66
@ PPV_NUM_COLS
Definition editgui.c:69
void editgui_refresh(void)
Definition editgui.c:1796
static void editbar_refresh(struct editbar *eb)
Definition editgui.c:669
static struct editinfobox * editor_infobox
Definition editgui.c:107
static struct editbar * editor_toolbar
Definition editgui.c:106
static gboolean editinfobox_handle_tool_image_button_press(GtkWidget *evbox, GdkEventButton *ev, gpointer data)
Definition editgui.c:1082
struct editbar * editgui_get_editbar(void)
Definition editgui.c:1788
static void refresh_tool_value_selector(struct editbar *eb, enum editor_tool_type ett)
Definition editgui.c:612
static struct editinfobox * editinfobox_create(void)
Definition editgui.c:1167
static void refresh_player_pov_indicator(struct editbar *eb)
Definition editgui.c:223
void editgui_tileset_changed(void)
Definition editgui.c:1862
void editgui_free(void)
Definition editgui.c:1835
static gboolean editinfobox_handle_mode_image_button_press(GtkWidget *evbox, GdkEventButton *ev, gpointer data)
Definition editgui.c:1093
static GdkPixbuf * get_tool_value_pixbuf(enum editor_tool_type ett, int value)
Definition editgui.c:1406
static GdkPixbuf * get_tool_mode_pixbuf(enum editor_tool_mode etm)
Definition editgui.c:1477
void property_editor_handle_object_changed(struct property_editor *pe, enum editor_object_type objtype, int object_id, bool remove)
Definition editprop.c:6322
void property_editor_handle_object_created(struct property_editor *pe, int tag, int object_id)
Definition editprop.c:6344
void property_editor_popup(struct property_editor *pe, enum editor_object_type objtype)
Definition editprop.c:6292
struct property_editor * editprop_get_property_editor(void)
Definition editprop.c:6245
void property_editor_reload(struct property_editor *pe, enum editor_object_type objtype)
Definition editprop.c:6382
void property_editor_popdown(struct property_editor *pe)
Definition editprop.c:6310
void property_editor_load_tiles(struct property_editor *pe, const struct tile_list *tiles)
Definition editprop.c:6256
void property_editor_clear(struct property_editor *pe)
Definition editprop.c:6362
GtkWidget * unit_info_box
Definition gui_main.c:153
GtkWidget * toplevel
Definition gui_main.c:126
void disable_gobject_callback(GObject *obj, GCallback cb)
Definition gui_stuff.c:1090
void enable_gobject_callback(GObject *obj, GCallback cb)
Definition gui_stuff.c:1106
GdkPixbuf * get_flag(const struct nation_type *nation)
Definition plrdlg.c:607
const char * tooltip
Definition repodlgs.c:1315
GdkPixbuf * surface_get_pixbuf(cairo_surface_t *surf, int width, int height)
Definition sprite.c:418
GdkPixbuf * sprite_get_pixbuf(struct sprite *sprite)
Definition sprite.c:402
GdkPixbuf * create_extra_pixbuf(const struct extra_type *pextra)
Definition sprite.c:494
static gboolean editbar_tool_right_button(GtkGestureClick *gesture, int n_press, double x, double y, gpointer data)
Definition editgui.c:390
gint blocking_dialog(GtkWidget *dlg)
Definition gui_stuff.c:1136
#define fc_assert_ret(condition)
Definition log.h:192
#define fc_assert(condition)
Definition log.h:177
void put_drawn_sprites(struct canvas *pcanvas, float zoom, int canvas_x, int canvas_y, int count, struct drawn_sprite *pdrawn, bool fog)
#define fc_calloc(n, esz)
Definition mem.h:38
#define NO_NATION_SELECTED
Definition nation.h:30
struct player * player_by_number(const int player_id)
Definition player.c:849
int player_count(void)
Definition player.c:817
int player_number(const struct player *pplayer)
Definition player.c:837
const char * player_name(const struct player *pplayer)
Definition player.c:895
#define players_iterate_end
Definition player.h:542
#define players_iterate(_pplayer)
Definition player.h:537
size_t size
Definition specvec.h:72
struct sprite int int y
Definition sprite_g.h:31
struct sprite int x
Definition sprite_g.h:31
cairo_surface_t * surface
Definition canvas.h:23
struct sprite * city
Definition tilespec.h:353
struct sprite * vision
Definition tilespec.h:354
struct sprite * copypaste
Definition tilespec.h:347
struct sprite * startpos
Definition tilespec.h:348
struct sprite * properties
Definition tilespec.h:356
char name[MAX_LEN_NAME]
Definition player.h:251
GtkWidget * view
Definition editgui.c:91
struct editbar * editbar_parent
Definition editgui.c:86
GtkListStore * store
Definition editgui.c:90
GtkWidget * dialog
Definition editgui.c:88
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:960
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
const char * terrain_name_translation(const struct terrain *pterrain)
Definition terrain.c:238
struct terrain * terrain_by_number(const Terrain_type_id type)
Definition terrain.c:156
Terrain_type_id terrain_number(const struct terrain *pterrain)
Definition terrain.c:147
#define terrain_type_iterate(_p)
Definition terrain.h:266
#define terrain_type_iterate_end
Definition terrain.h:272
int fill_basic_terrain_layer_sprite_array(struct tileset *t, struct drawn_sprite *sprs, int layer, struct terrain *pterrain)
Definition tilespec.c:7395
int tileset_tile_height(const struct tileset *t)
Definition tilespec.c:791
struct sprite * get_unittype_sprite(const struct tileset *t, const struct unit_type *punittype, enum unit_activity activity, enum direction8 facing)
Definition tilespec.c:7029
int tileset_tile_width(const struct tileset *t)
Definition tilespec.c:779
const struct editor_sprites * get_editor_sprites(const struct tileset *t)
Definition tilespec.c:7173
struct unit_type * utype_by_number(const Unit_type_id id)
Definition unittype.c:112
Unit_type_id utype_number(const struct unit_type *punittype)
Definition unittype.c:100
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1566
#define unit_type_iterate(_p)
Definition unittype.h:862
#define unit_type_iterate_end
Definition unittype.h:869