editprop.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 2005 - The Freeciv Project
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
***********************************************************************/
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
#include <limits.h> /* USHRT_MAX */
 
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
 
/* utility */
#include "bitvector.h"
#include "fc_cmdline.h"
#include "fcintl.h"
#include "log.h"
#include "mem.h"
 
/* common */
#include "fc_interface.h"
#include "game.h"
#include "government.h"
#include "map.h"
#include "movement.h"
#include "nation.h"
#include "research.h"
#include "tile.h"
 
/* client */
#include "client_main.h"
#include "climisc.h"
#include "editor.h"
#include "mapview_common.h"
#include "tilespec.h"
 
/* client/gui-gtk-4.0 */
#include "canvas.h"
#include "gui_main.h"
#include "gui_stuff.h"
#include "plrdlg.h"
#include "sprite.h"
 
#include "editprop.h"
 
 
/* Forward declarations. */
struct objprop;
struct objbind;
struct property_page;
struct property_editor;
struct extviewer;
 
/****************************************************************************
  Miscellaneous helpers.
****************************************************************************/
static GdkPixbuf *create_pixbuf_from_layers(const struct tile *ptile,
                                            const struct unit *punit,
                                            const struct city *pcity,
                                            enum layer_category category);
static GdkPixbuf *create_tile_pixbuf(const struct tile *ptile);
static GdkPixbuf *create_unit_pixbuf(const struct unit *punit);
static GdkPixbuf *create_city_pixbuf(const struct city *pcity);
 
static void add_column(GtkWidget *view,
                       int col_id,
                       const char *name,
                       GType gtype,
                       bool editable,
                       bool is_radio,
                       GCallback edit_callback,
                       gpointer callback_userdata);
 
static bool can_create_unit_at_tile(struct tile *ptile);
 
static int get_next_unique_tag(void);
 
/* 'struct stored_tag_hash' and related functions. */
#define SPECHASH_TAG stored_tag
#define SPECHASH_INT_KEY_TYPE
#define SPECHASH_INT_DATA_TYPE
#include "spechash.h"
 
/* NB: If packet definitions change, be sure to
 * update objbind_pack_current_values()!!! */
union packetdata {
  struct {
    gpointer v_pointer1;
    gpointer v_pointer2;
  } pointers;
  struct packet_edit_tile *tile;
  struct packet_edit_startpos_full *startpos;
  struct packet_edit_city *city;
  struct packet_edit_unit *unit;
  struct packet_edit_player *player;
  struct {
    struct packet_edit_game *game;
    struct packet_edit_scenario_desc *desc;
  } game;
};
 
/* Helpers for the OPID_TILE_VISION property. */
struct tile_vision_data {
  bv_player tile_known, tile_seen[V_COUNT];
};
const char *vision_layer_get_name(enum vision_layer);
 
#define PF_MAX_CLAUSES 16
#define PF_DISJUNCTION_SEPARATOR "|"
#define PF_CONJUNCTION_SEPARATOR "&"
 
struct pf_pattern {
  bool negate;
  char *text;
};
 
struct pf_conjunction {
  struct pf_pattern conjunction[PF_MAX_CLAUSES];
  int count;
};
 
struct property_filter {
  struct pf_conjunction disjunction[PF_MAX_CLAUSES];
  int count;
};
 
static struct property_filter *property_filter_new(const char *filter);
static bool property_filter_match(struct property_filter *pf,
                                  const struct objprop *op);
static void property_filter_free(struct property_filter *pf);
 
 
/****************************************************************************
  Object type declarations.
 
  To add a new object type:
  1. Add a value in enum editor_object_type in client/editor.h.
  2. Add a string name to objtype_get_name.
  3. Add code in objtype_get_id_from_object.
  4. Add code in objtype_get_object_from_id.
  5. Add a case handler in objtype_is_conserved, and if
     the object type is not conserved, then also in
     objbind_request_destroy_object and property_page_create_objects.
  6. Add an if-block in objbind_get_value_from_object.
  7. Add an if-block in objbind_get_allowed_value_span.
  9. Add a case handler in property_page_setup_objprops.
  10. Add a case handler in property_page_add_objbinds_from_tile
      if applicable.
 
  Furthermore, if the object type is to be editable:
  11. Define its edit packet in common/networking/packets.def.
  12. Add the packet handler in server/edithand.c.
  13. Add its edit packet type to union packetdata.
  14. Add an if-block in objbind_pack_current_values.
  15. Add an if-block in objbind_pack_modified_value.
  16. Add code in property_page_new_packet.
  17. Add code in property_page_send_packet.
  18. Add calls to editgui_notify_object_changed in
      client/packhand.c or where applicable.
 
****************************************************************************/
 
/* OBJTYPE_* enum values defined in client/editor.h */
 
static const char *objtype_get_name(enum editor_object_type objtype);
static int objtype_get_id_from_object(enum editor_object_type objtype,
                                      gpointer object);
static gpointer objtype_get_object_from_id(enum editor_object_type objtype,
                                           int id);
static bool objtype_is_conserved(enum editor_object_type objtype);
 
 
/****************************************************************************
  Value type declarations.
 
  To add a new value type:
  1. Add a value in enum value_types.
  2. Add its field in union propval_data.
  3. Add a case handler in valtype_get_name.
  4. Add a case handler in propval_copy if needed.
  5. Add a case handler in propval_free if needed.
  6. Add a case handler in propval_equal if needed.
  7. Add a case handler in objprop_get_gtype.
  8. Add a case handler in property_page_set_store_value.
  9. Add a case handler in propval_as_string if needed.
****************************************************************************/
enum value_types {
  VALTYPE_NONE = 0,
  VALTYPE_INT,
  VALTYPE_BOOL,
  VALTYPE_STRING,
  VALTYPE_PIXBUF,
  VALTYPE_BUILT_ARRAY,        /* struct built_status[B_LAST] */
  VALTYPE_INVENTIONS_ARRAY,   /* bool[A_LAST] */
  VALTYPE_BV_SPECIAL,
  VALTYPE_BV_ROADS,
  VALTYPE_BV_BASES,
  VALTYPE_NATION,
  VALTYPE_NATION_HASH,        /* struct nation_hash */
  VALTYPE_GOV,
  VALTYPE_TILE_VISION_DATA    /* struct tile_vision_data */
};
 
static const char *valtype_get_name(enum value_types valtype);
 
 
/****************************************************************************
  Propstate and propval declarations.
 
  To add a new member to union propval_data, see the steps for adding a
  new value type above.
 
  New property values are "constructed" by objbind_get_value_from_object().
****************************************************************************/
union propval_data {
  gpointer v_pointer;
  int v_int;
  bool v_bool;
  char *v_string;
  const char *v_const_string;
  GdkPixbuf *v_pixbuf;
  struct built_status *v_built;
  bv_max_extras v_bv_special;
  bv_max_extras v_bv_roads;
  bv_max_extras v_bv_bases;
  struct nation_type *v_nation;
  struct nation_hash *v_nation_hash;
  struct government *v_gov;
  bv_techs v_bv_inventions;
  struct tile_vision_data *v_tile_vision;
};
 
struct propval {
  union propval_data data;
  enum value_types valtype;
  bool must_free;
};
 
static void propval_free(struct propval *pv);
static void propval_free_data(struct propval *pv);
static struct propval *propval_copy(struct propval *pv);
static bool propval_equal(struct propval *pva, struct propval *pvb);
 
struct propstate {
  int property_id;
  struct propval *property_value;
};
 
static struct propstate *propstate_new(struct objprop *op,
                                       struct propval *pv);
static void propstate_destroy(struct propstate *ps);
static void propstate_clear_value(struct propstate *ps);
static void propstate_set_value(struct propstate *ps,
                                struct propval *pv);
static struct propval *propstate_get_value(struct propstate *ps);
 
#define SPECHASH_TAG propstate
#define SPECHASH_INT_KEY_TYPE
#define SPECHASH_IDATA_TYPE struct propstate *
#define SPECHASH_IDATA_FREE propstate_destroy
#include "spechash.h"
 
 
/****************************************************************************
  Objprop declarations.
 
  To add a new object property:
  1. Add a value in enum object_property_ids (grouped by
     object type).
  2. Define the property in property_page_setup_objprops.
  3. Add a case handler in objbind_get_value_from_object
     in the appropriate object type block.
  4. Add a case handler in objprop_setup_widget.
  5. Add a case handler in objprop_refresh_widget.
 
  Furthermore, if the property is editable:
  5. Add a field for this property in the edit
     packet for this object type in common/networking/packets.def.
  6. Add a case handler in objbind_pack_modified_value.
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  !!! 7. Add code to set the packet field in  !!!
  !!!    objbind_pack_current_values().       !!!
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  8. Add code to handle changes in the packet field in
     server/edithand.c handle_edit_<objtype>.
 
  If the property makes use of an extviewer:
  9. Handle widget creation in extviewer_new.
  10. Handle refresh in extviewer_refresh_widgets.
  11. Handle clear in extviewer_clear_widgets.
  12. Handle any signal callbacks (e.g. toggled) if needed.
 
  TODO: Add more object properties.
****************************************************************************/
enum object_property_ids {
  OPID_TILE_IMAGE,
  OPID_TILE_X,
  OPID_TILE_Y,
  OPID_TILE_NAT_X,
  OPID_TILE_NAT_Y,
  OPID_TILE_CONTINENT,
#ifdef FREECIV_DEBUG
  OPID_TILE_ADDRESS,
#endif /* FREECIV_DEBUG */
  OPID_TILE_TERRAIN,
  OPID_TILE_INDEX,
  OPID_TILE_XY,
  OPID_TILE_RESOURCE,
  OPID_TILE_SPECIALS,
  OPID_TILE_ROADS,
  OPID_TILE_BASES,
  OPID_TILE_VISION, /* tile_known and tile_seen */
  OPID_TILE_LABEL,
 
  OPID_STARTPOS_IMAGE,
  OPID_STARTPOS_XY,
  OPID_STARTPOS_EXCLUDE,
  OPID_STARTPOS_NATIONS,
 
  OPID_UNIT_IMAGE,
#ifdef FREECIV_DEBUG
  OPID_UNIT_ADDRESS,
#endif /* FREECIV_DEBUG */
  OPID_UNIT_TYPE,
  OPID_UNIT_ID,
  OPID_UNIT_XY,
  OPID_UNIT_MOVES_LEFT,
  OPID_UNIT_FUEL,
  OPID_UNIT_MOVED,
  OPID_UNIT_DONE_MOVING,
  OPID_UNIT_HP,
  OPID_UNIT_VETERAN,
  OPID_UNIT_STAY,
 
  OPID_CITY_IMAGE,
  OPID_CITY_NAME,
#ifdef FREECIV_DEBUG
  OPID_CITY_ADDRESS,
#endif /* FREECIV_DEBUG */
  OPID_CITY_ID,
  OPID_CITY_XY,
  OPID_CITY_SIZE,
  OPID_CITY_HISTORY,
  OPID_CITY_BUILDINGS,
  OPID_CITY_FOOD_STOCK,
  OPID_CITY_SHIELD_STOCK,
 
  OPID_PLAYER_NAME,
  OPID_PLAYER_NATION,
  OPID_PLAYER_GOV,
  OPID_PLAYER_AGE,
#ifdef FREECIV_DEBUG
  OPID_PLAYER_ADDRESS,
#endif /* FREECIV_DEBUG */
  OPID_PLAYER_INVENTIONS,
  OPID_PLAYER_SCENARIO_RESERVED,
  OPID_PLAYER_SELECT_WEIGHT,
  OPID_PLAYER_SCIENCE,
  OPID_PLAYER_GOLD,
  OPID_PLAYER_INFRAPOINTS,
 
  OPID_GAME_SCENARIO,
  OPID_GAME_SCENARIO_NAME,
  OPID_GAME_SCENARIO_AUTHORS,
  OPID_GAME_SCENARIO_DESC,
  OPID_GAME_SCENARIO_RANDSTATE,
  OPID_GAME_SCENARIO_PLAYERS,
  OPID_GAME_STARTPOS_NATIONS,
  OPID_GAME_PREVENT_CITIES,
  OPID_GAME_LAKE_FLOODING,
  OPID_GAME_RULESET_LOCKED
};
 
enum object_property_flags {
  OPF_NO_FLAGS    = 0,
  OPF_EDITABLE    = 1 << 0,
  OPF_IN_LISTVIEW = 1 << 1,
  OPF_HAS_WIDGET  = 1 << 2
};
 
struct objprop {
  int id;
  const char *name;
  const char *tooltip;
  enum object_property_flags flags;
  enum value_types valtype;
  int column_id;
  GtkTreeViewColumn *view_column;
  GtkWidget *widget;
  struct extviewer *extviewer;
  struct property_page *parent_page;
};
 
static struct objprop *objprop_new(int id,
                                   const char *name,
                                   const char *tooltip,
                                   enum object_property_flags flags,
                                   enum value_types valtype,
                                   struct property_page *parent);
static int objprop_get_id(const struct objprop *op);
static const char *objprop_get_name(const struct objprop *op);
static const char *objprop_get_tooltip(const struct objprop *op);
static enum value_types objprop_get_valtype(const struct objprop *op);
static struct property_page *
objprop_get_property_page(const struct objprop *op);
 
static bool objprop_show_in_listview(const struct objprop *op);
static bool objprop_is_sortable(const struct objprop *op);
static bool objprop_is_readonly(const struct objprop *op);
static bool objprop_has_widget(const struct objprop *op);
 
static GType objprop_get_gtype(const struct objprop *op);
static const char *objprop_get_attribute_type_string(const struct objprop *op);
static void objprop_set_column_id(struct objprop *op, int col_id);
static int objprop_get_column_id(const struct objprop *op);
static void objprop_set_treeview_column(struct objprop *op,
                                        GtkTreeViewColumn *col);
static GtkTreeViewColumn *objprop_get_treeview_column(const struct objprop *op);
static GtkCellRenderer *objprop_create_cell_renderer(const struct objprop *op);
 
static void objprop_setup_widget(struct objprop *op);
static GtkWidget *objprop_get_widget(struct objprop *op);
static void objprop_set_child_widget(struct objprop *op,
                                     const char *widget_name,
                                     GtkWidget *widget);
static GtkWidget *objprop_get_child_widget(struct objprop *op,
                                           const char *widget_name);
static void objprop_set_extviewer(struct objprop *op,
                                  struct extviewer *ev);
static struct extviewer *objprop_get_extviewer(struct objprop *op);
static void objprop_refresh_widget(struct objprop *op,
                                   struct objbind *ob);
static void objprop_widget_text_changed(GtkEditable *text, gpointer userdata);
static void objprop_widget_spin_button_changed(GtkSpinButton *spin,
                                               gpointer userdata);
static void objprop_widget_toggle_button_changed(GtkToggleButton *button,
                                                 gpointer userdata);
 
#define SPECHASH_TAG objprop
#define SPECHASH_INT_KEY_TYPE
#define SPECHASH_IDATA_TYPE struct objprop *
#include "spechash.h"
 
 
/****************************************************************************
  Objbind declarations.
****************************************************************************/
struct objbind {
  enum editor_object_type objtype;
  int object_id;
  struct property_page *parent_property_page;
  struct propstate_hash *propstate_table;
  GtkTreeRowReference *rowref;
};
 
static struct objbind *objbind_new(enum editor_object_type objtype,
                                   gpointer object);
static void objbind_destroy(struct objbind *ob);
static enum editor_object_type objbind_get_objtype(const struct objbind *ob);
static void objbind_bind_properties(struct objbind *ob,
                                    struct property_page *pp);
static gpointer objbind_get_object(struct objbind *ob);
static int objbind_get_object_id(struct objbind *ob);
static void objbind_request_destroy_object(struct objbind *ob);
static struct propval *objbind_get_value_from_object(struct objbind *ob,
                                                     struct objprop *op);
static bool objbind_get_allowed_value_span(struct objbind *ob,
                                           struct objprop *op,
                                           double *pmin,
                                           double *pmax,
                                           double *pstep,
                                           double *pbig_step);
static bool objbind_set_modified_value(struct objbind *ob,
                                       struct objprop *op,
                                       struct propval *pv);
static struct propval *objbind_get_modified_value(struct objbind *ob,
                                                  struct objprop *op);
static void objbind_clear_modified_value(struct objbind *ob,
                                         struct objprop *op);
static bool objbind_property_is_modified(struct objbind *ob,
                                         struct objprop *op);
static bool objbind_has_modified_properties(struct objbind *ob);
static void objbind_clear_all_modified_values(struct objbind *ob);
static void objbind_pack_current_values(struct objbind *ob,
                                        union packetdata packet);
static void objbind_pack_modified_value(struct objbind *ob,
                                        struct objprop *op,
                                        union packetdata packet);
static void objbind_set_rowref(struct objbind *ob,
                               GtkTreeRowReference *rr);
static GtkTreeRowReference *objbind_get_rowref(struct objbind *ob);
 
#define SPECHASH_TAG objbind
#define SPECHASH_INT_KEY_TYPE
#define SPECHASH_IDATA_TYPE struct objbind *
#define SPECHASH_IDATA_FREE objbind_destroy
#include "spechash.h"
 
 
/****************************************************************************
  Extended property viewer declarations. This is a set of widgets used
  for viewing and/or editing properties with complex values (e.g. arrays).
****************************************************************************/
struct extviewer {
  struct objprop *objprop;
  struct propval *pv_cached;
 
  GtkWidget *panel_widget;
  GtkWidget *panel_label;
  GtkWidget *panel_button;
  GtkWidget *panel_image;
 
  GtkWidget *view_widget;
  GtkWidget *view_label;
 
  GtkListStore *store;
  GtkTextBuffer *textbuf;
};
 
static struct extviewer *extviewer_new(struct objprop *op);
static struct objprop *extviewer_get_objprop(struct extviewer *ev);
static GtkWidget *extviewer_get_panel_widget(struct extviewer *ev);
static GtkWidget *extviewer_get_view_widget(struct extviewer *ev);
static void extviewer_refresh_widgets(struct extviewer *ev,
                                      struct propval *pv);
static void extviewer_clear_widgets(struct extviewer *ev);
static void extviewer_panel_button_clicked(GtkButton *button,
                                           gpointer userdata);
static void extviewer_view_cell_toggled(GtkCellRendererToggle *cell,
                                        gchar *path,
                                        gpointer userdata);
static void extviewer_textbuf_changed(GtkTextBuffer *textbuf,
                                      gpointer userdata);
 
 
/****************************************************************************
  Property page declarations.
****************************************************************************/
struct property_page {
  enum editor_object_type objtype;
 
  GtkWidget *widget;
  GtkListStore *object_store;
  GtkWidget *object_view;
  GtkWidget *extviewer_notebook;
 
  struct property_editor *pe_parent;
 
  struct objprop_hash *objprop_table;
  struct objbind_hash *objbind_table;
  struct stored_tag_hash *tag_table;
 
  struct objbind *focused_objbind;
};
 
static struct property_page *
property_page_new(enum editor_object_type objtype,
                  struct property_editor *parent);
static void property_page_setup_objprops(struct property_page *pp);
static const char *property_page_get_name(const struct property_page *pp);
static enum editor_object_type
property_page_get_objtype(const struct property_page *pp);
static void property_page_load_tiles(struct property_page *pp,
                                     const struct tile_list *tiles);
static void property_page_add_objbinds_from_tile(struct property_page *pp,
                                                 const struct tile *ptile);
static int property_page_get_num_objbinds(const struct property_page *pp);
static void property_page_clear_objbinds(struct property_page *pp);
static void property_page_add_objbind(struct property_page *pp,
                                      gpointer object_data);
static void property_page_fill_widgets(struct property_page *pp);
static struct objbind *
property_page_get_focused_objbind(struct property_page *pp);
static void property_page_set_focused_objbind(struct property_page *pp,
                                              struct objbind *ob);
static struct objbind *property_page_get_objbind(struct property_page *pp,
                                                 int object_id);
static void property_page_selection_changed(GtkTreeSelection *sel,
                                            gpointer userdata);
static gboolean property_page_selection_func(GtkTreeSelection *sel,
                                             GtkTreeModel *model,
                                             GtkTreePath *path,
                                             gboolean currently_selected,
                                             gpointer data);
static void property_page_quick_find_entry_changed(GtkWidget *entry,
                                                   gpointer userdata);
static void property_page_change_value(struct property_page *pp,
                                       struct objprop *op,
                                       struct propval *pv);
static void property_page_send_values(struct property_page *pp);
static void property_page_reset_objbinds(struct property_page *pp);
static void property_page_destroy_objects(struct property_page *pp);
static void property_page_create_objects(struct property_page *pp,
                                         struct tile_list *hint_tiles);
static union packetdata property_page_new_packet(struct property_page *pp);
static void property_page_send_packet(struct property_page *pp,
                                      union packetdata packet);
static void property_page_free_packet(struct property_page *pp,
                                      union packetdata packet);
static void property_page_object_changed(struct property_page *pp,
                                         int object_id,
                                         bool remove);
static void property_page_object_created(struct property_page *pp,
                                         int tag, int object_id);
static void property_page_add_extviewer(struct property_page *pp,
                                        struct extviewer *ev);
static void property_page_show_extviewer(struct property_page *pp,
                                         struct extviewer *ev);
static void property_page_store_creation_tag(struct property_page *pp,
                                             int tag, int count);
static void property_page_remove_creation_tag(struct property_page *pp,
                                              int tag);
static bool property_page_tag_is_known(struct property_page *pp, int tag);
static void property_page_clear_tags(struct property_page *pp);
static void property_page_apply_button_clicked(GtkButton *button,
                                               gpointer userdata);
static void property_page_refresh_button_clicked(GtkButton *button,
                                                 gpointer userdata);
static void property_page_create_button_clicked(GtkButton *button,
                                                gpointer userdata);
static void property_page_destroy_button_clicked(GtkButton *button,
                                                 gpointer userdata);
 
 
#define property_page_objprop_iterate(ARG_pp, NAME_op)                      \
  TYPED_HASH_DATA_ITERATE(struct objprop *, (ARG_pp)->objprop_table, NAME_op)
#define property_page_objprop_iterate_end HASH_DATA_ITERATE_END
 
#define property_page_objbind_iterate(ARG_pp, NAME_ob)                      \
  TYPED_HASH_DATA_ITERATE(struct objbind *, (ARG_pp)->objbind_table, NAME_ob)
#define property_page_objbind_iterate_end HASH_DATA_ITERATE_END
 
 
/****************************************************************************
  Property editor declarations.
****************************************************************************/
struct property_editor {
  GtkWidget *widget;
  GtkWidget *notebook;
 
  struct property_page *property_pages[NUM_OBJTYPES];
};
 
static struct property_editor *property_editor_new(void);
static bool property_editor_add_page(struct property_editor *pe,
                                     enum editor_object_type objtype);
static struct property_page *
property_editor_get_page(struct property_editor *pe,
                         enum editor_object_type objtype);
 
static struct property_editor *the_property_editor;
 
 
/************************************************************************/
static const char *objtype_get_name(enum editor_object_type objtype)
{
  switch (objtype) {
  case OBJTYPE_TILE:
    return _("Tile");
  case OBJTYPE_STARTPOS:
    return _("Start Position");
  case OBJTYPE_UNIT:
    return _("Unit");
  case OBJTYPE_CITY:
    return _("City");
  case OBJTYPE_PLAYER:
    return _("Player");
  case OBJTYPE_GAME:
    return Q_("?play:Game");
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s() Unhandled request to get name of object type %d.",
            __FUNCTION__, objtype);
  return "Unknown";
}
 
/************************************************************************/
static int objtype_get_id_from_object(enum editor_object_type objtype,
                                      gpointer object)
{
  switch (objtype) {
  case OBJTYPE_TILE:
    return tile_index((struct tile *) object);
  case OBJTYPE_STARTPOS:
    return startpos_number((struct startpos *) object);
  case OBJTYPE_UNIT:
    return ((struct unit *) object)->id;
  case OBJTYPE_CITY:
    return ((struct city *) object)->id;
  case OBJTYPE_PLAYER:
    return player_number((struct player *) object);
  case OBJTYPE_GAME:
    return 1;
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request to get object ID from object %p of "
            "type %d (%s).", __FUNCTION__, object, objtype,
            objtype_get_name(objtype));
  return -1;
}
 
/************************************************************************/
static gpointer objtype_get_object_from_id(enum editor_object_type objtype,
                                           int id)
{
  switch (objtype) {
  case OBJTYPE_TILE:
    return index_to_tile(&(wld.map), id);
  case OBJTYPE_STARTPOS:
    return map_startpos_by_number(id);
  case OBJTYPE_UNIT:
    return game_unit_by_number(id);
  case OBJTYPE_CITY:
    return game_city_by_number(id);
  case OBJTYPE_PLAYER:
    return player_by_number(id);
  case OBJTYPE_GAME:
    return &game;
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request to get object of type %d (%s) "
            "with ID %d.", __FUNCTION__, objtype,
            objtype_get_name(objtype), id);
  return NULL;
}
 
/************************************************************************/
static bool objtype_is_conserved(enum editor_object_type objtype)
{
  switch (objtype) {
  case OBJTYPE_TILE:
  case OBJTYPE_GAME:
    return TRUE;
  case OBJTYPE_STARTPOS:
  case OBJTYPE_UNIT:
  case OBJTYPE_CITY:
  case OBJTYPE_PLAYER:
    return FALSE;
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request for object type %d (%s)).",
            __FUNCTION__, objtype, objtype_get_name(objtype));
  return TRUE;
}
 
/************************************************************************/
static const char *valtype_get_name(enum value_types valtype)
{
  switch (valtype) {
  case VALTYPE_NONE:
    return "none";
  case VALTYPE_STRING:
    return "string";
  case VALTYPE_INT:
    return "int";
  case VALTYPE_BOOL:
    return "bool";
  case VALTYPE_PIXBUF:
    return "pixbuf";
  case VALTYPE_BUILT_ARRAY:
    return "struct built_status[B_LAST]";
  case VALTYPE_INVENTIONS_ARRAY:
    return "bool[A_LAST]";
  case VALTYPE_BV_SPECIAL:
    return "bv_special";
  case VALTYPE_BV_ROADS:
    return "bv_roads";
  case VALTYPE_BV_BASES:
    return "bv_bases";
  case VALTYPE_NATION:
    return "nation";
  case VALTYPE_NATION_HASH:
    return "struct nation_hash";
  case VALTYPE_GOV:
    return "government";
  case VALTYPE_TILE_VISION_DATA:
    return "struct tile_vision_data";
  }
 
  log_error("%s(): unhandled value type %d.", __FUNCTION__, valtype);
  return "void";
}
 
/************************************************************************/
static void add_column(GtkWidget *view,
                       int col_id,
                       const char *name,
                       GType gtype,
                       bool editable,
                       bool is_radio,
                       GCallback edit_callback,
                       gpointer userdata)
{
  GtkCellRenderer *cell;
  GtkTreeViewColumn *col;
  const char *attr = NULL;
 
  if (gtype == G_TYPE_BOOLEAN) {
    cell = gtk_cell_renderer_toggle_new();
    gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell),
                                       is_radio);
    if (editable) {
      g_signal_connect(cell, "toggled", edit_callback, userdata);
    }
    attr = "active";
  } else if (gtype == GDK_TYPE_PIXBUF) {
    cell = gtk_cell_renderer_pixbuf_new();
    attr = "pixbuf";
  } else {
    cell = gtk_cell_renderer_text_new();
    if (editable) {
      g_object_set(cell, "editable", TRUE, NULL);
      g_signal_connect(cell, "edited", edit_callback, userdata);
    }
    attr = "text";
  }
 
  col = gtk_tree_view_column_new_with_attributes(name, cell,
                                                 attr, col_id, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
}
 
/************************************************************************/
static gchar *propval_as_string(struct propval *pv)
{
  int count = 0;
 
  fc_assert_ret_val(NULL != pv, 0);
 
  switch (pv->valtype) {
  case VALTYPE_NONE:
    return g_strdup("");
 
  case VALTYPE_INT:
    return g_strdup_printf("%d", pv->data.v_int);
 
  case VALTYPE_BOOL:
    return g_strdup_printf("%s", pv->data.v_bool ? _("TRUE") : _("FALSE"));
 
  case VALTYPE_NATION:
    return g_strdup_printf("%s", nation_adjective_translation(pv->data.v_nation));
 
  case VALTYPE_GOV:
    if (pv->data.v_gov != NULL) {
      return g_strdup_printf("%s", government_name_translation(pv->data.v_gov));
    } else {
      return g_strdup_printf("%s", government_name_translation(game.government_during_revolution));
    }
 
  case VALTYPE_BUILT_ARRAY:
    {
      int great_wonder_count = 0, small_wonder_count = 0, building_count = 0;
      int id;
 
      improvement_iterate(pimprove) {
        id = improvement_index(pimprove);
        if (pv->data.v_built[id].turn < 0) {
          continue;
        }
        if (is_great_wonder(pimprove)) {
          great_wonder_count++;
        } else if (is_small_wonder(pimprove)) {
          small_wonder_count++;
        } else {
          building_count++;
        }
      } improvement_iterate_end;
      /* TRANS: "Number of buildings, number of small
       * wonders (e.g. palace), number of great wonders." */
      return g_strdup_printf(_("%db %ds %dW"),
                             building_count, small_wonder_count,
                             great_wonder_count);
    }
 
  case VALTYPE_INVENTIONS_ARRAY:
    advance_index_iterate(A_FIRST, tech) {
      if (BV_ISSET(pv->data.v_bv_inventions, tech)) {
        count++;
      }
    } advance_index_iterate_end;
    /* TRANS: "Number of technologies known". */
    return g_strdup_printf(_("%d known"), count);
 
  case VALTYPE_BV_SPECIAL:
    extra_type_by_cause_iterate(EC_SPECIAL, spe) {
      if (BV_ISSET(pv->data.v_bv_special, spe->data.special_idx)) {
        count++;
      }
    } extra_type_by_cause_iterate_end;
    /* TRANS: "The number of terrain specials (e.g. hut,
     * river, pollution, etc.) present on a tile." */
    return g_strdup_printf(_("%d present"), count);
 
  case VALTYPE_BV_ROADS:
    extra_type_by_cause_iterate(EC_ROAD, pextra) {
      struct road_type *proad = extra_road_get(pextra);
 
      if (BV_ISSET(pv->data.v_bv_roads, road_number(proad))) {
        count++;
      }
    } extra_type_by_cause_iterate_end;
    return g_strdup_printf(_("%d present"), count);
 
  case VALTYPE_BV_BASES:
    extra_type_by_cause_iterate(EC_BASE, pextra) {
      struct base_type *pbase = extra_base_get(pextra);
 
      if (BV_ISSET(pv->data.v_bv_bases, base_number(pbase))) {
        count++;
      }
    } extra_type_by_cause_iterate_end;
    return g_strdup_printf(_("%d present"), count);
 
  case VALTYPE_NATION_HASH:
    count = nation_hash_size(pv->data.v_nation_hash);
    if (0 == count) {
      return g_strdup(_("All nations"));
    } else {
      return g_strdup_printf(PL_("%d nation", "%d nations",
                                 count), count);
    }
 
  case VALTYPE_STRING:
    /* Assume it is a very long string. */
    count = strlen(pv->data.v_const_string);
    return g_strdup_printf(PL_("%d byte", "%d bytes", count),
                           count);
 
  case VALTYPE_PIXBUF:
  case VALTYPE_TILE_VISION_DATA:
    break;
  }
 
  log_error("%s(): Unhandled value type %d for property value %p.",
            __FUNCTION__, pv->valtype, pv);
  return g_strdup("");
}
 
/************************************************************************/
static gchar *built_status_to_string(struct built_status *bs)
{
  int turn_built;
 
  turn_built = bs->turn;
 
  if (turn_built == I_NEVER) {
    /* TRANS: Improvement never built. */
    return g_strdup(_("(never)"));
  } else if (turn_built == I_DESTROYED) {
    /* TRANS: Improvement was destroyed. */
    return g_strdup(_("(destroyed)"));
  } else {
    return g_strdup_printf("%d", turn_built);
  }
}
 
/************************************************************************/
static bool can_create_unit_at_tile(struct tile *ptile)
{
  struct unit *vunit;
  struct city *pcity;
  struct player *pplayer;
  bool ret;
 
  if (!ptile) {
    return FALSE;
  }
 
  vunit = editor_unit_virtual_create();
  if (!vunit) {
    return FALSE;
  }
 
  pcity = tile_city(ptile);
  pplayer = unit_owner(vunit);
 
  ret = (can_unit_exist_at_tile(&(wld.map), vunit, ptile)
         && !is_non_allied_unit_tile(ptile, pplayer,
                                     unit_has_type_flag(vunit, UTYF_FLAGLESS))
         && (pcity == NULL
             || pplayers_allied(city_owner(pcity),
                                unit_owner(vunit))));
  free(vunit);
 
  return ret;
}
 
/************************************************************************/
static int get_next_unique_tag(void)
{
  static int tag_series = 0;
 
  tag_series++;
  return tag_series;
}
 
/************************************************************************/
static struct propval *propval_copy(struct propval *pv)
{
  struct propval *pv_copy;
  size_t size;
 
  if (!pv) {
    return NULL;
  }
 
  pv_copy = fc_calloc(1, sizeof(*pv));
  pv_copy->valtype = pv->valtype;
 
  switch (pv->valtype) {
  case VALTYPE_NONE:
    return pv_copy;
  case VALTYPE_INT:
    pv_copy->data.v_int = pv->data.v_int;
    return pv_copy;
  case VALTYPE_BOOL:
    pv_copy->data.v_bool = pv->data.v_bool;
    return pv_copy;
  case VALTYPE_STRING:
    pv_copy->data.v_string = fc_strdup(pv->data.v_string);
    pv_copy->must_free = TRUE;
    return pv_copy;
  case VALTYPE_PIXBUF:
    g_object_ref(pv->data.v_pixbuf);
    pv_copy->data.v_pixbuf = pv->data.v_pixbuf;
    pv_copy->must_free = TRUE;
    return pv_copy;
  case VALTYPE_BUILT_ARRAY:
    size = B_LAST * sizeof(struct built_status);
    pv_copy->data.v_pointer = fc_malloc(size);
    memcpy(pv_copy->data.v_pointer, pv->data.v_pointer, size);
    pv_copy->must_free = TRUE;
    return pv_copy;
  case VALTYPE_BV_SPECIAL:
    pv_copy->data.v_bv_special = pv->data.v_bv_special;
    return pv_copy;
  case VALTYPE_BV_ROADS:
    pv_copy->data.v_bv_roads = pv->data.v_bv_roads;
    return pv_copy;
  case VALTYPE_BV_BASES:
    pv_copy->data.v_bv_bases = pv->data.v_bv_bases;
    return pv_copy;
  case VALTYPE_NATION:
    pv_copy->data.v_nation = pv->data.v_nation;
    return pv_copy;
  case VALTYPE_GOV:
    pv_copy->data.v_gov = pv->data.v_gov;
    return pv_copy;
  case VALTYPE_NATION_HASH:
    pv_copy->data.v_nation_hash
      = nation_hash_copy(pv->data.v_nation_hash);
    pv_copy->must_free = TRUE;
    return pv_copy;
  case VALTYPE_INVENTIONS_ARRAY:
    pv_copy->data.v_bv_inventions = pv->data.v_bv_inventions;
    return pv_copy;
  case VALTYPE_TILE_VISION_DATA:
    size = sizeof(struct tile_vision_data);
    pv_copy->data.v_tile_vision = fc_malloc(size);
    pv_copy->data.v_tile_vision->tile_known
      = pv->data.v_tile_vision->tile_known;
    vision_layer_iterate(v) {
      pv_copy->data.v_tile_vision->tile_seen[v]
        = pv->data.v_tile_vision->tile_seen[v];
    } vision_layer_iterate_end;
    pv_copy->must_free = TRUE;
    return pv_copy;
  }
 
  log_error("%s(): Unhandled value type %d for property value %p.",
            __FUNCTION__, pv->valtype, pv);
  pv_copy->data = pv->data;
  return pv_copy;
}
 
/************************************************************************/
static void propval_free(struct propval *pv)
{
  if (!pv) {
    return;
  }
 
  propval_free_data(pv);
  free(pv);
}
 
/************************************************************************/
static void propval_free_data(struct propval *pv)
{
  if (!pv || !pv->must_free) {
    return;
  }
 
  switch (pv->valtype) {
  case VALTYPE_NONE:
  case VALTYPE_INT:
  case VALTYPE_BOOL:
  case VALTYPE_BV_SPECIAL:
  case VALTYPE_BV_ROADS:
  case VALTYPE_BV_BASES:
  case VALTYPE_NATION:
  case VALTYPE_GOV:
    return;
  case VALTYPE_PIXBUF:
    g_object_unref(pv->data.v_pixbuf);
    return;
  case VALTYPE_STRING:
  case VALTYPE_BUILT_ARRAY:
  case VALTYPE_INVENTIONS_ARRAY:
  case VALTYPE_TILE_VISION_DATA:
    free(pv->data.v_pointer);
    return;
  case VALTYPE_NATION_HASH:
    nation_hash_destroy(pv->data.v_nation_hash);
    return;
  }
 
  log_error("%s(): Unhandled request to free data %p (type %s).",
            __FUNCTION__, pv->data.v_pointer, valtype_get_name(pv->valtype));
}
 
/************************************************************************/
static bool propval_equal(struct propval *pva,
                          struct propval *pvb)
{
  if (!pva || !pvb) {
    return pva == pvb;
  }
 
  if (pva->valtype != pvb->valtype) {
    return FALSE;
  }
 
  switch (pva->valtype) {
  case VALTYPE_NONE:
    return TRUE;
  case VALTYPE_INT:
    return pva->data.v_int == pvb->data.v_int;
  case VALTYPE_BOOL:
    return pva->data.v_bool == pvb->data.v_bool;
  case VALTYPE_STRING:
    if (pva->data.v_const_string != NULL
        && pvb->data.v_const_string != NULL) {
      return !strcmp(pva->data.v_const_string,
                     pvb->data.v_const_string);
    }
    return pva->data.v_const_string == pvb->data.v_const_string;
  case VALTYPE_PIXBUF:
    return pva->data.v_pixbuf == pvb->data.v_pixbuf;
  case VALTYPE_BUILT_ARRAY:
    if (pva->data.v_pointer == pvb->data.v_pointer) {
      return TRUE;
    } else if (!pva->data.v_pointer || !pvb->data.v_pointer) {
      return FALSE;
    }
 
    improvement_iterate(pimprove) {
      int id, vatb, vbtb;
 
      id = improvement_index(pimprove);
      vatb = pva->data.v_built[id].turn;
      vbtb = pvb->data.v_built[id].turn;
      if (vatb < 0 && vbtb < 0) {
        continue;
      }
      if (vatb != vbtb) {
        return FALSE;
      }
    } improvement_iterate_end;
    return TRUE;
  case VALTYPE_INVENTIONS_ARRAY:
    return BV_ARE_EQUAL(pva->data.v_bv_inventions, pvb->data.v_bv_inventions);
  case VALTYPE_BV_SPECIAL:
    return BV_ARE_EQUAL(pva->data.v_bv_special, pvb->data.v_bv_special);
  case VALTYPE_BV_ROADS:
    return BV_ARE_EQUAL(pva->data.v_bv_roads, pvb->data.v_bv_roads);
  case VALTYPE_BV_BASES:
    return BV_ARE_EQUAL(pva->data.v_bv_bases, pvb->data.v_bv_bases);
  case VALTYPE_NATION:
    return pva->data.v_nation == pvb->data.v_nation;
  case VALTYPE_NATION_HASH:
    return nation_hashes_are_equal(pva->data.v_nation_hash,
                                   pvb->data.v_nation_hash);
  case VALTYPE_GOV:
    return pva->data.v_gov == pvb->data.v_gov;
  case VALTYPE_TILE_VISION_DATA:
    if (!BV_ARE_EQUAL(pva->data.v_tile_vision->tile_known,
                      pvb->data.v_tile_vision->tile_known)) {
      return FALSE;
    }
    vision_layer_iterate(v) {
      if (!BV_ARE_EQUAL(pva->data.v_tile_vision->tile_seen[v],
                        pvb->data.v_tile_vision->tile_seen[v])) {
        return FALSE;
      }
    } vision_layer_iterate_end;
    return TRUE;
  }
 
  log_error("%s(): Unhandled value type %d for property values %p and %p.",
            __FUNCTION__, pva->valtype, pva, pvb);
  return pva->data.v_pointer == pvb->data.v_pointer;
}
 
/************************************************************************/
static struct propstate *propstate_new(struct objprop *op,
                                       struct propval *pv)
{
  struct propstate *ps;
 
  if (!op) {
    return NULL;
  }
 
  ps = fc_calloc(1, sizeof(*ps));
  ps->property_id = objprop_get_id(op);
  ps->property_value = pv;
 
  return ps;
}
 
/************************************************************************/
static void propstate_clear_value(struct propstate *ps)
{
  if (!ps) {
    return;
  }
 
  propval_free(ps->property_value);
  ps->property_value = NULL;
}
 
/************************************************************************/
static void propstate_destroy(struct propstate *ps)
{
  if (!ps) {
    return;
  }
  propstate_clear_value(ps);
  free(ps);
}
 
/************************************************************************/
static void propstate_set_value(struct propstate *ps,
                                struct propval *pv)
{
  if (!ps) {
    return;
  }
  propstate_clear_value(ps);
  ps->property_value = pv;
}
 
/************************************************************************/
static struct propval *propstate_get_value(struct propstate *ps)
{
  if (!ps) {
    return NULL;
  }
  return ps->property_value;
}
 
/************************************************************************/
static struct objbind *objbind_new(enum editor_object_type objtype,
                                   gpointer object)
{
  struct objbind *ob;
  int id;
 
  if (object == NULL) {
    return NULL;
  }
 
  id = objtype_get_id_from_object(objtype, object);
  if (id < 0) {
    return NULL;
  }
 
  ob = fc_calloc(1, sizeof(*ob));
  ob->object_id = id;
  ob->objtype = objtype;
  ob->propstate_table = propstate_hash_new();
 
  return ob;
}
 
/************************************************************************/
static gpointer objbind_get_object(struct objbind *ob)
{
  int id;
 
  if (!ob) {
    return NULL;
  }
 
  id = objbind_get_object_id(ob);
 
  return objtype_get_object_from_id(ob->objtype, id);
}
 
/************************************************************************/
static int objbind_get_object_id(struct objbind *ob)
{
  if (NULL == ob) {
    return -1;
  }
  return ob->object_id;
}
 
/************************************************************************/
static void objbind_request_destroy_object(struct objbind *ob)
{
  struct connection *my_conn = &client.conn;
  enum editor_object_type objtype;
  int id;
 
  if (!ob) {
    return;
  }
 
  objtype = objbind_get_objtype(ob);
  if (objtype_is_conserved(objtype)) {
    return;
  }
 
  id = objbind_get_object_id(ob);
 
  switch (objtype) {
  case OBJTYPE_STARTPOS:
    dsend_packet_edit_startpos(my_conn, id, TRUE, 0);
    return;
  case OBJTYPE_UNIT:
    dsend_packet_edit_unit_remove_by_id(my_conn, id);
    return;
  case OBJTYPE_CITY:
    dsend_packet_edit_city_remove(my_conn, id);
    return;
  case OBJTYPE_PLAYER:
    dsend_packet_edit_player_remove(my_conn, id);
    return;
  case OBJTYPE_TILE:
  case OBJTYPE_GAME:
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request to destroy object %p (ID %d) of type "
            "%d (%s).", __FUNCTION__, objbind_get_object(ob), id, objtype,
            objtype_get_name(objtype));
}
 
/************************************************************************/
static struct propval *objbind_get_value_from_object(struct objbind *ob,
                                                     struct objprop *op)
{
  enum editor_object_type objtype;
  enum object_property_ids propid;
  struct propval *pv;
 
  if (!ob || !op) {
    return NULL;
  }
 
  objtype = objbind_get_objtype(ob);
  propid = objprop_get_id(op);
 
  pv = fc_calloc(1, sizeof(*pv));
  pv->valtype = objprop_get_valtype(op);
 
  switch (objtype) {
  case OBJTYPE_TILE:
    {
      const struct tile *ptile = objbind_get_object(ob);
      int tile_x, tile_y, nat_x, nat_y;
 
      if (NULL == ptile) {
        goto FAILED;
      }
 
      index_to_map_pos(&tile_x, &tile_y, tile_index(ptile));
      index_to_native_pos(&nat_x, &nat_y, tile_index(ptile));
 
      switch (propid) {
      case OPID_TILE_IMAGE:
        pv->data.v_pixbuf = create_tile_pixbuf(ptile);
        pv->must_free = TRUE;
        break;
#ifdef FREECIV_DEBUG
      case OPID_TILE_ADDRESS:
        pv->data.v_string = g_strdup_printf("%p", ptile);
        pv->must_free = TRUE;
        break;
#endif /* FREECIV_DEBUG */
      case OPID_TILE_TERRAIN:
        {
          const struct terrain *pterrain = tile_terrain(ptile);
 
          if (NULL != pterrain) {
            pv->data.v_const_string = terrain_name_translation(pterrain);
          } else {
            pv->data.v_const_string = "";
          }
        }
        break;
      case OPID_TILE_RESOURCE:
        {
          const struct extra_type *presource = tile_resource(ptile);
 
          if (NULL != presource) {
            pv->data.v_const_string = extra_name_translation(presource);
          } else {
            pv->data.v_const_string = "";
          }
        }
        break;
      case OPID_TILE_XY:
        pv->data.v_string = g_strdup_printf("(%d, %d)", tile_x, tile_y);
        pv->must_free = TRUE;
        break;
      case OPID_TILE_INDEX:
        pv->data.v_int = tile_index(ptile);
        break;
      case OPID_TILE_X:
        pv->data.v_int = tile_x;
        break;
      case OPID_TILE_Y:
        pv->data.v_int = tile_y;
        break;
      case OPID_TILE_NAT_X:
        pv->data.v_int = nat_x;
        break;
      case OPID_TILE_NAT_Y:
        pv->data.v_int = nat_y;
        break;
      case OPID_TILE_CONTINENT:
        pv->data.v_int = ptile->continent;
        break;
      case OPID_TILE_SPECIALS:
        BV_CLR_ALL(pv->data.v_bv_special);
        extra_type_by_cause_iterate(EC_SPECIAL, pextra) {
          if (tile_has_extra(ptile, pextra)) {
            BV_SET(pv->data.v_bv_special, pextra->data.special_idx);
          }
        } extra_type_by_cause_iterate_end;
        break;
      case OPID_TILE_ROADS:
        BV_CLR_ALL(pv->data.v_bv_roads);
        extra_type_by_cause_iterate(EC_ROAD, pextra) {
          if (tile_has_extra(ptile, pextra)) {
            BV_SET(pv->data.v_bv_roads, road_number(extra_road_get(pextra)));
          }
        } extra_type_by_cause_iterate_end;
        break;
      case OPID_TILE_BASES:
        BV_CLR_ALL(pv->data.v_bv_bases);
        extra_type_by_cause_iterate(EC_BASE, pextra) {
          if (tile_has_extra(ptile, pextra)) {
            BV_SET(pv->data.v_bv_bases, base_number(extra_base_get(pextra)));
          }
        } extra_type_by_cause_iterate_end;
        break;
      case OPID_TILE_VISION:
        pv->data.v_tile_vision = fc_malloc(sizeof(struct tile_vision_data));
 
        /* The server saves the known tiles and the player vision in special
         * bitvectors with the number of tiles as index. Here we want the
         * information for one tile. Thus, the data is transformed to
         * bitvectors with the number of player slots as index. */
        BV_CLR_ALL(pv->data.v_tile_vision->tile_known);
        players_iterate(pplayer) {
          if (dbv_isset(&pplayer->tile_known, tile_index(ptile))) {
            BV_SET(pv->data.v_tile_vision->tile_known,
                   player_index(pplayer));
          }
        } players_iterate_end;
 
        vision_layer_iterate(v) {
          BV_CLR_ALL(pv->data.v_tile_vision->tile_seen[v]);
          players_iterate(pplayer) {
            if (fc_funcs->player_tile_vision_get(ptile, pplayer, v)) {
              BV_SET(pv->data.v_tile_vision->tile_seen[v],
                     player_index(pplayer));
            }
          } players_iterate_end;
        } vision_layer_iterate_end;
        pv->must_free = TRUE;
        break;
      case OPID_TILE_LABEL:
        if (ptile->label != NULL) {
          pv->data.v_const_string = ptile->label;
        } else {
          pv->data.v_const_string = "";
        }
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case OBJTYPE_STARTPOS:
    {
      const struct startpos *psp = objbind_get_object(ob);
      const struct tile *ptile;
 
      if (NULL == psp) {
        goto FAILED;
      }
 
      switch (propid) {
      case OPID_STARTPOS_IMAGE:
        ptile = startpos_tile(psp);
        pv->data.v_pixbuf = create_tile_pixbuf(ptile);
        pv->must_free = TRUE;
        break;
      case OPID_STARTPOS_XY:
        ptile = startpos_tile(psp);
        pv->data.v_string = g_strdup_printf("(%d, %d)", TILE_XY(ptile));
        pv->must_free = TRUE;
        break;
      case OPID_STARTPOS_EXCLUDE:
        pv->data.v_bool = startpos_is_excluding(psp);
        break;
      case OPID_STARTPOS_NATIONS:
        pv->data.v_nation_hash = nation_hash_copy(startpos_raw_nations(psp));
        pv->must_free = TRUE;
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case OBJTYPE_UNIT:
    {
      struct unit *punit = objbind_get_object(ob);
 
      if (NULL == punit) {
        goto FAILED;
      }
 
      switch (propid) {
      case OPID_UNIT_IMAGE:
        pv->data.v_pixbuf = create_unit_pixbuf(punit);
        pv->must_free = TRUE;
        break;
#ifdef FREECIV_DEBUG
      case OPID_UNIT_ADDRESS:
        pv->data.v_string = g_strdup_printf("%p", punit);
        pv->must_free = TRUE;
        break;
#endif /* FREECIV_DEBUG */
      case OPID_UNIT_XY:
        {
          const struct tile *ptile = unit_tile(punit);
 
          pv->data.v_string = g_strdup_printf("(%d, %d)", TILE_XY(ptile));
          pv->must_free = TRUE;
        }
        break;
      case OPID_UNIT_ID:
        pv->data.v_int = punit->id;
        break;
      case OPID_UNIT_TYPE:
        {
          const struct unit_type *putype = unit_type_get(punit);
 
          pv->data.v_const_string = utype_name_translation(putype);
        }
        break;
      case OPID_UNIT_MOVES_LEFT:
        pv->data.v_int = punit->moves_left;
        break;
      case OPID_UNIT_FUEL:
        pv->data.v_int = punit->fuel;
        break;
      case OPID_UNIT_MOVED:
        pv->data.v_bool = punit->moved;
        break;
      case OPID_UNIT_DONE_MOVING:
        pv->data.v_bool = punit->done_moving;
        break;
      case OPID_UNIT_HP:
        pv->data.v_int = punit->hp;
        break;
      case OPID_UNIT_VETERAN:
        pv->data.v_int = punit->veteran;
        break;
      case OPID_UNIT_STAY:
        pv->data.v_bool = punit->stay;
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case OBJTYPE_CITY:
    {
      const struct city *pcity = objbind_get_object(ob);
 
      if (NULL == pcity) {
        goto FAILED;
      }
 
      switch (propid) {
      case OPID_CITY_IMAGE:
        pv->data.v_pixbuf = create_city_pixbuf(pcity);
        pv->must_free = TRUE;
        break;
#ifdef FREECIV_DEBUG
      case OPID_CITY_ADDRESS:
        pv->data.v_string = g_strdup_printf("%p", pcity);
        pv->must_free = TRUE;
        break;
#endif /* FREECIV_DEBUG */
      case OPID_CITY_XY:
        {
          const struct tile *ptile = city_tile(pcity);
 
          pv->data.v_string = g_strdup_printf("(%d, %d)", TILE_XY(ptile));
          pv->must_free = TRUE;
        }
        break;
      case OPID_CITY_ID:
        pv->data.v_int = pcity->id;
        break;
      case OPID_CITY_NAME:
        pv->data.v_const_string = pcity->name;
        break;
      case OPID_CITY_SIZE:
        pv->data.v_int = city_size_get(pcity);
        break;
      case OPID_CITY_HISTORY:
        pv->data.v_int = pcity->history;
        break;
      case OPID_CITY_BUILDINGS:
        pv->data.v_built = fc_malloc(sizeof(pcity->built));
        memcpy(pv->data.v_built, pcity->built, sizeof(pcity->built));
        pv->must_free = TRUE;
        break;
      case OPID_CITY_FOOD_STOCK:
        pv->data.v_int = pcity->food_stock;
        break;
      case OPID_CITY_SHIELD_STOCK:
        pv->data.v_int = pcity->shield_stock;
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case OBJTYPE_PLAYER:
    {
      const struct player *pplayer = objbind_get_object(ob);
      const struct research *presearch;
 
      if (NULL == pplayer) {
        goto FAILED;
      }
 
      switch (propid) {
      case OPID_PLAYER_NAME:
        pv->data.v_const_string = pplayer->name;
        break;
      case OPID_PLAYER_NATION:
        pv->data.v_nation = nation_of_player(pplayer);
        break;
      case OPID_PLAYER_GOV:
        pv->data.v_gov = pplayer->government;
        break;
      case OPID_PLAYER_AGE:
        pv->data.v_int = pplayer->turns_alive;
        break;
#ifdef FREECIV_DEBUG
      case OPID_PLAYER_ADDRESS:
        pv->data.v_string = g_strdup_printf("%p", pplayer);
        pv->must_free = TRUE;
        break;
#endif /* FREECIV_DEBUG */
      case OPID_PLAYER_INVENTIONS:
        presearch = research_get(pplayer);
        BV_CLR_ALL(pv->data.v_bv_inventions);
        advance_index_iterate(A_FIRST, tech) {
          if (TECH_KNOWN == research_invention_state(presearch, tech)) {
            BV_SET(pv->data.v_bv_inventions, tech);
          }
        } advance_index_iterate_end;
        break;
      case OPID_PLAYER_SCENARIO_RESERVED:
        pv->data.v_bool = player_has_flag(pplayer, PLRF_SCENARIO_RESERVED);
        break;
      case OPID_PLAYER_SELECT_WEIGHT:
        pv->data.v_int = pplayer->autoselect_weight;
        break;
      case OPID_PLAYER_SCIENCE:
        presearch = research_get(pplayer);
        pv->data.v_int = presearch->bulbs_researched;
        break;
      case OPID_PLAYER_GOLD:
        pv->data.v_int = pplayer->economic.gold;
        break;
      case OPID_PLAYER_INFRAPOINTS:
        pv->data.v_int = pplayer->economic.infra_points;
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case OBJTYPE_GAME:
    {
      const struct civ_game *pgame = objbind_get_object(ob);
 
      if (NULL == pgame) {
        goto FAILED;
      }
 
      switch (propid) {
      case OPID_GAME_SCENARIO:
        pv->data.v_bool = pgame->scenario.is_scenario;
        break;
      case OPID_GAME_SCENARIO_NAME:
        pv->data.v_const_string = pgame->scenario.name;
        break;
      case OPID_GAME_SCENARIO_AUTHORS:
        pv->data.v_const_string = pgame->scenario.authors;
        break;
      case OPID_GAME_SCENARIO_DESC:
        pv->data.v_const_string = pgame->scenario_desc.description;
        break;
      case OPID_GAME_SCENARIO_RANDSTATE:
        pv->data.v_bool = pgame->scenario.save_random;
        break;
      case OPID_GAME_SCENARIO_PLAYERS:
        pv->data.v_bool = pgame->scenario.players;
        break;
      case OPID_GAME_STARTPOS_NATIONS:
        pv->data.v_bool = pgame->scenario.startpos_nations;
        break;
      case OPID_GAME_PREVENT_CITIES:
        pv->data.v_bool = pgame->scenario.prevent_new_cities;
        break;
      case OPID_GAME_LAKE_FLOODING:
        pv->data.v_bool = pgame->scenario.lake_flooding;
        break;
      case OPID_GAME_RULESET_LOCKED:
        pv->data.v_bool = pgame->scenario.ruleset_locked;
        break;
      default:
        log_error("%s(): Unhandled request for value of property %d "
                  "(%s) from object of type \"%s\".", __FUNCTION__,
                  propid, objprop_get_name(op), objtype_get_name(objtype));
        goto FAILED;
      }
    }
    return pv;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request for object type \"%s\" (nb %d).",
            __FUNCTION__, objtype_get_name(objtype), objtype);
 
FAILED:
  if (NULL != pv) {
    free(pv);
  }
  return NULL;
}
 
/************************************************************************/
static bool objbind_get_allowed_value_span(struct objbind *ob,
                                           struct objprop *op,
                                           double *pmin,
                                           double *pmax,
                                           double *pstep,
                                           double *pbig_step)
{
  enum editor_object_type objtype;
  enum object_property_ids propid;
  double dummy;
 
  /* Fill the values with something. */
  if (NULL != pmin) {
    *pmin = 0;
  } else {
    pmin = &dummy;
  }
  if (NULL != pmax) {
    *pmax = 1;
  } else {
    pmax = &dummy;
  }
  if (NULL != pstep) {
    *pstep = 1;
  } else {
    pstep = &dummy;
  }
  if (NULL != pbig_step) {
    *pbig_step = 1;
  } else {
    pbig_step = &dummy;
  }
 
  if (!ob || !op) {
    return FALSE;
  }
 
  propid = objprop_get_id(op);
  objtype = objbind_get_objtype(ob);
 
  switch (objtype) {
  case OBJTYPE_TILE:
  case OBJTYPE_STARTPOS:
    log_error("%s(): Unhandled request for value range of property %d (%s) "
              "from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return FALSE;
 
  case OBJTYPE_UNIT:
    {
      const struct unit *punit = objbind_get_object(ob);
      const struct unit_type *putype;
 
      if (NULL == punit) {
        return FALSE;
      }
 
      putype = unit_type_get(punit);
 
      switch (propid) {
      case OPID_UNIT_MOVES_LEFT:
        *pmin = 0;
        *pmax = MAX_MOVE_FRAGS;
        *pstep = 1;
        *pbig_step = 5;
        return TRUE;
      case OPID_UNIT_FUEL:
        *pmin = 0;
        *pmax = utype_fuel(putype);
        *pstep = 1;
        *pbig_step = 5;
        return TRUE;
      case OPID_UNIT_HP:
        *pmin = 1;
        *pmax = putype->hp;
        *pstep = 1;
        *pbig_step = 10;
        return TRUE;
      case OPID_UNIT_VETERAN:
        *pmin = 0;
        *pmax = utype_veteran_levels(putype) - 1;
        *pstep = 1;
        *pbig_step = 3;
        return TRUE;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request for value range of property %d (%s) "
              "from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return FALSE;
 
  case OBJTYPE_CITY:
    {
      const struct city *pcity = objbind_get_object(ob);
 
      if (NULL == pcity) {
        return FALSE;
      }
 
      switch (propid) {
      case OPID_CITY_SIZE:
        *pmin = 1;
        *pmax = MAX_CITY_SIZE;
        *pstep = 1;
        *pbig_step = 5;
        return TRUE;
      case OPID_CITY_HISTORY:
        *pmin = 0;
        *pmax = USHRT_MAX;
        *pstep = 1;
        *pbig_step = 10;
        return TRUE;
      case OPID_CITY_FOOD_STOCK:
        *pmin = 0;
        *pmax = city_granary_size(city_size_get(pcity));
        *pstep = 1;
        *pbig_step = 5;
        return TRUE;
      case OPID_CITY_SHIELD_STOCK:
        *pmin = 0;
        *pmax = USHRT_MAX; /* Limited to uint16 by city info packet. */
        *pstep = 1;
        *pbig_step = 10;
        return TRUE;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request for value range of property %d (%s) "
              "from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return FALSE;
 
  case OBJTYPE_PLAYER:
    switch (propid) {
    case OPID_PLAYER_SCIENCE:
      *pmin = 0;
      *pmax = 1000000; /* Arbitrary. */
      *pstep = 1;
      *pbig_step = 100;
      return TRUE;
    case OPID_PLAYER_GOLD:
      *pmin = 0;
      *pmax = 1000000; /* Arbitrary. */
      *pstep = 1;
      *pbig_step = 100;
      return TRUE;
    case OPID_PLAYER_INFRAPOINTS:
      *pmin = 0;
      *pmax = 1000000; /* Arbitrary. */
      *pstep = 1;
      *pbig_step = 100;
      return TRUE;
    case OPID_PLAYER_SELECT_WEIGHT:
      *pmin = -1;
      *pmax = 10000; /* Keep it under SINT16 */
      *pstep = 1;
      *pbig_step = 10;
      return TRUE;
    default:
      break;
    }
    log_error("%s(): Unhandled request for value range of property %d (%s) "
              "from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return FALSE;
 
  case OBJTYPE_GAME:
    log_error("%s(): Unhandled request for value range of property %d (%s) "
              "from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return FALSE;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request for object type \"%s\" (nb %d).",
            __FUNCTION__, objtype_get_name(objtype), objtype);
  return FALSE;
}
 
/************************************************************************/
static void objbind_clear_modified_value(struct objbind *ob,
                                         struct objprop *op)
{
  if (!ob || !op || !ob->propstate_table) {
    return;
  }
 
  propstate_hash_remove(ob->propstate_table, objprop_get_id(op));
}
 
/************************************************************************/
static bool objbind_property_is_modified(struct objbind *ob,
                                         struct objprop *op)
{
  if (!ob || !op) {
    return FALSE;
  }
 
  if (objprop_is_readonly(op)) {
    return FALSE;
  }
 
  return propstate_hash_lookup(ob->propstate_table,
                               objprop_get_id(op), NULL);
}
 
/************************************************************************/
static bool objbind_has_modified_properties(struct objbind *ob)
{
  if (!ob) {
    return FALSE;
  }
 
  return (0 < propstate_hash_size(ob->propstate_table));
}
 
/************************************************************************/
static void objbind_clear_all_modified_values(struct objbind *ob)
{
  if (!ob) {
    return;
  }
  propstate_hash_clear(ob->propstate_table);
}
 
/************************************************************************/
static bool objbind_set_modified_value(struct objbind *ob,
                                       struct objprop *op,
                                       struct propval *pv)
{
  struct propstate *ps;
  bool equal;
  struct propval *pv_old, *pv_copy;
  enum object_property_ids propid;
 
  if (!ob || !op) {
    return FALSE;
  }
 
  propid = objprop_get_id(op);
 
  pv_old = objbind_get_value_from_object(ob, op);
  if (!pv_old) {
    return FALSE;
  }
 
  equal = propval_equal(pv, pv_old);
  propval_free(pv_old);
 
  if (equal) {
    objbind_clear_modified_value(ob, op);
    return FALSE;
  }
 
  pv_copy = propval_copy(pv);
 
  if (propstate_hash_lookup(ob->propstate_table, propid, &ps)) {
    propstate_set_value(ps, pv_copy);
  } else {
    ps = propstate_new(op, pv_copy);
    propstate_hash_insert(ob->propstate_table, propid, ps);
  }
 
  return TRUE;
}
 
/************************************************************************/
static struct propval *objbind_get_modified_value(struct objbind *ob,
                                                  struct objprop *op)
{
  struct propstate *ps;
 
  if (!ob || !op) {
    return NULL;
  }
 
  if (propstate_hash_lookup(ob->propstate_table, objprop_get_id(op), &ps)) {
    return propstate_get_value(ps);
  } else {
    return NULL;
  }
}
 
/************************************************************************/
static void objbind_destroy(struct objbind *ob)
{
  if (!ob) {
    return;
  }
  if (ob->propstate_table) {
    propstate_hash_destroy(ob->propstate_table);
    ob->propstate_table = NULL;
  }
  if (ob->rowref) {
    gtk_tree_row_reference_free(ob->rowref);
    ob->rowref = NULL;
  }
  free(ob);
}
 
/************************************************************************/
static enum editor_object_type objbind_get_objtype(const struct objbind *ob)
{
  if (!ob) {
    return NUM_OBJTYPES;
  }
  return ob->objtype;
}
 
/************************************************************************/
static void objbind_bind_properties(struct objbind *ob,
                                    struct property_page *pp)
{
  if (!ob) {
    return;
  }
  ob->parent_property_page = pp;
}
 
/************************************************************************/
static void objbind_pack_current_values(struct objbind *ob,
                                        union packetdata pd)
{
  enum editor_object_type objtype;
 
  if (!ob || !pd.pointers.v_pointer1) {
    return;
  }
 
  objtype = objbind_get_objtype(ob);
 
  switch (objtype) {
  case OBJTYPE_TILE:
    {
      struct packet_edit_tile *packet = pd.tile;
      const struct tile *ptile = objbind_get_object(ob);
 
      if (NULL == ptile) {
        return;
      }
 
      packet->tile = tile_index(ptile);
      packet->extras = *tile_extras(ptile);
      /* TODO: Set more packet fields. */
    }
    return;
 
  case OBJTYPE_STARTPOS:
    {
      struct packet_edit_startpos_full *packet = pd.startpos;
      const struct startpos *psp = objbind_get_object(ob);
 
      if (NULL != psp) {
        startpos_pack(psp, packet);
      }
    }
    return;
 
  case OBJTYPE_UNIT:
    {
      struct packet_edit_unit *packet = pd.unit;
      const struct unit *punit = objbind_get_object(ob);
 
      if (NULL == punit) {
        return;
      }
 
      packet->id = punit->id;
      packet->moves_left = punit->moves_left;
      packet->fuel = punit->fuel;
      packet->moved = punit->moved;
      packet->done_moving = punit->done_moving;
      packet->hp = punit->hp;
      packet->veteran = punit->veteran;
      packet->stay = punit->stay;
      /* TODO: Set more packet fields. */
    }
    return;
 
  case OBJTYPE_CITY:
    {
      struct packet_edit_city *packet = pd.city;
      const struct city *pcity = objbind_get_object(ob);
      int i;
 
      if (NULL == pcity) {
        return;
      }
 
      packet->id = pcity->id;
      sz_strlcpy(packet->name, pcity->name);
      packet->size = city_size_get(pcity);
      packet->history = pcity->history;
      for (i = 0; i < B_LAST; i++) {
        packet->built[i] = pcity->built[i].turn;
      }
      packet->food_stock = pcity->food_stock;
      packet->shield_stock = pcity->shield_stock;
      /* TODO: Set more packet fields. */
    }
    return;
 
  case OBJTYPE_PLAYER:
    {
      struct packet_edit_player *packet = pd.player;
      const struct player *pplayer = objbind_get_object(ob);
      const struct nation_type *pnation;
      const struct research *presearch;
 
      if (NULL == pplayer) {
        return;
      }
 
      packet->id = player_number(pplayer);
      sz_strlcpy(packet->name, pplayer->name);
      pnation = nation_of_player(pplayer);
      packet->nation = nation_index(pnation);
      presearch = research_get(pplayer);
      advance_index_iterate(A_FIRST, tech) {
        packet->inventions[tech]
            = TECH_KNOWN == research_invention_state(presearch, tech);
      } advance_index_iterate_end;
      packet->autoselect_weight = pplayer->autoselect_weight;
      packet->gold = pplayer->economic.gold;
      packet->infrapoints = pplayer->economic.infra_points;
      packet->government = government_index(pplayer->government);
      packet->scenario_reserved = player_has_flag(pplayer, PLRF_SCENARIO_RESERVED);
      /* TODO: Set more packet fields. */
    }
    return;
 
  case OBJTYPE_GAME:
    {
      struct packet_edit_game *packet = pd.game.game;
      const struct civ_game *pgame = objbind_get_object(ob);
 
      if (NULL == pgame) {
        return;
      }
 
      packet->scenario = pgame->scenario.is_scenario;
      sz_strlcpy(packet->scenario_name, pgame->scenario.name);
      sz_strlcpy(packet->scenario_authors, pgame->scenario.authors);
      sz_strlcpy(pd.game.desc->scenario_desc, pgame->scenario_desc.description);
      packet->scenario_random = pgame->scenario.save_random;
      packet->scenario_players = pgame->scenario.players;
      packet->startpos_nations = pgame->scenario.startpos_nations;
      packet->prevent_new_cities = pgame->scenario.prevent_new_cities;
      packet->lake_flooding = pgame->scenario.lake_flooding;
    }
    return;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled object type %s (nb %d).", __FUNCTION__,
            objtype_get_name(objtype), objtype);
}
 
/************************************************************************/
static void objbind_pack_modified_value(struct objbind *ob,
                                        struct objprop *op,
                                        union packetdata pd)
{
  struct propval *pv;
  enum editor_object_type objtype;
  enum object_property_ids propid;
 
  if (!op || !ob || !pd.pointers.v_pointer1) {
    return;
  }
 
  if (NULL == objbind_get_object(ob)) {
    return;
  }
 
  if (objprop_is_readonly(op) || !objbind_property_is_modified(ob, op)) {
    return;
  }
 
  pv = objbind_get_modified_value(ob, op);
  if (!pv) {
    return;
  }
 
  objtype = objbind_get_objtype(ob);
  propid = objprop_get_id(op);
 
  switch (objtype) {
  case OBJTYPE_TILE:
    {
      struct packet_edit_tile *packet = pd.tile;
 
      switch (propid) {
      case OPID_TILE_SPECIALS:
        extra_type_by_cause_iterate(EC_SPECIAL, pextra) {
          if (BV_ISSET(pv->data.v_bv_special, pextra->data.special_idx)) {
            BV_SET(packet->extras, pextra->data.special_idx);
          } else {
            BV_CLR(packet->extras, pextra->data.special_idx);
          }
        } extra_type_by_cause_iterate_end;
        return;
      case OPID_TILE_ROADS:
        extra_type_by_cause_iterate(EC_ROAD, pextra) {
          int ridx = road_number(extra_road_get(pextra));
 
          if (BV_ISSET(pv->data.v_bv_roads, ridx)) {
            BV_SET(packet->extras, extra_index(pextra));
          } else {
            BV_CLR(packet->extras, extra_index(pextra));
          }
        } extra_type_by_cause_iterate_end;
        return;
      case OPID_TILE_BASES:
        extra_type_by_cause_iterate(EC_BASE, pextra) {
          int bidx = base_number(extra_base_get(pextra));
 
          if (BV_ISSET(pv->data.v_bv_bases, bidx)) {
            BV_SET(packet->extras, extra_index(pextra));
          } else {
            BV_CLR(packet->extras, extra_index(pextra));
          }
        } extra_type_by_cause_iterate_end;
        return;
      case OPID_TILE_LABEL:
        sz_strlcpy(packet->label, pv->data.v_string);
        return;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case OBJTYPE_STARTPOS:
    {
      struct packet_edit_startpos_full *packet = pd.startpos;
 
      switch (propid) {
      case OPID_STARTPOS_EXCLUDE:
        packet->exclude = pv->data.v_bool;
        return;
      case OPID_STARTPOS_NATIONS:
        BV_CLR_ALL(packet->nations);
        nation_hash_iterate(pv->data.v_nation_hash, pnation) {
          BV_SET(packet->nations, nation_number(pnation));
        } nation_hash_iterate_end;
        return;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case OBJTYPE_UNIT:
    {
      struct packet_edit_unit *packet = pd.unit;
 
      switch (propid) {
      case OPID_UNIT_MOVES_LEFT:
        packet->moves_left = pv->data.v_int;
        return;
      case OPID_UNIT_FUEL:
        packet->fuel = pv->data.v_int;
        return;
      case OPID_UNIT_MOVED:
        packet->moved = pv->data.v_bool;
        return;
      case OPID_UNIT_DONE_MOVING:
        packet->done_moving = pv->data.v_bool;
        return;
      case OPID_UNIT_HP:
        packet->hp = pv->data.v_int;
        return;
      case OPID_UNIT_VETERAN:
        packet->veteran = pv->data.v_int;
        return;
      case OPID_UNIT_STAY:
        packet->stay = pv->data.v_bool;
        return;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case OBJTYPE_CITY:
    {
      struct packet_edit_city *packet = pd.city;
 
      switch (propid) {
      case OPID_CITY_NAME:
        sz_strlcpy(packet->name, pv->data.v_string);
        return;
      case OPID_CITY_SIZE:
        packet->size = pv->data.v_int;
        return;
      case OPID_CITY_HISTORY:
        packet->history = pv->data.v_int;
        return;
      case OPID_CITY_FOOD_STOCK:
        packet->food_stock = pv->data.v_int;
        return;
      case OPID_CITY_SHIELD_STOCK:
        packet->shield_stock = pv->data.v_int;
        return;
      case OPID_CITY_BUILDINGS:
        {
          int i;
 
          for (i = 0; i < B_LAST; i++) {
            packet->built[i] = pv->data.v_built[i].turn;
          }
        }
        return;
      default:
          break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case OBJTYPE_PLAYER:
    {
      struct packet_edit_player *packet = pd.player;
 
      switch (propid) {
      case OPID_PLAYER_NAME:
        sz_strlcpy(packet->name, pv->data.v_string);
        return;
      case OPID_PLAYER_NATION:
        packet->nation = nation_index(pv->data.v_nation);
        return;
      case OPID_PLAYER_GOV:
        packet->government = government_index(pv->data.v_gov);
        return;
      case OPID_PLAYER_INVENTIONS:
        advance_index_iterate(A_FIRST, tech) {
          packet->inventions[tech] = BV_ISSET(pv->data.v_bv_inventions, tech);
        } advance_index_iterate_end;
        return;
      case OPID_PLAYER_SCENARIO_RESERVED:
        packet->scenario_reserved = pv->data.v_bool;
        return;
      case OPID_PLAYER_SELECT_WEIGHT:
        packet->autoselect_weight = pv->data.v_int;
        return;
      case OPID_PLAYER_SCIENCE:
        packet->bulbs_researched = pv->data.v_int;
        return;
      case OPID_PLAYER_GOLD:
        packet->gold = pv->data.v_int;
        return;
      case OPID_PLAYER_INFRAPOINTS:
        packet->infrapoints = pv->data.v_int;
        return;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case OBJTYPE_GAME:
    {
      struct packet_edit_game *packet = pd.game.game;
 
      switch (propid) {
      case OPID_GAME_SCENARIO:
        packet->scenario = pv->data.v_bool;
        return;
      case OPID_GAME_SCENARIO_NAME:
        sz_strlcpy(packet->scenario_name, pv->data.v_const_string);
        return;
      case OPID_GAME_SCENARIO_AUTHORS:
        sz_strlcpy(packet->scenario_authors, pv->data.v_const_string);
        return;
      case OPID_GAME_SCENARIO_DESC:
        sz_strlcpy(pd.game.desc->scenario_desc, pv->data.v_const_string);
        return;
      case OPID_GAME_SCENARIO_RANDSTATE:
        packet->scenario_random = pv->data.v_bool;
        return;
      case OPID_GAME_SCENARIO_PLAYERS:
        packet->scenario_players = pv->data.v_bool;
        return;
      case OPID_GAME_STARTPOS_NATIONS:
        packet->startpos_nations = pv->data.v_bool;
        return;
      case OPID_GAME_PREVENT_CITIES:
        packet->prevent_new_cities = pv->data.v_bool;
        return;
      case OPID_GAME_LAKE_FLOODING:
        packet->lake_flooding = pv->data.v_bool;
        return;
      case OPID_GAME_RULESET_LOCKED:
        packet->ruleset_locked = pv->data.v_bool;
        return;
      default:
        break;
      }
    }
    log_error("%s(): Unhandled request to pack value of property "
              "%d (%s) from object of type \"%s\".", __FUNCTION__,
              propid, objprop_get_name(op), objtype_get_name(objtype));
    return;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled request for object type \"%s\" (nb %d).",
            __FUNCTION__, objtype_get_name(objtype), objtype);
 
}
 
/************************************************************************/
static void objbind_set_rowref(struct objbind *ob,
                               GtkTreeRowReference *rr)
{
  if (!ob) {
    return;
  }
  ob->rowref = rr;
}
 
/************************************************************************/
static GtkTreeRowReference *objbind_get_rowref(struct objbind *ob)
{
  if (!ob) {
    return NULL;
  }
  return ob->rowref;
}
 
/************************************************************************/
static int objprop_get_id(const struct objprop *op)
{
  if (!op) {
    return -1;
  }
  return op->id;
}
 
/************************************************************************/
static GType objprop_get_gtype(const struct objprop *op)
{
  fc_assert_ret_val(NULL != op, G_TYPE_NONE);
 
  switch (op->valtype) {
  case VALTYPE_NONE:
  case VALTYPE_TILE_VISION_DATA:
    return G_TYPE_NONE;
  case VALTYPE_INT:
    return G_TYPE_INT;
  case VALTYPE_BOOL:
    /* We want to show it as translated string, not as untranslated G_TYPE_BOOLEAN */
    return G_TYPE_STRING;
  case VALTYPE_STRING:
  case VALTYPE_BUILT_ARRAY:
  case VALTYPE_INVENTIONS_ARRAY:
  case VALTYPE_BV_SPECIAL:
  case VALTYPE_BV_ROADS:
  case VALTYPE_BV_BASES:
  case VALTYPE_NATION_HASH:
    return G_TYPE_STRING;
  case VALTYPE_PIXBUF:
  case VALTYPE_NATION:
  case VALTYPE_GOV:
    return GDK_TYPE_PIXBUF;
  }
  log_error("%s(): Unhandled value type %d.", __FUNCTION__, op->valtype);
  return G_TYPE_NONE;
}
 
/************************************************************************/
static enum value_types objprop_get_valtype(const struct objprop *op)
{
  if (!op) {
    return VALTYPE_NONE;
  }
  return op->valtype;
}
 
/************************************************************************/
static bool objprop_show_in_listview(const struct objprop *op)
{
  if (!op) {
    return FALSE;
  }
  return op->flags & OPF_IN_LISTVIEW;
}
 
/************************************************************************/
static bool objprop_has_widget(const struct objprop *op)
{
  if (!op) {
    return FALSE;
  }
  return op->flags & OPF_HAS_WIDGET;
}
 
/************************************************************************/
static const char *objprop_get_attribute_type_string(const struct objprop *op)
{
  GType gtype;
 
  if (!op) {
    return NULL;
  }
 
  gtype = objprop_get_gtype(op);
  if (gtype == G_TYPE_INT || gtype == G_TYPE_STRING
      || gtype == G_TYPE_BOOLEAN) {
    return "text";
  } else if (gtype == GDK_TYPE_PIXBUF) {
    return "pixbuf";
  }
 
  return NULL;
}
 
/************************************************************************/
static void objprop_set_column_id(struct objprop *op, int col_id)
{
  if (!op) {
    return;
  }
  op->column_id = col_id;
}
 
/************************************************************************/
static int objprop_get_column_id(const struct objprop *op)
{
  if (!op) {
    return -1;
  }
  return op->column_id;
}
 
/************************************************************************/
static void objprop_set_treeview_column(struct objprop *op,
                                        GtkTreeViewColumn *col)
{
  if (!op) {
    return;
  }
  op->view_column = col;
}
 
/************************************************************************/
static GtkTreeViewColumn *objprop_get_treeview_column(const struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  return op->view_column;
}
 
/************************************************************************/
static const char *objprop_get_name(const struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  return op->name;
}
 
/************************************************************************/
static const char *objprop_get_tooltip(const struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  return op->tooltip;
}
 
/************************************************************************/
static GtkCellRenderer *objprop_create_cell_renderer(const struct objprop *op)
{
  GtkCellRenderer *cell = NULL;
  GType gtype;
 
  gtype = objprop_get_gtype(op);
 
  if (gtype == G_TYPE_INT || gtype == G_TYPE_STRING
      || gtype == G_TYPE_BOOLEAN) {
    cell = gtk_cell_renderer_text_new();
  } else if (gtype == GDK_TYPE_PIXBUF) {
    cell = gtk_cell_renderer_pixbuf_new();
  }
 
  return cell;
}
 
/************************************************************************/
static bool objprop_is_sortable(const struct objprop *op)
{
  GType gtype;
  if (!op) {
    return FALSE;
  }
  gtype = objprop_get_gtype(op);
  return gtype == G_TYPE_INT || gtype == G_TYPE_STRING;
}
 
/************************************************************************/
static bool objprop_is_readonly(const struct objprop *op)
{
  if (!op) {
    return TRUE;
  }
  return !(op->flags & OPF_EDITABLE);
}
 
/************************************************************************/
static void objprop_widget_text_changed(GtkEditable *text, gpointer userdata)
{
  struct objprop *op;
  struct property_page *pp;
  struct propval value = {{0,}, VALTYPE_STRING, FALSE};
 
  op = userdata;
  pp = objprop_get_property_page(op);
  value.data.v_const_string = gtk_entry_buffer_get_text(gtk_text_get_buffer(GTK_TEXT(text)));
 
  property_page_change_value(pp, op, &value);
}
 
/************************************************************************/
static void objprop_widget_spin_button_changed(GtkSpinButton *spin,
                                               gpointer userdata)
{
  struct objprop *op;
  struct property_page *pp;
  struct propval value = {{0,}, VALTYPE_INT, FALSE};
 
  op = userdata;
  pp = objprop_get_property_page(op);
  value.data.v_int = gtk_spin_button_get_value_as_int(spin);
 
  property_page_change_value(pp, op, &value);
}
 
/************************************************************************/
static void objprop_widget_toggle_button_changed(GtkToggleButton *button,
                                                 gpointer userdata)
{
  struct objprop *op;
  struct property_page *pp;
  struct propval value = {{0,}, VALTYPE_BOOL, FALSE};
 
  op = userdata;
  pp = objprop_get_property_page(op);
  value.data.v_bool = gtk_toggle_button_get_active(button);
 
  property_page_change_value(pp, op, &value);
}
 
/************************************************************************/
static void objprop_setup_widget(struct objprop *op)
{
  GtkWidget *hbox, *hbox2, *label, *image, *text, *spin, *button;
  struct extviewer *ev = NULL;
  enum object_property_ids propid;
 
  if (!op) {
    return;
  }
 
  if (!objprop_has_widget(op)) {
    return;
  }
 
  hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
  op->widget = hbox;
 
  label = gtk_label_new(objprop_get_name(op));
  gtk_widget_set_halign(label, GTK_ALIGN_START);
  gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
  gtk_box_append(GTK_BOX(hbox), label);
  objprop_set_child_widget(op, "name-label", label);
 
  propid = objprop_get_id(op);
 
  switch (propid) {
  case OPID_TILE_INDEX:
  case OPID_TILE_X:
  case OPID_TILE_Y:
  case OPID_TILE_NAT_X:
  case OPID_TILE_NAT_Y:
  case OPID_TILE_CONTINENT:
  case OPID_TILE_TERRAIN:
  case OPID_TILE_RESOURCE:
  case OPID_TILE_XY:
  case OPID_STARTPOS_XY:
  case OPID_UNIT_ID:
  case OPID_UNIT_XY:
  case OPID_UNIT_TYPE:
  case OPID_CITY_ID:
  case OPID_CITY_XY:
  case OPID_PLAYER_AGE:
#ifdef FREECIV_DEBUG
  case OPID_TILE_ADDRESS:
  case OPID_UNIT_ADDRESS:
  case OPID_CITY_ADDRESS:
  case OPID_PLAYER_ADDRESS:
#endif /* FREECIV_DEBUG */
    label = gtk_label_new(NULL);
    gtk_widget_set_hexpand(label, TRUE);
    gtk_widget_set_halign(label, GTK_ALIGN_START);
    gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(hbox), label);
    objprop_set_child_widget(op, "value-label", label);
    return;
 
  case OPID_TILE_IMAGE:
  case OPID_STARTPOS_IMAGE:
  case OPID_UNIT_IMAGE:
  case OPID_CITY_IMAGE:
    image = gtk_image_new();
    gtk_widget_set_size_request(image,
                                tileset_tile_width(tileset),
                                tileset_tile_height(tileset));
    gtk_widget_set_hexpand(image, TRUE);
    gtk_widget_set_halign(image, GTK_ALIGN_START);
    gtk_widget_set_valign(image, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(hbox), image);
    objprop_set_child_widget(op, "image", image);
    return;
 
  case OPID_CITY_NAME:
  case OPID_PLAYER_NAME:
  case OPID_GAME_SCENARIO_NAME:
  case OPID_TILE_LABEL:
    text = gtk_text_new();
    gtk_widget_set_hexpand(text, TRUE);
    gtk_widget_set_halign(text, GTK_ALIGN_END);
    gtk_editable_set_width_chars(GTK_EDITABLE(text), 8);
    g_signal_connect(text, "changed",
                     G_CALLBACK(objprop_widget_text_changed), op);
    gtk_box_append(GTK_BOX(hbox), text);
    objprop_set_child_widget(op, "text", text);
    return;
 
  case OPID_UNIT_MOVES_LEFT:
  case OPID_CITY_SIZE:
  case OPID_CITY_HISTORY:
  case OPID_CITY_SHIELD_STOCK:
  case OPID_PLAYER_SELECT_WEIGHT:
  case OPID_PLAYER_SCIENCE:
  case OPID_PLAYER_GOLD:
  case OPID_PLAYER_INFRAPOINTS:
    spin = gtk_spin_button_new_with_range(0.0, 100.0, 1.0);
    gtk_widget_set_hexpand(spin, TRUE);
    gtk_widget_set_halign(spin, GTK_ALIGN_END);
    g_signal_connect(spin, "value-changed",
        G_CALLBACK(objprop_widget_spin_button_changed), op);
    gtk_box_append(GTK_BOX(hbox), spin);
    objprop_set_child_widget(op, "spin", spin);
    return;
 
  case OPID_UNIT_FUEL:
  case OPID_UNIT_HP:
  case OPID_UNIT_VETERAN:
  case OPID_CITY_FOOD_STOCK:
    hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
    gtk_widget_set_hexpand(hbox2, TRUE);
    gtk_widget_set_halign(hbox2, GTK_ALIGN_END);
    gtk_box_append(GTK_BOX(hbox), hbox2);
    spin = gtk_spin_button_new_with_range(0.0, 100.0, 1.0);
    g_signal_connect(spin, "value-changed",
        G_CALLBACK(objprop_widget_spin_button_changed), op);
    gtk_box_append(GTK_BOX(hbox2), spin);
    objprop_set_child_widget(op, "spin", spin);
    label = gtk_label_new(NULL);
    gtk_widget_set_halign(label, GTK_ALIGN_START);
    gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(hbox2), label);
    objprop_set_child_widget(op, "max-value-label", label);
    return;
 
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
  case OPID_TILE_VISION:
  case OPID_STARTPOS_NATIONS:
  case OPID_CITY_BUILDINGS:
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
  case OPID_PLAYER_INVENTIONS:
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    ev = extviewer_new(op);
    objprop_set_extviewer(op, ev);
    gtk_widget_set_hexpand(extviewer_get_panel_widget(ev), TRUE);
    gtk_widget_set_halign(extviewer_get_panel_widget(ev), GTK_ALIGN_END);
    gtk_box_append(GTK_BOX(hbox), extviewer_get_panel_widget(ev));
    property_page_add_extviewer(objprop_get_property_page(op), ev);
    return;
 
  case OPID_STARTPOS_EXCLUDE:
  case OPID_UNIT_MOVED:
  case OPID_UNIT_DONE_MOVING:
  case OPID_UNIT_STAY:
  case OPID_GAME_SCENARIO:
  case OPID_GAME_SCENARIO_RANDSTATE:
  case OPID_GAME_SCENARIO_PLAYERS:
  case OPID_GAME_STARTPOS_NATIONS:
  case OPID_GAME_PREVENT_CITIES:
  case OPID_GAME_LAKE_FLOODING:
  case OPID_GAME_RULESET_LOCKED:
  case OPID_PLAYER_SCENARIO_RESERVED:
    button = gtk_toggle_button_new();
    gtk_widget_set_hexpand(button, TRUE);
    gtk_widget_set_halign(button, GTK_ALIGN_END);
    g_signal_connect(button, "toggled",
                     G_CALLBACK(objprop_widget_toggle_button_changed),
                     op);
    gtk_box_append(GTK_BOX(hbox), button);
    objprop_set_child_widget(op, "togglebutton", button);
    return;
  }
 
  log_error("%s(): Unhandled request to create widget for property %d (%s).",
            __FUNCTION__, propid, objprop_get_name(op));
}
 
/************************************************************************/
static void objprop_refresh_widget(struct objprop *op,
                                   struct objbind *ob)
{
  GtkWidget *w, *label, *image, *text, *spin, *button;
  struct extviewer *ev;
  struct propval *pv;
  bool modified;
  enum object_property_ids propid;
  double min, max, step, big_step;
  char buf[256];
  const char *newtext;
  GtkEntryBuffer *buffer;
 
  if (!op || !objprop_has_widget(op)) {
    return;
  }
 
  w = objprop_get_widget(op);
  if (!w) {
    return;
  }
 
  propid = objprop_get_id(op);
 
  /* NB: We must take care to propval_free() the return value of
   * objbind_get_value_from_object(), since it always makes a
   * copy, but to NOT free the result of objbind_get_modified_value()
   * since it returns its own stored value. */
  pv = objbind_get_value_from_object(ob, op);
  modified = objbind_property_is_modified(ob, op);
 
  if (pv && modified) {
    struct propval *pv_mod;
 
    pv_mod = objbind_get_modified_value(ob, op);
    if (pv_mod) {
      if (propval_equal(pv, pv_mod)) {
        objbind_clear_modified_value(ob, op);
        modified = FALSE;
      } else {
        propval_free(pv);
        pv = pv_mod;
        modified = TRUE;
      }
    } else {
      modified = FALSE;
    }
  }
 
  switch (propid) {
  case OPID_TILE_IMAGE:
  case OPID_STARTPOS_IMAGE:
  case OPID_UNIT_IMAGE:
  case OPID_CITY_IMAGE:
    image = objprop_get_child_widget(op, "image");
    if (pv) {
      gtk_image_set_from_pixbuf(GTK_IMAGE(image), pv->data.v_pixbuf);
    } else {
      gtk_image_set_from_pixbuf(GTK_IMAGE(image), NULL);
    }
    break;
 
  case OPID_TILE_XY:
  case OPID_TILE_TERRAIN:
  case OPID_TILE_RESOURCE:
  case OPID_STARTPOS_XY:
  case OPID_UNIT_XY:
  case OPID_UNIT_TYPE:
  case OPID_CITY_XY:
#ifdef FREECIV_DEBUG
  case OPID_TILE_ADDRESS:
  case OPID_UNIT_ADDRESS:
  case OPID_CITY_ADDRESS:
  case OPID_PLAYER_ADDRESS:
#endif /* FREECIV_DEBUG */
    label = objprop_get_child_widget(op, "value-label");
    if (pv) {
      gtk_label_set_text(GTK_LABEL(label), pv->data.v_string);
    } else {
      gtk_label_set_text(GTK_LABEL(label), NULL);
    }
    break;
 
  case OPID_TILE_INDEX:
  case OPID_TILE_X:
  case OPID_TILE_Y:
  case OPID_TILE_NAT_X:
  case OPID_TILE_NAT_Y:
  case OPID_TILE_CONTINENT:
  case OPID_UNIT_ID:
  case OPID_CITY_ID:
  case OPID_PLAYER_AGE:
    label = objprop_get_child_widget(op, "value-label");
    if (pv) {
      char agebuf[16];
 
      fc_snprintf(agebuf, sizeof(agebuf), "%d", pv->data.v_int);
      gtk_label_set_text(GTK_LABEL(label), agebuf);
    } else {
      gtk_label_set_text(GTK_LABEL(label), NULL);
    }
    break;
 
  case OPID_CITY_NAME:
  case OPID_PLAYER_NAME:
  case OPID_GAME_SCENARIO_NAME:
  case OPID_TILE_LABEL:
    text = objprop_get_child_widget(op, "text");
    if (pv) {
      /* Most of these are semantically in "v_const_string",
       * but this works as the address is the same regardless. */
      newtext = pv->data.v_string;
    } else {
      newtext = "";
    }
    buffer = gtk_text_get_buffer(GTK_TEXT(text));
 
    /* Only set the text if it has changed. This breaks
     * recursive loop. */
    if (strcmp(newtext, gtk_entry_buffer_get_text(buffer))) {
      gtk_entry_buffer_set_text(buffer, newtext, -1);
    }
    gtk_widget_set_sensitive(text, pv != NULL);
    break;
 
  case OPID_UNIT_MOVES_LEFT:
  case OPID_CITY_SIZE:
  case OPID_CITY_HISTORY:
  case OPID_CITY_SHIELD_STOCK:
  case OPID_PLAYER_SELECT_WEIGHT:
  case OPID_PLAYER_SCIENCE:
  case OPID_PLAYER_GOLD:
  case OPID_PLAYER_INFRAPOINTS:
    spin = objprop_get_child_widget(op, "spin");
    if (pv) {
      disable_gobject_callback(G_OBJECT(spin),
          G_CALLBACK(objprop_widget_spin_button_changed));
      if (objbind_get_allowed_value_span(ob, op, &min, &max,
                                         &step, &big_step)) {
        gtk_spin_button_set_range(GTK_SPIN_BUTTON(spin), min, max);
        gtk_spin_button_set_increments(GTK_SPIN_BUTTON(spin),
                                       step, big_step);
      }
      gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), pv->data.v_int);
      enable_gobject_callback(G_OBJECT(spin),
                              G_CALLBACK(objprop_widget_spin_button_changed));
    }
    gtk_widget_set_sensitive(spin, pv != NULL);
    break;
 
  case OPID_UNIT_FUEL:
  case OPID_UNIT_HP:
  case OPID_UNIT_VETERAN:
  case OPID_CITY_FOOD_STOCK:
    spin = objprop_get_child_widget(op, "spin");
    label = objprop_get_child_widget(op, "max-value-label");
    if (pv) {
      disable_gobject_callback(G_OBJECT(spin),
          G_CALLBACK(objprop_widget_spin_button_changed));
      if (objbind_get_allowed_value_span(ob, op, &min, &max,
                                         &step, &big_step)) {
        gtk_spin_button_set_range(GTK_SPIN_BUTTON(spin), min, max);
        gtk_spin_button_set_increments(GTK_SPIN_BUTTON(spin),
                                       step, big_step);
        fc_snprintf(buf, sizeof(buf), "/%d", (int) max);
        gtk_label_set_text(GTK_LABEL(label), buf);
      } else {
        gtk_label_set_text(GTK_LABEL(label), NULL);
      }
      gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), pv->data.v_int);
      enable_gobject_callback(G_OBJECT(spin),
          G_CALLBACK(objprop_widget_spin_button_changed));
    } else {
      gtk_label_set_text(GTK_LABEL(label), NULL);
    }
    gtk_widget_set_sensitive(spin, pv != NULL);
    break;
 
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
  case OPID_TILE_VISION:
  case OPID_STARTPOS_NATIONS:
  case OPID_CITY_BUILDINGS:
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
  case OPID_PLAYER_INVENTIONS:
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    ev = objprop_get_extviewer(op);
    if (pv) {
      extviewer_refresh_widgets(ev, pv);
    } else {
      extviewer_clear_widgets(ev);
    }
    break;
 
  case OPID_STARTPOS_EXCLUDE:
  case OPID_UNIT_MOVED:
  case OPID_UNIT_DONE_MOVING:
  case OPID_UNIT_STAY:
  case OPID_GAME_SCENARIO:
  case OPID_GAME_SCENARIO_RANDSTATE:
  case OPID_GAME_SCENARIO_PLAYERS:
  case OPID_GAME_STARTPOS_NATIONS:
  case OPID_GAME_PREVENT_CITIES:
  case OPID_GAME_LAKE_FLOODING:
  case OPID_GAME_RULESET_LOCKED:
  case OPID_PLAYER_SCENARIO_RESERVED:
    button = objprop_get_child_widget(op, "togglebutton");
    disable_gobject_callback(G_OBJECT(button),
                             G_CALLBACK(objprop_widget_toggle_button_changed));
    if (pv) {
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
                                   pv->data.v_bool);
    } else {
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
    }
    enable_gobject_callback(G_OBJECT(button),
                            G_CALLBACK(objprop_widget_toggle_button_changed));
    gtk_widget_set_sensitive(button, pv != NULL);
    break;
  }
 
  if (!modified) {
    propval_free(pv);
  }
 
  label = objprop_get_child_widget(op, "name-label");
  if (label) {
    const char *name = objprop_get_name(op);
    if (modified) {
      char namebuf[128];
 
      fc_snprintf(namebuf, sizeof(namebuf),
                  "<span foreground=\"red\">%s</span>", name);
      gtk_label_set_markup(GTK_LABEL(label), namebuf);
    } else {
      gtk_label_set_text(GTK_LABEL(label), name);
    }
  }
}
 
/************************************************************************/
static GtkWidget *objprop_get_widget(struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  if (!op->widget) {
    objprop_setup_widget(op);
  }
  return op->widget;
}
 
/************************************************************************/
static void objprop_set_child_widget(struct objprop *op,
                                     const char *widget_name,
                                     GtkWidget *widget)
{
  GtkWidget *w;
 
  if (!op || !widget_name || !widget) {
    return;
  }
 
  w = objprop_get_widget(op);
  if (!w) {
    log_error("Cannot store child widget %p under name "
              "\"%s\" using objprop_set_child_widget for object "
              "property %d (%s) because objprop_get_widget does "
              "not return a valid widget.",
              widget, widget_name, objprop_get_id(op), objprop_get_name(op));
    return;
  }
 
  g_object_set_data(G_OBJECT(w), widget_name, widget);
}
 
/************************************************************************/
static GtkWidget *objprop_get_child_widget(struct objprop *op,
                                           const char *widget_name)
{
  GtkWidget *w, *child;
 
  if (!op || !widget_name) {
    return NULL;
  }
 
  w = objprop_get_widget(op);
  if (!w) {
    log_error("Cannot retrieve child widget under name "
              "\"%s\" using objprop_get_child_widget for object "
              "property %d (%s) because objprop_get_widget does "
              "not return a valid widget.",
              widget_name, objprop_get_id(op), objprop_get_name(op));
    return NULL;
  }
 
  child = g_object_get_data(G_OBJECT(w), widget_name);
  if (!child) {
    log_error("Child widget \"%s\" not found for object "
              "property %d (%s) via objprop_get_child_widget.",
              widget_name, objprop_get_id(op), objprop_get_name(op));
    return NULL;
  }
 
  return child;
}
 
/************************************************************************/
static void objprop_set_extviewer(struct objprop *op,
                                  struct extviewer *ev)
{
  if (!op) {
    return;
  }
  op->extviewer = ev;
}
 
/************************************************************************/
static struct extviewer *objprop_get_extviewer(struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  return op->extviewer;
}
 
/************************************************************************/
static struct property_page *objprop_get_property_page(const struct objprop *op)
{
  if (!op) {
    return NULL;
  }
  return op->parent_page;
}
 
/************************************************************************/
static struct objprop *objprop_new(int id,
                                   const char *name,
                                   const char *tooltip,
                                   enum object_property_flags flags,
                                   enum value_types valtype,
                                   struct property_page *parent)
{
  struct objprop *op;
 
  op = fc_calloc(1, sizeof(*op));
  op->id = id;
  op->name = name;
  op->tooltip = tooltip;
  op->flags = flags;
  op->valtype = valtype;
  op->column_id = -1;
  op->parent_page = parent;
 
  return op;
}
 
/************************************************************************/
static struct extviewer *extviewer_new(struct objprop *op)
{
  struct extviewer *ev;
  GtkWidget *hbox, *vbox, *label, *button, *scrollwin, *image;
  GtkWidget *view = NULL;
  GtkTreeSelection *sel;
  GtkListStore *store = NULL;
  GtkTextBuffer *textbuf = NULL;
  GType *gtypes;
  enum object_property_ids propid;
  int num_cols;
 
  if (!op) {
    return NULL;
  }
 
  ev = fc_calloc(1, sizeof(*ev));
  ev->objprop = op;
 
  propid = objprop_get_id(op);
 
 
  /* Create the panel widget. */
 
  switch (propid) {
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
  case OPID_STARTPOS_NATIONS:
  case OPID_CITY_BUILDINGS:
  case OPID_PLAYER_INVENTIONS:
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
    ev->panel_widget = hbox;
 
    label = gtk_label_new(NULL);
    gtk_widget_set_halign(label, GTK_ALIGN_START);
    gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(hbox), label);
    ev->panel_label = label;
    break;
 
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
    ev->panel_widget = vbox;
 
    label = gtk_label_new(NULL);
    gtk_widget_set_halign(label, GTK_ALIGN_START);
    gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(vbox), label);
    ev->panel_label = label;
 
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
    gtk_box_append(GTK_BOX(vbox), hbox);
 
    image = gtk_image_new();
    if (propid == OPID_PLAYER_GOV) {
      gtk_widget_set_size_request(image,
                                  tileset_small_sprite_width(tileset),
                                  tileset_small_sprite_height(tileset));
    } else {
      /* propid OPID_PLAYER_NATION */
      gtk_widget_set_size_request(image, 100, 40);
    }
    gtk_widget_set_halign(image, GTK_ALIGN_START);
    gtk_widget_set_valign(image, GTK_ALIGN_CENTER);
    gtk_box_append(GTK_BOX(hbox), image);
    ev->panel_image = image;
    break;
 
  case OPID_TILE_VISION:
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
    ev->panel_widget = hbox;
    break;
 
  default:
    log_error("Unhandled request to create panel widget "
              "for property %d (%s) in extviewer_new().",
              propid, objprop_get_name(op));
    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
    ev->panel_widget = hbox;
    break;
  }
 
  if (objprop_is_readonly(op)) {
    button = gtk_button_new_with_label(Q_("?verb:View"));
  } else {
    button = gtk_button_new_with_label(_("Edit"));
  }
  g_signal_connect(button, "clicked",
                   G_CALLBACK(extviewer_panel_button_clicked), ev);
  gtk_box_append(GTK_BOX(hbox), button);
  ev->panel_button = button;
 
 
  /* Create the data store. */
 
  switch (propid) {
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
  case OPID_PLAYER_INVENTIONS:
    store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_INT,
                               G_TYPE_STRING);
    break;
  case OPID_TILE_VISION:
    num_cols = 3 + 1 + V_COUNT;
    gtypes = fc_malloc(num_cols * sizeof(GType));
    gtypes[0] = G_TYPE_INT;       /* player number */
    gtypes[1] = GDK_TYPE_PIXBUF;  /* player flag */
    gtypes[2] = G_TYPE_STRING;    /* player name */
    gtypes[3] = G_TYPE_BOOLEAN;   /* tile_known */
    vision_layer_iterate(v) {
      gtypes[4 + v] = G_TYPE_BOOLEAN; /* tile_seen[v] */
    } vision_layer_iterate_end;
    store = gtk_list_store_newv(num_cols, gtypes);
    free(gtypes);
    break;
  case OPID_CITY_BUILDINGS:
    store = gtk_list_store_new(4, G_TYPE_BOOLEAN, G_TYPE_INT,
                               G_TYPE_STRING, G_TYPE_STRING);
    break;
  case OPID_STARTPOS_NATIONS:
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
    store = gtk_list_store_new(4, G_TYPE_BOOLEAN, G_TYPE_INT,
                               GDK_TYPE_PIXBUF, G_TYPE_STRING);
    break;
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    textbuf = gtk_text_buffer_new(NULL);
    break;
  default:
    log_error("Unhandled request to create data store "
              "for property %d (%s) in extviewer_new().",
              propid, objprop_get_name(op));
    break;
  }
 
  ev->store = store;
  ev->textbuf = textbuf;
 
  /* Create the view widget. */
 
  vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
  ev->view_widget = vbox;
 
  label = gtk_label_new(objprop_get_name(op));
  gtk_widget_set_halign(label, GTK_ALIGN_START);
  gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
  gtk_box_append(GTK_BOX(vbox), label);
  ev->view_label = label;
 
  if (store || textbuf) {
    scrollwin = gtk_scrolled_window_new();
    gtk_scrolled_window_set_has_frame(GTK_SCROLLED_WINDOW(scrollwin),
                                      TRUE);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
    gtk_box_append(GTK_BOX(vbox), scrollwin);
 
    if (store) {
      view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
      sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
      gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
    } else {
      const bool editable = !objprop_is_readonly(op);
 
      view = gtk_text_view_new_with_buffer(textbuf);
      gtk_text_view_set_editable(GTK_TEXT_VIEW(view), editable);
      gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(view), editable);
    }
    gtk_widget_set_hexpand(view, TRUE);
    gtk_widget_set_vexpand(view, TRUE);
 
    gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scrollwin), view);
  }
 
  switch (propid) {
 
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
    /* TRANS: As in "this tile special is present". */
    add_column(view, 0, _("Present"), G_TYPE_BOOLEAN, TRUE, FALSE,
               G_CALLBACK(extviewer_view_cell_toggled), ev);
    add_column(view, 1, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    break;
 
  case OPID_TILE_VISION:
    add_column(view, 0, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 1, _("Nation"), GDK_TYPE_PIXBUF,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 3, _("Known"), G_TYPE_BOOLEAN,
               FALSE, FALSE, NULL, NULL);
    vision_layer_iterate(v) {
      add_column(view, 4 + v, vision_layer_get_name(v),
                 G_TYPE_BOOLEAN, FALSE, FALSE, NULL, NULL);
    } vision_layer_iterate_end;
    break;
 
  case OPID_CITY_BUILDINGS:
    /* TRANS: As in "this building is present". */
    add_column(view, 0, _("Present"), G_TYPE_BOOLEAN, TRUE, FALSE,
               G_CALLBACK(extviewer_view_cell_toggled), ev);
    add_column(view, 1, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    /* TRANS: As in "the turn when this building was built". */
    add_column(view, 3, _("Turn Built"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    break;
 
  case OPID_STARTPOS_NATIONS:
    /* TRANS: As in "the player has set this nation". */
    add_column(view, 0, _("Set"), G_TYPE_BOOLEAN, TRUE, FALSE,
               G_CALLBACK(extviewer_view_cell_toggled), ev);
    add_column(view, 1, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2, _("Flag"), GDK_TYPE_PIXBUF,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 3, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    break;
 
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
    /* TRANS: As in "the player has set this nation". */
    add_column(view, 0, _("Set"), G_TYPE_BOOLEAN, TRUE, TRUE,
               G_CALLBACK(extviewer_view_cell_toggled), ev);
    add_column(view, 1, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2,
               propid == OPID_PLAYER_GOV ? _("Icon") : _("Flag"),
               GDK_TYPE_PIXBUF,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 3, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    break;
 
  case OPID_PLAYER_INVENTIONS:
    /* TRANS: As in "this invention is known". */
    add_column(view, 0, _("Known"), G_TYPE_BOOLEAN, TRUE, FALSE,
               G_CALLBACK(extviewer_view_cell_toggled), ev);
    add_column(view, 1, _("ID"), G_TYPE_INT,
               FALSE, FALSE, NULL, NULL);
    add_column(view, 2, _("Name"), G_TYPE_STRING,
               FALSE, FALSE, NULL, NULL);
    break;
 
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    g_signal_connect(textbuf, "changed",
                     G_CALLBACK(extviewer_textbuf_changed), ev);
    break;
 
  default:
    log_error("Unhandled request to configure view widget "
              "for property %d (%s) in extviewer_new().",
              propid, objprop_get_name(op));
    break;
  }
 
  gtk_widget_set_visible(ev->panel_widget, TRUE);
  gtk_widget_set_visible(ev->view_widget, TRUE);
 
  return ev;
}
 
/************************************************************************/
static struct objprop *extviewer_get_objprop(struct extviewer *ev)
{
  if (!ev) {
    return NULL;
  }
  return ev->objprop;
}
 
/************************************************************************/
static GtkWidget *extviewer_get_panel_widget(struct extviewer *ev)
{
  if (!ev) {
    return NULL;
  }
  return ev->panel_widget;
}
 
/************************************************************************/
static GtkWidget *extviewer_get_view_widget(struct extviewer *ev)
{
  if (!ev) {
    return NULL;
  }
  return ev->view_widget;
}
 
/************************************************************************/
static void extviewer_refresh_widgets(struct extviewer *ev,
                                      struct propval *pv)
{
  struct objprop *op;
  enum object_property_ids propid;
  int id, turn_built;
  bool present, all;
  const char *name;
  GdkPixbuf *pixbuf;
  GtkListStore *store;
  GtkTextBuffer *textbuf;
  GtkTreeIter iter;
  gchar *buf;
 
  if (!ev) {
    return;
  }
 
  op = extviewer_get_objprop(ev);
  propid = objprop_get_id(op);
 
  if (propval_equal(pv, ev->pv_cached)) {
    return;
  }
  propval_free(ev->pv_cached);
  ev->pv_cached = propval_copy(pv);
  store = ev->store;
  textbuf = ev->textbuf;
 
 
  /* NB: Remember to have -1 as the last argument to
   * gtk_list_store_set() and to use the correct column
   * number when inserting data. :) */
  switch (propid) {
 
  case OPID_TILE_SPECIALS:
    gtk_list_store_clear(store);
    extra_type_by_cause_iterate(EC_SPECIAL, spe) {
      id = spe->data.special_idx;
      name = extra_name_translation(spe);
      present = BV_ISSET(pv->data.v_bv_special, id);
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, present, 1, id, 2, name, -1);
    } extra_type_by_cause_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_TILE_ROADS:
    gtk_list_store_clear(store);
    extra_type_by_cause_iterate(EC_ROAD, pextra) {
      struct road_type *proad = extra_road_get(pextra);
 
      id = road_number(proad);
      name = extra_name_translation(pextra);
      present = BV_ISSET(pv->data.v_bv_roads, id);
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, present, 1, id, 2, name, -1);
    } extra_type_by_cause_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_TILE_BASES:
    gtk_list_store_clear(store);
    extra_type_by_cause_iterate(EC_BASE, pextra) {
      struct base_type *pbase = extra_base_get(pextra);
 
      id = base_number(pbase);
      name = extra_name_translation(pextra);
      present = BV_ISSET(pv->data.v_bv_bases, id);
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, present, 1, id, 2, name, -1);
    } extra_type_by_cause_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_TILE_VISION:
    gtk_list_store_clear(store);
    player_slots_iterate(pslot) {
      id = player_slot_index(pslot);
      if (player_slot_is_used(pslot)) {
        struct player *pplayer = player_slot_get_player(pslot);
 
        name = player_name(pplayer);
        pixbuf = get_flag(pplayer->nation);
      } else {
        name = "";
        pixbuf = NULL;
      }
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, id, 2, name, -1);
      if (pixbuf) {
        gtk_list_store_set(store, &iter, 1, pixbuf, -1);
        g_object_unref(pixbuf);
        pixbuf = NULL;
      }
      present = BV_ISSET(pv->data.v_tile_vision->tile_known, id);
      gtk_list_store_set(store, &iter, 3, present, -1);
      vision_layer_iterate(v) {
        present = BV_ISSET(pv->data.v_tile_vision->tile_seen[v], id);
        gtk_list_store_set(store, &iter, 4 + v, present, -1);
      } vision_layer_iterate_end;
    } player_slots_iterate_end;
    break;
 
  case OPID_STARTPOS_NATIONS:
    gtk_list_store_clear(store);
    gtk_list_store_append(store, &iter);
    all = (0 == nation_hash_size(pv->data.v_nation_hash));
    gtk_list_store_set(store, &iter, 0, all, 1, -1, 3,
                       _("All nations"), -1);
    nations_iterate(pnation) {
      if (client_nation_is_in_current_set(pnation)
          && is_nation_playable(pnation)) {
        present = (!all && nation_hash_lookup(pv->data.v_nation_hash,
                                              pnation, NULL));
        id = nation_number(pnation);
        pixbuf = get_flag(pnation);
        name = nation_adjective_translation(pnation);
        gtk_list_store_append(store, &iter);
        gtk_list_store_set(store, &iter, 0, present, 1, id,
                           2, pixbuf, 3, name, -1);
        if (pixbuf) {
          g_object_unref(pixbuf);
        }
      }
    } nations_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_CITY_BUILDINGS:
    gtk_list_store_clear(store);
    improvement_iterate(pimprove) {
      if (is_special_improvement(pimprove)) {
        continue;
      }
      id = improvement_index(pimprove);
      name = improvement_name_translation(pimprove);
      turn_built = pv->data.v_built[id].turn;
      present = turn_built >= 0;
      buf = built_status_to_string(&pv->data.v_built[id]);
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, present, 1, id, 2, name,
                         3, buf, -1);
      g_free(buf);
    } improvement_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_PLAYER_NATION:
    {
      enum barbarian_type barbarian_type
        = nation_barbarian_type(pv->data.v_nation);
 
      gtk_list_store_clear(store);
      nations_iterate(pnation) {
        if (client_nation_is_in_current_set(pnation)
            && nation_barbarian_type(pnation) == barbarian_type
            && (barbarian_type != NOT_A_BARBARIAN
                || is_nation_playable(pnation))) {
          present = (pnation == pv->data.v_nation);
          id = nation_index(pnation);
          pixbuf = get_flag(pnation);
          name = nation_adjective_translation(pnation);
          gtk_list_store_append(store, &iter);
          gtk_list_store_set(store, &iter, 0, present, 1, id,
                             2, pixbuf, 3, name, -1);
          if (pixbuf) {
            g_object_unref(pixbuf);
          }
        }
      } nations_iterate_end;
      gtk_label_set_text(GTK_LABEL(ev->panel_label),
                         nation_adjective_translation(pv->data.v_nation));
      pixbuf = get_flag(pv->data.v_nation);
      gtk_image_set_from_pixbuf(GTK_IMAGE(ev->panel_image), pixbuf);
      if (pixbuf) {
        g_object_unref(pixbuf);
      }
    }
    break;
 
  case OPID_PLAYER_GOV:
    {
      gtk_list_store_clear(store);
      governments_iterate(pgov) {
        present = (pgov == pv->data.v_gov);
        id = government_index(pgov);
        pixbuf = sprite_get_pixbuf(get_government_sprite(tileset, pgov));
        name = government_name_translation(pgov);
        gtk_list_store_append(store, &iter);
        gtk_list_store_set(store, &iter, 0, present, 1, id,
                           2, pixbuf, 3, name, -1);
        if (pixbuf) {
          g_object_unref(pixbuf);
        }
      } governments_iterate_end;
      if (pv->data.v_gov != NULL) {
        gtk_label_set_text(GTK_LABEL(ev->panel_label),
                           government_name_translation(pv->data.v_gov));
        pixbuf = sprite_get_pixbuf(get_government_sprite(tileset, pv->data.v_gov));
      } else {
        gtk_label_set_text(GTK_LABEL(ev->panel_label), "?");
        pixbuf = sprite_get_pixbuf(get_government_sprite(tileset,
                                                         game.government_during_revolution));
      }
 
      gtk_image_set_from_pixbuf(GTK_IMAGE(ev->panel_image), pixbuf);
      if (pixbuf) {
        g_object_unref(pixbuf);
      }
    }
    break;
 
  case OPID_PLAYER_INVENTIONS:
    gtk_list_store_clear(store);
    advance_iterate(padvance) {
      id = advance_index(padvance);
      present = BV_ISSET(pv->data.v_bv_inventions, id);
      name = advance_name_translation(padvance);
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, present, 1, id, 2, name, -1);
    } advance_iterate_end;
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    disable_gobject_callback(G_OBJECT(ev->textbuf),
                             G_CALLBACK(extviewer_textbuf_changed));
    {
      GtkTextIter start, end;
      char *oldtext;
 
      /* Don't re-set content if unchanged, to avoid moving cursor */
      gtk_text_buffer_get_bounds(textbuf, &start, &end);
      oldtext = gtk_text_buffer_get_text(textbuf, &start, &end, TRUE);
      if (strcmp(oldtext, pv->data.v_const_string) != 0) {
        gtk_text_buffer_set_text(textbuf, pv->data.v_const_string, -1);
      }
    }
    enable_gobject_callback(G_OBJECT(ev->textbuf),
                            G_CALLBACK(extviewer_textbuf_changed));
    gtk_widget_set_sensitive(ev->view_widget, TRUE);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  default:
    log_error("Unhandled request to refresh widgets "
              "extviewer_refresh_widgets() for objprop id=%d "
              "name \"%s\".", propid, objprop_get_name(op));
    break;
  }
}
 
/************************************************************************/
static void extviewer_clear_widgets(struct extviewer *ev)
{
  struct objprop *op;
  enum object_property_ids propid;
 
  if (!ev) {
    return;
  }
 
  op = extviewer_get_objprop(ev);
  propid = objprop_get_id(op);
 
  propval_free(ev->pv_cached);
  ev->pv_cached = NULL;
 
  if (ev->panel_label != NULL) {
    gtk_label_set_text(GTK_LABEL(ev->panel_label), NULL);
  }
 
  switch (propid) {
  case OPID_TILE_SPECIALS:
  case OPID_TILE_ROADS:
  case OPID_TILE_BASES:
  case OPID_TILE_VISION:
  case OPID_STARTPOS_NATIONS:
  case OPID_CITY_BUILDINGS:
  case OPID_PLAYER_INVENTIONS:
    gtk_list_store_clear(ev->store);
    break;
  case OPID_PLAYER_NATION:
  case OPID_PLAYER_GOV:
    gtk_list_store_clear(ev->store);
    gtk_image_set_from_pixbuf(GTK_IMAGE(ev->panel_image), NULL);
    break;
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    disable_gobject_callback(G_OBJECT(ev->textbuf),
                             G_CALLBACK(extviewer_textbuf_changed));
    gtk_text_buffer_set_text(ev->textbuf, "", -1);
    enable_gobject_callback(G_OBJECT(ev->textbuf),
                            G_CALLBACK(extviewer_textbuf_changed));
    gtk_widget_set_sensitive(ev->view_widget, FALSE);
    break;
  default:
    log_error("Unhandled request to clear widgets "
              "in extviewer_clear_widgets() for objprop id=%d "
              "name \"%s\".", propid, objprop_get_name(op));
    break;
  }
}
 
/************************************************************************/
static void extviewer_panel_button_clicked(GtkButton *button,
                                           gpointer userdata)
{
  struct extviewer *ev;
  struct property_page *pp;
  struct objprop *op;
 
  ev = userdata;
  if (!ev) {
    return;
  }
 
  op = extviewer_get_objprop(ev);
  pp = objprop_get_property_page(op);
  property_page_show_extviewer(pp, ev);
}
 
/************************************************************************/
static void extviewer_view_cell_toggled(GtkCellRendererToggle *cell,
                                        gchar *path,
                                        gpointer userdata)
{
  struct extviewer *ev;
  struct objprop *op;
  struct property_page *pp;
  enum object_property_ids propid;
  GtkTreeModel *model;
  GtkTreeIter iter;
  int id, old_id, turn_built;
  struct propval *pv;
  bool active, present;
  gchar *buf;
  GdkPixbuf *pixbuf = NULL;
 
  ev = userdata;
  if (!ev) {
    return;
  }
 
  pv = ev->pv_cached;
  if (!pv) {
    return;
  }
 
  op = extviewer_get_objprop(ev);
  propid = objprop_get_id(op);
  active = gtk_cell_renderer_toggle_get_active(cell);
  pp = objprop_get_property_page(op);
 
  model = GTK_TREE_MODEL(ev->store);
  if (!gtk_tree_model_get_iter_from_string(model, &iter, path)) {
    return;
  }
  present = !active;
 
 
  switch (propid) {
 
  case OPID_TILE_SPECIALS:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (id < 0 || id >= extra_type_list_size(extra_type_list_by_cause(EC_SPECIAL))) {
      return;
    }
    if (present) {
      BV_SET(pv->data.v_bv_special, id);
    } else {
      BV_CLR(pv->data.v_bv_special, id);
    }
    gtk_list_store_set(ev->store, &iter, 0, present, -1);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_TILE_ROADS:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(0 <= id && id < road_count())) {
      return;
    }
    if (present) {
      BV_SET(pv->data.v_bv_roads, id);
    } else {
      BV_CLR(pv->data.v_bv_roads, id);
    }
    gtk_list_store_set(ev->store, &iter, 0, present, -1);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_TILE_BASES:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(0 <= id && id < base_count())) {
      return;
    }
    if (present) {
      BV_SET(pv->data.v_bv_bases, id);
    } else {
      BV_CLR(pv->data.v_bv_bases, id);
    }
    gtk_list_store_set(ev->store, &iter, 0, present, -1);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_STARTPOS_NATIONS:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (-1 > id && id >= nation_count()) {
      return;
    }
 
    if (-1 == id) {
      gtk_list_store_set(ev->store, &iter, 0, present, -1);
      gtk_tree_model_get_iter_first(model, &iter);
      if (present) {
        while (gtk_tree_model_iter_next(model, &iter)) {
          gtk_list_store_set(ev->store, &iter, 0, FALSE, -1);
        }
        nation_hash_clear(pv->data.v_nation_hash);
      } else {
        const struct nation_type *pnation;
        int id2;
 
        gtk_tree_model_iter_next(model, &iter);
        gtk_tree_model_get(model, &iter, 0, &id2, -1);
        gtk_list_store_set(ev->store, &iter, 0, TRUE, -1);
        pnation = nation_by_number(id2);
        nation_hash_insert(pv->data.v_nation_hash, pnation, NULL);
      }
    } else {
      const struct nation_type *pnation;
      bool all;
 
      gtk_list_store_set(ev->store, &iter, 0, present, -1);
      pnation = nation_by_number(id);
      if (present) {
        nation_hash_insert(pv->data.v_nation_hash, pnation, NULL);
      } else {
        nation_hash_remove(pv->data.v_nation_hash, pnation);
      }
      gtk_tree_model_get_iter_first(model, &iter);
      all = (0 == nation_hash_size(pv->data.v_nation_hash));
      gtk_list_store_set(ev->store, &iter, 0, all, -1);
    }
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_CITY_BUILDINGS:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(0 <= id && id < B_LAST)) {
      return;
    }
    turn_built = present ? game.info.turn : I_NEVER;
    pv->data.v_built[id].turn = turn_built;
    buf = built_status_to_string(&pv->data.v_built[id]);
    gtk_list_store_set(ev->store, &iter, 0, present, 3, buf, -1);
    g_free(buf);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  case OPID_PLAYER_NATION:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(0 <= id && id < nation_count()) || !present) {
      return;
    }
    old_id = nation_index(pv->data.v_nation);
    pv->data.v_nation = nation_by_number(id);
    gtk_list_store_set(ev->store, &iter, 0, TRUE, -1);
    gtk_tree_model_iter_nth_child(model, &iter, NULL, old_id);
    gtk_list_store_set(ev->store, &iter, 0, FALSE, -1);
    gtk_label_set_text(GTK_LABEL(ev->panel_label),
                       nation_adjective_translation(pv->data.v_nation));
    pixbuf = get_flag(pv->data.v_nation);
    gtk_image_set_from_pixbuf(GTK_IMAGE(ev->panel_image), pixbuf);
    if (pixbuf) {
      g_object_unref(pixbuf);
    }
    break;
 
  case OPID_PLAYER_GOV:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(0 <= id && id < government_count()) || !present) {
      return;
    }
    if (pv->data.v_gov != NULL) {
      old_id = government_index(pv->data.v_gov);
      pv->data.v_gov = government_by_number(id);
      gtk_list_store_set(ev->store, &iter, 0, TRUE, -1);
      gtk_tree_model_iter_nth_child(model, &iter, NULL, old_id);
      gtk_list_store_set(ev->store, &iter, 0, FALSE, -1);
    } else {
      pv->data.v_gov = government_by_number(id);
      gtk_list_store_set(ev->store, &iter, 0, TRUE, -1);
    }
 
    gtk_label_set_text(GTK_LABEL(ev->panel_label),
                       government_name_translation(pv->data.v_gov));
    pixbuf = sprite_get_pixbuf(get_government_sprite(tileset, pv->data.v_gov));
    gtk_image_set_from_pixbuf(GTK_IMAGE(ev->panel_image), pixbuf);
    if (pixbuf) {
      g_object_unref(pixbuf);
    }
    break;
 
  case OPID_PLAYER_INVENTIONS:
    gtk_tree_model_get(model, &iter, 1, &id, -1);
    if (!(A_FIRST <= id && id < advance_count())) {
      return;
    }
    if (present) {
      BV_SET(pv->data.v_bv_inventions, id);
    } else {
      BV_CLR(pv->data.v_bv_inventions, id);
    }
    gtk_list_store_set(ev->store, &iter, 0, present, -1);
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
 
  default:
    log_error("Unhandled widget toggled signal in "
              "extviewer_view_cell_toggled() for objprop id=%d "
              "name \"%s\".", propid, objprop_get_name(op));
    return;
    break;
  }
 
  property_page_change_value(pp, op, pv);
}
 
/************************************************************************/
static void extviewer_textbuf_changed(GtkTextBuffer *textbuf,
                                      gpointer userdata)
{
  struct extviewer *ev;
  struct objprop *op;
  struct property_page *pp;
  enum object_property_ids propid;
  struct propval value = {{0,}, VALTYPE_STRING, FALSE}, *pv;
  GtkTextIter start, end;
  char *text;
  gchar *buf;
 
  ev = userdata;
  if (!ev) {
    return;
  }
 
  op = extviewer_get_objprop(ev);
  propid = objprop_get_id(op);
  pp = objprop_get_property_page(op);
 
  gtk_text_buffer_get_start_iter(textbuf, &start);
  gtk_text_buffer_get_end_iter(textbuf, &end);
  text = gtk_text_buffer_get_text(textbuf, &start, &end, FALSE);
  value.data.v_const_string = text;
  pv = &value;
 
  switch (propid) {
  case OPID_GAME_SCENARIO_AUTHORS:
  case OPID_GAME_SCENARIO_DESC:
    buf = propval_as_string(pv);
    gtk_label_set_text(GTK_LABEL(ev->panel_label), buf);
    g_free(buf);
    break;
  default:
    log_error("Unhandled widget modified signal in "
              "extviewer_textbuf_changed() for objprop id=%d "
              "name \"%s\".", propid, objprop_get_name(op));
    return;
    break;
  }
 
  property_page_change_value(pp, op, pv);
  g_free(text);
}
 
/************************************************************************/
static void property_page_setup_objprops(struct property_page *pp)
{
#define ADDPROP(ARG_id, ARG_name, ARG_tooltip, ARG_flags, ARG_valtype) do { \
  struct objprop *MY_op = objprop_new(ARG_id, ARG_name, ARG_tooltip, \
                                      ARG_flags, ARG_valtype, pp); \
  objprop_hash_insert(pp->objprop_table, MY_op->id, MY_op); \
} while (FALSE)
 
  switch (property_page_get_objtype(pp)) {
  case OBJTYPE_TILE:
    ADDPROP(OPID_TILE_IMAGE, _("Image"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_PIXBUF);
    ADDPROP(OPID_TILE_TERRAIN, _("Terrain"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_TILE_RESOURCE, _("Resource"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_TILE_INDEX, _("Index"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_TILE_X, Q_("?coordinate:X"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_TILE_Y, Q_("?coordinate:Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    /* TRANS: The coordinate X in native coordinates.
     * The freeciv coordinate system is described in doc/HACKING. */
    ADDPROP(OPID_TILE_NAT_X, _("NAT X"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    /* TRANS: The coordinate Y in native coordinates.
     * The freeciv coordinate system is described in doc/HACKING. */
    ADDPROP(OPID_TILE_NAT_Y, _("NAT Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_TILE_CONTINENT, _("Continent"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_TILE_XY, Q_("?coordinates:X,Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_TILE_SPECIALS, _("Specials"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_BV_SPECIAL);
    ADDPROP(OPID_TILE_ROADS, _("Roads"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_BV_ROADS);
    ADDPROP(OPID_TILE_BASES, _("Bases"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_BV_BASES);
#ifdef FREECIV_DEBUG
    ADDPROP(OPID_TILE_ADDRESS, _("Address"), NULL,
            OPF_HAS_WIDGET, VALTYPE_STRING);
#endif /* FREECIV_DEBUG */
#if 0
    /* Disabled entirely for now as server is not sending other
     * players' vision information anyway. */
    ADDPROP(OPID_TILE_VISION, _("Vision"), NULL,
            OPF_HAS_WIDGET, VALTYPE_TILE_VISION_DATA);
#endif
    /* TRANS: Tile property "Label" label in editor */
    ADDPROP(OPID_TILE_LABEL, Q_("?property:Label"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_STRING);
    return;
 
  case OBJTYPE_STARTPOS:
    ADDPROP(OPID_STARTPOS_IMAGE, _("Image"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_PIXBUF);
    ADDPROP(OPID_STARTPOS_XY, Q_("?coordinates:X,Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_STARTPOS_EXCLUDE, _("Exclude Nations"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_STARTPOS_NATIONS, _("Nations"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_NATION_HASH);
    return;
 
  case OBJTYPE_UNIT:
    ADDPROP(OPID_UNIT_IMAGE, _("Image"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_PIXBUF);
#ifdef FREECIV_DEBUG
    ADDPROP(OPID_UNIT_ADDRESS, _("Address"), NULL,
            OPF_HAS_WIDGET, VALTYPE_STRING);
#endif /* FREECIV_DEBUG */
    ADDPROP(OPID_UNIT_TYPE, _("Type"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_UNIT_ID, _("ID"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_UNIT_XY, Q_("?coordinates:X,Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_UNIT_MOVES_LEFT, _("Moves Left"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_UNIT_FUEL, _("Fuel"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_UNIT_MOVED, _("Moved"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_UNIT_DONE_MOVING, _("Done Moving"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    /* TRANS: HP = Hit Points of a unit. */
    ADDPROP(OPID_UNIT_HP, _("HP"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_UNIT_VETERAN, _("Veteran"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_UNIT_STAY, _("Stay put"), NULL,
            OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    return;
 
  case OBJTYPE_CITY:
    ADDPROP(OPID_CITY_IMAGE, _("Image"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_PIXBUF);
    ADDPROP(OPID_CITY_NAME, _("Name"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_STRING);
#ifdef FREECIV_DEBUG
    ADDPROP(OPID_CITY_ADDRESS, _("Address"), NULL,
            OPF_HAS_WIDGET, VALTYPE_STRING);
#endif /* FREECIV_DEBUG */
    ADDPROP(OPID_CITY_ID, _("ID"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_CITY_XY, Q_("?coordinates:X,Y"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET, VALTYPE_STRING);
    ADDPROP(OPID_CITY_SIZE, _("Size"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_CITY_HISTORY, _("History"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_CITY_BUILDINGS, _("Buildings"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_BUILT_ARRAY);
    ADDPROP(OPID_CITY_FOOD_STOCK, _("Food Stock"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_CITY_SHIELD_STOCK, _("Shield Stock"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    return;
 
  case OBJTYPE_PLAYER:
    ADDPROP(OPID_PLAYER_NAME, _("Name"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_STRING);
#ifdef FREECIV_DEBUG
    ADDPROP(OPID_PLAYER_ADDRESS, _("Address"), NULL,
            OPF_HAS_WIDGET, VALTYPE_STRING);
#endif /* FREECIV_DEBUG */
    ADDPROP(OPID_PLAYER_NATION, _("Nation"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_NATION);
    ADDPROP(OPID_PLAYER_GOV, _("Government"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_GOV);
    ADDPROP(OPID_PLAYER_AGE, _("Age"), NULL,
            OPF_HAS_WIDGET, VALTYPE_INT);
    ADDPROP(OPID_PLAYER_INVENTIONS, _("Inventions"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_INVENTIONS_ARRAY);
    ADDPROP(OPID_PLAYER_SCENARIO_RESERVED, _("Reserved"), NULL,
            OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_PLAYER_SELECT_WEIGHT, _("Select Weight"),
            _("How likely user is to get this player by autoselect. '-1' for default behavior."),
            OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_INT);
    ADDPROP(OPID_PLAYER_SCIENCE, _("Science"), NULL,
            OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_INT);
    ADDPROP(OPID_PLAYER_GOLD, _("Gold"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_INT);
    ADDPROP(OPID_PLAYER_INFRAPOINTS, _("Infrapoints"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_INT);
    return;
 
  case OBJTYPE_GAME:
    ADDPROP(OPID_GAME_SCENARIO, _("Scenario"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_BOOL);
    ADDPROP(OPID_GAME_SCENARIO_NAME,
            _("Scenario Name"),  NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_STRING);
    ADDPROP(OPID_GAME_SCENARIO_AUTHORS,
            _("Scenario Authors"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_STRING);
    ADDPROP(OPID_GAME_SCENARIO_DESC,
            _("Scenario Description"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE,
            VALTYPE_STRING);
    ADDPROP(OPID_GAME_SCENARIO_RANDSTATE,
            _("Save Random Number State"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_GAME_SCENARIO_PLAYERS,
            _("Save Players"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_GAME_STARTPOS_NATIONS,
            _("Nation Start Positions"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_GAME_PREVENT_CITIES,
            _("Prevent New Cities"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_GAME_LAKE_FLOODING,
            _("Saltwater Flooding Lakes"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    ADDPROP(OPID_GAME_RULESET_LOCKED,
            _("Lock to current Ruleset"), NULL,
            OPF_IN_LISTVIEW | OPF_HAS_WIDGET | OPF_EDITABLE, VALTYPE_BOOL);
    return;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled page object type %s (nb %d).", __FUNCTION__,
            objtype_get_name(property_page_get_objtype(pp)),
            property_page_get_objtype(pp));
#undef ADDPROP
}
 
/************************************************************************/
static void property_page_selection_changed(GtkTreeSelection *sel,
                                            gpointer userdata)
{
  struct property_page *pp;
  struct objbind *ob = NULL;
 
  pp = userdata;
  if (!pp) {
    return;
  }
 
  if (gtk_tree_selection_count_selected_rows(sel) < 1) {
    property_page_set_focused_objbind(pp, NULL);
  }
 
  ob = property_page_get_focused_objbind(pp);
  property_page_objprop_iterate(pp, op) {
    objprop_refresh_widget(op, ob);
  } property_page_objprop_iterate_end;
}
 
/************************************************************************/
static gboolean property_page_selection_func(GtkTreeSelection *sel,
                                             GtkTreeModel *model,
                                             GtkTreePath *sel_path,
                                             gboolean currently_selected,
                                             gpointer data)
{
  struct property_page *pp;
  struct objbind *ob = NULL, *old_ob;
  GtkTreeIter iter;
 
  pp = data;
  if (!pp || !sel_path) {
    return TRUE;
  }
 
  if (!gtk_tree_model_get_iter(model, &iter, sel_path)) {
    return TRUE;
  }
 
  old_ob = property_page_get_focused_objbind(pp);
  gtk_tree_model_get(model, &iter, 0, &ob, -1);
  if (currently_selected) {
    if (ob == old_ob) {
      GList *rows, *p;
      GtkTreePath *path;
      struct objbind *new_ob = NULL;
 
      rows = gtk_tree_selection_get_selected_rows(sel, NULL);
      for (p = rows; p != NULL; p = p->next) {
        path = p->data;
        if (gtk_tree_model_get_iter(model, &iter, path)) {
          struct objbind *test_ob = NULL;
          gtk_tree_model_get(model, &iter, 0, &test_ob, -1);
          if (test_ob == ob) {
            continue;
          }
          new_ob = test_ob;
          break;
        }
      }
      g_list_foreach(rows, (GFunc) gtk_tree_path_free, NULL);
      g_list_free(rows);
 
      property_page_set_focused_objbind(pp, new_ob);
    }
  } else {
    property_page_set_focused_objbind(pp, ob);
  }
 
  return TRUE;
}
 
/************************************************************************/
static void property_page_quick_find_entry_changed(GtkWidget *entry,
                                                   gpointer userdata)
{
  struct property_page *pp;
  const gchar *text;
  GtkWidget *w;
  GtkTreeViewColumn *col;
  struct property_filter *pf;
  bool matched;
 
  pp = userdata;
  text = gtk_entry_buffer_get_text(gtk_entry_get_buffer(GTK_ENTRY(entry)));
  pf = property_filter_new(text);
 
  property_page_objprop_iterate(pp, op) {
    if (!objprop_has_widget(op)
        && !objprop_show_in_listview(op)) {
      continue;
    }
    matched = property_filter_match(pf, op);
    w = objprop_get_widget(op);
    if (objprop_has_widget(op) && w != nullptr) {
      gtk_widget_set_visible(w, matched);
    }
    col = objprop_get_treeview_column(op);
    if (objprop_show_in_listview(op) && col != nullptr) {
      gtk_tree_view_column_set_visible(col, matched);
    }
  } property_page_objprop_iterate_end;
 
  property_filter_free(pf);
}
 
/************************************************************************/
static struct property_page *
property_page_new(enum editor_object_type objtype,
                  struct property_editor *pe)
{
  struct property_page *pp;
  GtkWidget *vgrid, *vgrid2, *hgrid, *hgrid2, *paned, *frame, *w;
  GtkWidget *scrollwin, *view, *label, *entry, *notebook;
  GtkWidget *button, *hsep;
  GtkTreeSelection *sel;
  GtkCellRenderer *cell;
  GtkTreeViewColumn *col;
  GtkSizeGroup *sizegroup;
  int num_columns = 0;
  GType *gtype_array;
  int col_id = 1;
  const char *attr_type_str, *name, *tooltip;
  gchar *title;
  int grid_row = 0;
  int grid2_row = 0;
  int grid_col = 0;
  int grid2_col = 0;
 
  if (!(objtype < NUM_OBJTYPES)) {
    return NULL;
  }
 
  pp = fc_calloc(1, sizeof(struct property_page));
  pp->objtype = objtype;
  pp->pe_parent = pe;
 
  sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
 
  pp->objprop_table = objprop_hash_new();
  property_page_setup_objprops(pp);
 
  pp->objbind_table = objbind_hash_new();
 
  pp->tag_table = stored_tag_hash_new();
 
  property_page_objprop_iterate(pp, op) {
    if (objprop_show_in_listview(op)) {
      num_columns++;
    }
  } property_page_objprop_iterate_end;
 
  /* Column zero in the store holds an objbind
   * pointer and is never displayed. */
  num_columns++;
  gtype_array = fc_malloc(num_columns * sizeof(GType));
  gtype_array[0] = G_TYPE_POINTER;
 
  property_page_objprop_iterate(pp, op) {
    if (objprop_show_in_listview(op)) {
      gtype_array[col_id] = objprop_get_gtype(op);
      objprop_set_column_id(op, col_id);
      col_id++;
    }
  } property_page_objprop_iterate_end;
 
  pp->object_store = gtk_list_store_newv(num_columns, gtype_array);
  free(gtype_array);
 
  paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
  gtk_paned_set_position(GTK_PANED(paned), 256);
  pp->widget = paned;
 
  /* Left side object list view. */
 
  vgrid = gtk_grid_new();
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
                                 GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_spacing(GTK_GRID(vgrid), 4);
  gtk_widget_set_margin_start(vgrid, 4);
  gtk_widget_set_margin_end(vgrid, 4);
  gtk_widget_set_margin_top(vgrid, 4);
  gtk_widget_set_margin_bottom(vgrid, 4);
  gtk_paned_set_start_child(GTK_PANED(paned), vgrid);
 
  scrollwin = gtk_scrolled_window_new();
  gtk_scrolled_window_set_has_frame(GTK_SCROLLED_WINDOW(scrollwin),
                                    TRUE);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
                                 GTK_POLICY_AUTOMATIC,
                                 GTK_POLICY_AUTOMATIC);
  gtk_grid_attach(GTK_GRID(vgrid), scrollwin, 0, grid_row++, 1, 1);
 
  view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pp->object_store));
  gtk_widget_set_hexpand(view, TRUE);
  gtk_widget_set_vexpand(view, TRUE);
 
  property_page_objprop_iterate(pp, op) {
    if (!objprop_show_in_listview(op)) {
      continue;
    }
 
    attr_type_str = objprop_get_attribute_type_string(op);
    if (!attr_type_str) {
      continue;
    }
    col_id = objprop_get_column_id(op);
    if (col_id < 0) {
      continue;
    }
    name = objprop_get_name(op);
    if (!name) {
      continue;
    }
    cell = objprop_create_cell_renderer(op);
    if (!cell) {
      continue;
    }
 
    col = gtk_tree_view_column_new_with_attributes(name, cell,
                                                   attr_type_str, col_id,
                                                   NULL);
 
    gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
    gtk_tree_view_column_set_resizable(col, TRUE);
    gtk_tree_view_column_set_reorderable(col, TRUE);
    if (objprop_is_sortable(op)) {
      gtk_tree_view_column_set_clickable(col, TRUE);
      gtk_tree_view_column_set_sort_column_id(col, col_id);
    } else {
      gtk_tree_view_column_set_clickable(col, FALSE);
    }
    gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
    objprop_set_treeview_column(op, col);
 
  } property_page_objprop_iterate_end;
 
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
  g_signal_connect(sel, "changed",
                   G_CALLBACK(property_page_selection_changed), pp);
  gtk_tree_selection_set_select_function(sel,
      property_page_selection_func, pp, NULL);
 
  gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scrollwin), view);
  pp->object_view = view;
 
  if (!objtype_is_conserved(objtype)) {
    hgrid = gtk_grid_new();
    gtk_grid_set_column_spacing(GTK_GRID(hgrid), 4);
    gtk_grid_attach(GTK_GRID(vgrid), hgrid, 0, grid_row++, 1, 1);
 
    button = gtk_button_new();
    gtk_button_set_icon_name(GTK_BUTTON(button), "list-add");
    gtk_button_set_label(GTK_BUTTON(button), _("Create"));
    gtk_size_group_add_widget(sizegroup, button);
    gtk_widget_set_tooltip_text(button,
        _("Pressing this button will create a new object of the "
          "same type as the current property page and add it to "
          "the page. The specific type and count of the objects "
          "is taken from the editor tool state. So for example, "
          "the \"tool value\" of the unit tool and its \"count\" "
          "parameter affect unit creation."));
    g_signal_connect(button, "clicked",
                     G_CALLBACK(property_page_create_button_clicked), pp);
    gtk_grid_attach(GTK_GRID(hgrid), button, grid_col++, 0, 1, 1);
 
    button = gtk_button_new();
    gtk_button_set_icon_name(GTK_BUTTON(button), "list-remove");
    gtk_button_set_label(GTK_BUTTON(button), _("Destroy"));
    gtk_size_group_add_widget(sizegroup, button);
    gtk_widget_set_tooltip_text(button,
        _("Pressing this button will send a request to the server "
          "to destroy (i.e. erase) the objects selected in the object "
          "list."));
    g_signal_connect(button, "clicked",
                     G_CALLBACK(property_page_destroy_button_clicked), pp);
    gtk_grid_attach(GTK_GRID(hgrid), button, grid_col++, 0, 1, 1);
  }
 
  /* Right side properties panel. */
 
  hgrid = gtk_grid_new();
  grid_col = 0;
  gtk_grid_set_column_spacing(GTK_GRID(hgrid), 4);
  gtk_paned_set_end_child(GTK_PANED(paned), hgrid);
 
  vgrid = gtk_grid_new();
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid),
                                 GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_spacing(GTK_GRID(vgrid), 4);
  gtk_widget_set_margin_start(vgrid, 4);
  gtk_widget_set_margin_end(vgrid, 4);
  gtk_widget_set_margin_top(vgrid, 4);
  gtk_widget_set_margin_bottom(vgrid, 4);
  gtk_grid_attach(GTK_GRID(hgrid), vgrid, grid_col++, 0, 1, 1);
 
  /* Extended property viewer to the right of the properties panel.
   * This needs to be created before property widgets, since some
   * might try to append themselves to this notebook. */
 
  vgrid2 = gtk_grid_new();
  gtk_widget_set_hexpand(vgrid2, TRUE);
  gtk_widget_set_vexpand(vgrid, TRUE);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid2),
                                 GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_spacing(GTK_GRID(vgrid2), 4);
  gtk_grid_attach(GTK_GRID(hgrid), vgrid2, grid_col++, 0, 1, 1);
 
  notebook = gtk_notebook_new();
  gtk_widget_set_vexpand(notebook, TRUE);
  gtk_widget_set_size_request(notebook, 256, -1);
  gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
  gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
  gtk_grid_attach(GTK_GRID(vgrid2), notebook, 0, grid2_row++, 1, 1);
  pp->extviewer_notebook = notebook;
 
  hsep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
  gtk_grid_attach(GTK_GRID(vgrid2), hsep, 0, grid2_row++, 1, 1);
 
  hgrid2 = gtk_grid_new();
  gtk_widget_set_margin_start(hgrid2, 4);
  gtk_widget_set_margin_end(hgrid2, 4);
  gtk_widget_set_margin_top(hgrid2, 4);
  gtk_widget_set_margin_bottom(hgrid2, 4);
  gtk_grid_attach(GTK_GRID(vgrid2), hgrid2, 0, grid2_row++, 1, 1);
 
  button = gtk_button_new_with_mnemonic(_("_Close"));
  gtk_size_group_add_widget(sizegroup, button);
  g_signal_connect_swapped(button, "clicked",
                           G_CALLBACK(gtk_window_close), pe->widget);
  gtk_grid_attach(GTK_GRID(hgrid2), button, grid2_col++, 0, 1, 1);
 
  /* Now create the properties panel. */
 
  /* TRANS: %s is a type of object that can be edited, such as "Tile",
   * "Unit", "Start Position", etc. */
  title = g_strdup_printf(_("%s Properties"),
                          objtype_get_name(objtype));
  frame = gtk_frame_new(title);
  g_free(title);
  gtk_widget_set_size_request(frame, 256, -1);
  gtk_grid_attach(GTK_GRID(vgrid), frame, 0, grid_row++, 1, 1);
 
  scrollwin = gtk_scrolled_window_new();
  gtk_scrolled_window_set_has_frame(GTK_SCROLLED_WINDOW(scrollwin),
                                    FALSE);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
                                 GTK_POLICY_AUTOMATIC,
                                 GTK_POLICY_AUTOMATIC);
  gtk_frame_set_child(GTK_FRAME(frame), scrollwin);
 
  vgrid2 = gtk_grid_new();
  grid2_row = 0;
  gtk_widget_set_vexpand(vgrid2, TRUE);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vgrid2),
                                 GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_spacing(GTK_GRID(vgrid2), 4);
  gtk_widget_set_margin_start(vgrid2, 4);
  gtk_widget_set_margin_end(vgrid2, 4);
  gtk_widget_set_margin_top(vgrid2, 4);
  gtk_widget_set_margin_bottom(vgrid2, 4);
  gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scrollwin), vgrid2);
 
  property_page_objprop_iterate(pp, op) {
    if (!objprop_has_widget(op)) {
      continue;
    }
    w = objprop_get_widget(op);
    if (!w) {
      continue;
    }
    gtk_grid_attach(GTK_GRID(vgrid2), w, 0, grid2_row++, 1, 1);
    tooltip = objprop_get_tooltip(op);
    if (NULL != tooltip) {
      gtk_widget_set_tooltip_text(w, tooltip);
    }
  } property_page_objprop_iterate_end;
 
  hgrid2 = gtk_grid_new();
  grid2_col = 0;
  gtk_widget_set_margin_top(hgrid2, 4);
  gtk_widget_set_margin_bottom(hgrid2, 4);
  gtk_grid_set_column_spacing(GTK_GRID(hgrid2), 4);
  gtk_grid_attach(GTK_GRID(vgrid), hgrid2, 0, grid_row++, 1, 1);
 
  label = gtk_label_new(_("Filter:"));
  gtk_grid_attach(GTK_GRID(hgrid2), label, grid2_col++, 0, 1, 1);
 
  entry = gtk_entry_new();
  gtk_widget_set_tooltip_text(entry,
      _("Enter a filter string to limit which properties are shown. "
        "The filter is one or more text patterns separated by | "
        "(\"or\") or & (\"and\"). The symbol & has higher precedence "
        "than |. A pattern may also be negated by prefixing it with !."));
  g_signal_connect(entry, "changed",
      G_CALLBACK(property_page_quick_find_entry_changed), pp);
  gtk_grid_attach(GTK_GRID(hgrid2), entry, grid2_col++, 0, 1, 1);
 
  hgrid2 = gtk_grid_new();
  grid2_col = 0;
  gtk_grid_set_column_spacing(GTK_GRID(hgrid2), 4);
  gtk_grid_attach(GTK_GRID(vgrid), hgrid2, 0, grid_row++, 1, 1);
 
  button = gtk_button_new_with_mnemonic(_("_Refresh"));
  gtk_size_group_add_widget(sizegroup, button);
  gtk_widget_set_tooltip_text(button,
      _("Pressing this button will reset all modified properties of "
        "the selected objects to their current values (the values "
        "they have on the server)."));
  g_signal_connect(button, "clicked",
                   G_CALLBACK(property_page_refresh_button_clicked), pp);
  gtk_grid_attach(GTK_GRID(hgrid2), button, grid2_col++, 0, 1, 1);
 
  button = gtk_button_new_with_mnemonic(_("_Apply"));
  gtk_size_group_add_widget(sizegroup, button);
  gtk_widget_set_tooltip_text(button,
      _("Pressing this button will send all modified properties of "
        "the objects selected in the object list to the server. "
        "Modified properties' names are shown in red in the properties "
        "panel."));
  g_signal_connect(button, "clicked",
                   G_CALLBACK(property_page_apply_button_clicked), pp);
  gtk_grid_attach(GTK_GRID(hgrid2), button, grid2_col++, 0, 1, 1);
 
  return pp;
}
 
/************************************************************************/
static const char *property_page_get_name(const struct property_page *pp)
{
  if (!pp) {
    return "";
  }
  return objtype_get_name(property_page_get_objtype(pp));
}
 
/************************************************************************/
static enum editor_object_type
property_page_get_objtype(const struct property_page *pp)
{
  if (!pp) {
    return -1;
  }
  return pp->objtype;
}
 
/************************************************************************/
static GdkPixbuf *create_tile_pixbuf(const struct tile *ptile)
{
  return create_pixbuf_from_layers(ptile, NULL, NULL, LAYER_CATEGORY_TILE);
}
 
/************************************************************************/
static GdkPixbuf *create_unit_pixbuf(const struct unit *punit)
{
  return create_pixbuf_from_layers(NULL, punit, NULL, LAYER_CATEGORY_UNIT);
}
 
/************************************************************************/
static GdkPixbuf *create_city_pixbuf(const struct city *pcity)
{
  return create_pixbuf_from_layers(city_tile(pcity), NULL, pcity,
                                   LAYER_CATEGORY_CITY);
}
 
/************************************************************************/
static GdkPixbuf *create_pixbuf_from_layers(const struct tile *ptile,
                                            const struct unit *punit,
                                            const struct city *pcity,
                                            enum layer_category category)
{
  struct canvas canvas = FC_STATIC_CANVAS_INIT;
  int h, fh, fw, canvas_x, canvas_y;
  GdkPixbuf *pixbuf;
  cairo_t *cr;
 
  fw = tileset_full_tile_width(tileset);
  fh = tileset_full_tile_height(tileset);
  h = tileset_tile_height(tileset);
 
  canvas.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, fw, fh);
 
  cr = cairo_create(canvas.surface);
  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
  cairo_paint(cr);
  cairo_destroy(cr);
 
  canvas_x = 0;
  canvas_y = 0;
 
  canvas_y += (fh - h);
 
  mapview_layer_iterate(layer) {
    if (tileset_layer_in_category(layer, category)) {
      put_one_element(&canvas, 1.0, layer,
                      ptile, NULL, NULL, punit, pcity,
                      canvas_x, canvas_y, NULL, NULL);
    }
  } mapview_layer_iterate_end
  pixbuf = surface_get_pixbuf(canvas.surface, fw, fh);
  cairo_surface_destroy(canvas.surface);
 
  return pixbuf;
}
 
/************************************************************************/
static void property_page_clear_objbinds(struct property_page *pp)
{
  if (!pp) {
    return;
  }
 
  gtk_list_store_clear(pp->object_store);
  objbind_hash_clear(pp->objbind_table);
  property_page_set_focused_objbind(pp, NULL);
}
 
/************************************************************************/
static void property_page_add_objbind(struct property_page *pp,
                                      gpointer object_data)
{
  struct objbind *ob;
  enum editor_object_type objtype;
  int id;
 
  if (!pp) {
    return;
  }
 
  objtype = property_page_get_objtype(pp);
  id = objtype_get_id_from_object(objtype, object_data);
  if (id < 0) {
    return;
  }
 
  if (objbind_hash_lookup(pp->objbind_table, id, NULL)) {
    /* Object already exists. */
    return;
  }
 
  ob = objbind_new(objtype, object_data);
  if (!ob) {
    return;
  }
 
  objbind_bind_properties(ob, pp);
 
  objbind_hash_insert(pp->objbind_table, ob->object_id, ob);
}
 
/************************************************************************/
static void property_page_add_objbinds_from_tile(struct property_page *pp,
                                                 const struct tile *ptile)
{
 
  if (!pp || !ptile) {
    return;
  }
 
  switch (property_page_get_objtype(pp)) {
  case OBJTYPE_TILE:
    property_page_add_objbind(pp, (gpointer) ptile);
    return;
 
  case OBJTYPE_STARTPOS:
    {
      struct startpos *psp = map_startpos_get(ptile);
 
      if (NULL != psp) {
        property_page_add_objbind(pp, map_startpos_get(ptile));
      }
    }
    return;
 
  case OBJTYPE_UNIT:
    unit_list_iterate(ptile->units, punit) {
      property_page_add_objbind(pp, punit);
    } unit_list_iterate_end;
    return;
 
  case OBJTYPE_CITY:
    if (tile_city(ptile)) {
      property_page_add_objbind(pp, tile_city(ptile));
    }
    return;
 
  case OBJTYPE_PLAYER:
  case OBJTYPE_GAME:
    return;
 
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled page object type %s (nb %d).", __FUNCTION__,
            objtype_get_name(property_page_get_objtype(pp)),
            property_page_get_objtype(pp));
}
 
/************************************************************************/
static bool property_page_set_store_value(struct property_page *pp,
                                          struct objprop *op,
                                          struct objbind *ob,
                                          GtkTreeIter *iter)
{
  int col_id;
  struct propval *pv;
  enum value_types valtype;
  char buf[128], *p;
  GdkPixbuf *pixbuf = NULL;
  GtkListStore *store;
  gchar *buf2;
 
  if (!pp || !pp->object_store || !op || !ob) {
    return FALSE;
  }
 
  if (!objprop_show_in_listview(op)) {
    return FALSE;
  }
 
  col_id = objprop_get_column_id(op);
  if (col_id < 0) {
    return FALSE;
  }
 
  pv = objbind_get_value_from_object(ob, op);
  if (!pv) {
    return FALSE;
  }
 
  valtype = objprop_get_valtype(op);
  store = pp->object_store;
 
  switch (valtype) {
  case VALTYPE_NONE:
    break;
  case VALTYPE_INT:
    gtk_list_store_set(store, iter, col_id, pv->data.v_int, -1);
    break;
  case VALTYPE_BOOL:
    /* Set as translated string, not as untranslated G_TYPE_BOOLEAN */
    gtk_list_store_set(store, iter, col_id, propval_as_string(pv), -1);
    break;
  case VALTYPE_STRING:
    if (fc_strlcpy(buf, pv->data.v_string, 28) >= 28) {
      sz_strlcat(buf, "...");
    }
    for (p = buf; *p; p++) {
      if (*p == '\n' || *p == '\t' || *p == '\r') {
        *p = ' ';
      }
    }
    gtk_list_store_set(store, iter, col_id, buf, -1);
    break;
  case VALTYPE_PIXBUF:
    gtk_list_store_set(store, iter, col_id, pv->data.v_pixbuf, -1);
    break;
  case VALTYPE_BUILT_ARRAY:
  case VALTYPE_INVENTIONS_ARRAY:
  case VALTYPE_BV_SPECIAL:
  case VALTYPE_BV_ROADS:
  case VALTYPE_BV_BASES:
  case VALTYPE_NATION_HASH:
    buf2 = propval_as_string(pv);
    gtk_list_store_set(store, iter, col_id, buf2, -1);
    g_free(buf2);
    break;
  case VALTYPE_NATION:
    pixbuf = get_flag(pv->data.v_nation);
    gtk_list_store_set(store, iter, col_id, pixbuf, -1);
    if (pixbuf) {
      g_object_unref(pixbuf);
    }
    break;
  case VALTYPE_GOV:
    if (pv->data.v_gov != NULL) {
      pixbuf = sprite_get_pixbuf(get_government_sprite(tileset, pv->data.v_gov));
    } else {
      pixbuf = sprite_get_pixbuf(get_government_sprite(tileset,
                                                       game.government_during_revolution));
    }
    gtk_list_store_set(store, iter, col_id, pixbuf, -1);
    if (pixbuf) {
      g_object_unref(pixbuf);
    }
    break;
  case VALTYPE_TILE_VISION_DATA:
    break;
  }
 
  propval_free(pv);
 
  return TRUE;
}
 
/************************************************************************/
static void property_page_fill_widgets(struct property_page *pp)
{
  struct objbind *focused;
 
  if (!pp || !pp->objbind_table) {
    return;
  }
 
  if (pp->object_store) {
    GtkTreeIter iter;
    GtkTreeRowReference *rr;
    GtkTreeModel *model;
    GtkTreePath *path;
 
    model = GTK_TREE_MODEL(pp->object_store);
 
    property_page_objbind_iterate(pp, ob) {
      if (objbind_get_rowref(ob)) {
        continue;
      }
      gtk_list_store_append(pp->object_store, &iter);
      gtk_list_store_set(pp->object_store, &iter, 0, ob, -1);
      path = gtk_tree_model_get_path(model, &iter);
      rr = gtk_tree_row_reference_new(model, path);
      gtk_tree_path_free(path);
      objbind_set_rowref(ob, rr);
 
      property_page_objprop_iterate(pp, op) {
        property_page_set_store_value(pp, op, ob, &iter);
      } property_page_objprop_iterate_end;
    } property_page_objbind_iterate_end;
 
    if (gtk_tree_model_get_iter_first(model, &iter)) {
      GtkTreeSelection *sel;
 
      sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pp->object_view));
      gtk_tree_selection_select_iter(sel, &iter);
    }
  }
 
  focused = property_page_get_focused_objbind(pp);
  property_page_objprop_iterate(pp, op) {
    objprop_refresh_widget(op, focused);
  } property_page_objprop_iterate_end;
}
 
/************************************************************************/
static struct objbind *property_page_get_focused_objbind(struct property_page *pp)
{
  if (!pp) {
    return NULL;
  }
  return pp->focused_objbind;
}
 
/************************************************************************/
static void property_page_set_focused_objbind(struct property_page *pp,
                                              struct objbind *ob)
{
  if (!pp) {
    return;
  }
  pp->focused_objbind = ob;
}
 
/************************************************************************/
static struct objbind *property_page_get_objbind(struct property_page *pp,
                                                 int object_id)
{
  struct objbind *ob;
 
  if (!pp || !pp->objbind_table) {
    return NULL;
  }
 
  objbind_hash_lookup(pp->objbind_table, object_id, &ob);
  return ob;
}
 
/************************************************************************/
static void property_page_load_tiles(struct property_page *pp,
                                     const struct tile_list *tiles)
{
  if (!pp || !tiles) {
    return;
  }
 
  tile_list_iterate(tiles, ptile) {
    property_page_add_objbinds_from_tile(pp, ptile);
  } tile_list_iterate_end;
 
  property_page_fill_widgets(pp);
}
 
/************************************************************************/
static int property_page_get_num_objbinds(const struct property_page *pp)
{
  if (!pp || !pp->objbind_table) {
    return 0;
  }
  return objbind_hash_size(pp->objbind_table);
}
 
/************************************************************************/
static void property_page_change_value(struct property_page *pp,
                                       struct objprop *op,
                                       struct propval *pv)
{
  GtkTreeSelection *sel;
  GtkTreeModel *model;
  GList *rows, *p;
  GtkTreePath *path;
  GtkTreeIter iter;
  struct objbind *ob;
  bool changed = FALSE;
 
  if (!pp || !op || !pp->object_view) {
    return;
  }
 
  if (objprop_is_readonly(op)) {
    return;
  }
 
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pp->object_view));
  rows = gtk_tree_selection_get_selected_rows(sel, &model);
 
  for (p = rows; p != NULL; p = p->next) {
    path = p->data;
    if (gtk_tree_model_get_iter(model, &iter, path)) {
      gtk_tree_model_get(model, &iter, 0, &ob, -1);
      changed |= objbind_set_modified_value(ob, op, pv);
    }
    gtk_tree_path_free(path);
  }
  g_list_free(rows);
 
  if (changed) {
    ob = property_page_get_focused_objbind(pp);
    objprop_refresh_widget(op, ob);
  }
}
 
/************************************************************************/
static void property_page_send_values(struct property_page *pp)
{
  GtkTreeSelection *sel;
  GtkTreeModel *model;
  GList *rows, *p;
  GtkTreePath *path;
  GtkTreeIter iter;
  struct objbind *ob;
  union packetdata packet;
  struct connection *my_conn = &client.conn;
 
  if (!pp || !pp->object_view) {
    return;
  }
 
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pp->object_view));
  if (gtk_tree_selection_count_selected_rows(sel) < 1) {
    return;
  }
 
  packet = property_page_new_packet(pp);
  if (!packet.pointers.v_pointer1) {
    return;
  }
 
  rows = gtk_tree_selection_get_selected_rows(sel, &model);
  connection_do_buffer(my_conn);
  for (p = rows; p != NULL; p = p->next) {
    path = p->data;
    if (gtk_tree_model_get_iter(model, &iter, path)) {
      gtk_tree_model_get(model, &iter, 0, &ob, -1);
      if (objbind_has_modified_properties(ob)) {
        objbind_pack_current_values(ob, packet);
        property_page_objprop_iterate(pp, op) {
          if (objprop_is_readonly(op)) {
            continue;
          }
          objbind_pack_modified_value(ob, op, packet);
        } property_page_objprop_iterate_end;
        property_page_send_packet(pp, packet);
      }
    }
    gtk_tree_path_free(path);
  }
  connection_do_unbuffer(my_conn);
  g_list_free(rows);
 
  property_page_free_packet(pp, packet);
}
 
/************************************************************************/
static union packetdata property_page_new_packet(struct property_page *pp)
{
  union packetdata packet;
 
  packet.pointers.v_pointer2 = NULL;
 
  if (!pp) {
    packet.pointers.v_pointer1 = NULL;
    return packet;
  }
 
  switch (property_page_get_objtype(pp)) {
  case OBJTYPE_TILE:
    packet.tile = fc_calloc(1, sizeof(*packet.tile));
    break;
  case OBJTYPE_STARTPOS:
    packet.startpos = fc_calloc(1, sizeof(*packet.startpos));
    break;
  case OBJTYPE_UNIT:
    packet.unit = fc_calloc(1, sizeof(*packet.unit));
    break;
  case OBJTYPE_CITY:
    packet.city = fc_calloc(1, sizeof(*packet.city));
    break;
  case OBJTYPE_PLAYER:
    packet.player = fc_calloc(1, sizeof(*packet.player));
    break;
  case OBJTYPE_GAME:
    packet.game.game = fc_calloc(1, sizeof(*packet.game.game));
    packet.game.desc = fc_calloc(1, sizeof(*packet.game.desc));
    break;
  case NUM_OBJTYPES:
    break;
  }
 
  return packet;
}
 
/************************************************************************/
static void property_page_send_packet(struct property_page *pp,
                                      union packetdata packet)
{
  struct connection *my_conn = &client.conn;
 
  if (!pp || !packet.pointers.v_pointer1) {
    return;
  }
 
  switch (property_page_get_objtype(pp)) {
  case OBJTYPE_TILE:
    send_packet_edit_tile(my_conn, packet.tile);
    return;
  case OBJTYPE_STARTPOS:
    send_packet_edit_startpos_full(my_conn, packet.startpos);
    return;
  case OBJTYPE_UNIT:
    send_packet_edit_unit(my_conn, packet.unit);
    return;
  case OBJTYPE_CITY:
    send_packet_edit_city(my_conn, packet.city);
    return;
  case OBJTYPE_PLAYER:
    send_packet_edit_player(my_conn, packet.player);
    return;
  case OBJTYPE_GAME:
    send_packet_edit_game(my_conn, packet.game.game);
    send_packet_edit_scenario_desc(my_conn, packet.game.desc);
    return;
  case NUM_OBJTYPES:
    break;
  }
 
  log_error("%s(): Unhandled object type %s (nb %d).",
            __FUNCTION__, objtype_get_name(property_page_get_objtype(pp)),
            property_page_get_objtype(pp));
}
 
/************************************************************************/
static void property_page_free_packet(struct property_page *pp,
                                      union packetdata packet)
{
  if (!packet.pointers.v_pointer1) {
    return;
  }
 
  free(packet.pointers.v_pointer1);
  packet.pointers.v_pointer1 = NULL;
 
  if (packet.pointers.v_pointer2 != NULL) {
    free(packet.pointers.v_pointer2);
    packet.pointers.v_pointer2 = NULL;
  }
}
 
/************************************************************************/
static void property_page_reset_objbinds(struct property_page *pp)
{
  GtkTreeSelection *sel;
  GtkTreeModel *model;
  GtkTreeIter iter;
  GtkTreePath *path;
  GList *rows, *p;
  struct objbind *ob;
 
  if (!pp || !pp->object_view) {
    return;
  }
 
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pp->object_view));
  if (gtk_tree_selection_count_selected_rows(sel) < 1) {
    return;
  }
 
  rows = gtk_tree_selection_get_selected_rows(sel, &model);
  for (p = rows; p != NULL; p = p->next) {
    path = p->data;
    if (gtk_tree_model_get_iter(model, &iter, path)) {
      gtk_tree_model_get(model, &iter, 0, &ob, -1);
      objbind_clear_all_modified_values(ob);
      property_page_objprop_iterate(pp, op) {
        property_page_set_store_value(pp, op, ob, &iter);
      } property_page_objprop_iterate_end;
    }
    gtk_tree_path_free(path);
  }
  g_list_free(rows);
 
  ob = property_page_get_focused_objbind(pp);
  property_page_objprop_iterate(pp, op) {
    objprop_refresh_widget(op, ob);
  } property_page_objprop_iterate_end;
}
 
/************************************************************************/
static void property_page_destroy_objects(struct property_page *pp)
{
  GtkTreeSelection *sel;
  GtkTreeModel *model;
  GtkTreeIter iter;
  GtkTreePath *path;
  GList *rows, *p;
  struct objbind *ob;
  struct connection *my_conn = &client.conn;
 
  if (!pp || !pp->object_view) {
    return;
  }
 
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pp->object_view));
  if (gtk_tree_selection_count_selected_rows(sel) < 1) {
    return;
  }
 
  rows = gtk_tree_selection_get_selected_rows(sel, &model);
  connection_do_buffer(my_conn);
  for (p = rows; p != NULL; p = p->next) {
    path = p->data;
    if (gtk_tree_model_get_iter(model, &iter, path)) {
      gtk_tree_model_get(model, &iter, 0, &ob, -1);
      objbind_request_destroy_object(ob);
    }
    gtk_tree_path_free(path);
  }
  connection_do_unbuffer(my_conn);
  g_list_free(rows);
}
 
/************************************************************************/
static void property_page_create_objects(struct property_page *pp,
                                         struct tile_list *hint_tiles)
{
  enum editor_object_type objtype;
  int apno, value, count, size;
  int tag;
  struct connection *my_conn = &client.conn;
  struct tile *ptile = NULL;
  struct player *pplayer;
 
  if (!pp) {
    return;
  }
 
  objtype = property_page_get_objtype(pp);
  if (objtype_is_conserved(objtype)) {
    return;
  }
 
  tag = get_next_unique_tag();
  count = 1;
 
  switch (objtype) {
  case OBJTYPE_STARTPOS:
    if (hint_tiles) {
      tile_list_iterate(hint_tiles, atile) {
        if (NULL == map_startpos_get(atile)) {
          ptile = atile;
          break;
        }
      } tile_list_iterate_end;
    }
 
    if (NULL == ptile) {
      ptile = get_center_tile_mapcanvas();
    }
 
    if (NULL == ptile) {
      break;
    }
 
    dsend_packet_edit_startpos(my_conn, tile_index(ptile), FALSE, tag);
    break;
 
  case OBJTYPE_UNIT:
    if (hint_tiles) {
      tile_list_iterate(hint_tiles, atile) {
        if (can_create_unit_at_tile(atile)) {
          ptile = atile;
          break;
        }
      } tile_list_iterate_end;
    }
 
    if (!ptile) {
      struct unit *punit;
      property_page_objbind_iterate(pp, ob) {
        punit = objbind_get_object(ob);
        if (punit && can_create_unit_at_tile(unit_tile(punit))) {
          ptile = unit_tile(punit);
          break;
        }
      } property_page_objbind_iterate_end;
    }
 
    if (!ptile) {
      ptile = get_center_tile_mapcanvas();
    }
 
    if (!ptile) {
      break;
    }
 
    apno = editor_tool_get_applied_player(ETT_UNIT);
    count = editor_tool_get_count(ETT_UNIT);
    value = editor_tool_get_value(ETT_UNIT);
    dsend_packet_edit_unit_create(my_conn, apno, tile_index(ptile),
                                  value, count, tag);
    break;
 
  case OBJTYPE_CITY:
    apno = editor_tool_get_applied_player(ETT_CITY);
    pplayer = player_by_number(apno);
    if (pplayer && hint_tiles) {
      tile_list_iterate(hint_tiles, atile) {
        if (!is_enemy_unit_tile(atile, pplayer)
            && city_can_be_built_here(&(wld.map), atile,
                                      NULL, FALSE)) {
          ptile = atile;
          break;
        }
      } tile_list_iterate_end;
    }
 
    if (!ptile) {
      ptile = get_center_tile_mapcanvas();
    }
 
    if (!ptile) {
      break;
    }
 
    size = editor_tool_get_size(ETT_CITY);
    dsend_packet_edit_city_create(my_conn, apno, tile_index(ptile),
                                  size, tag);
    break;
 
  case OBJTYPE_PLAYER:
    dsend_packet_edit_player_create(my_conn, tag);
    break;
 
  case OBJTYPE_TILE:
  case OBJTYPE_GAME:
  case NUM_OBJTYPES:
    break;
  }
 
  property_page_store_creation_tag(pp, tag, count);
}
 
/************************************************************************/
static void property_page_object_changed(struct property_page *pp,
                                         int object_id,
                                         bool removed)
{
  struct objbind *ob;
  GtkTreeRowReference *rr;
 
  ob = property_page_get_objbind(pp, object_id);
  if (!ob) {
    return;
  }
 
  rr = objbind_get_rowref(ob);
  if (rr && gtk_tree_row_reference_valid(rr)) {
    GtkTreePath *path;
    GtkTreeIter iter;
    GtkTreeModel *model;
 
    model = GTK_TREE_MODEL(pp->object_store);
    path = gtk_tree_row_reference_get_path(rr);
 
    if (gtk_tree_model_get_iter(model, &iter, path)) {
      if (removed) {
        gtk_list_store_remove(pp->object_store, &iter);
      } else {
        property_page_objprop_iterate(pp, op) {
          property_page_set_store_value(pp, op, ob, &iter);
        } property_page_objprop_iterate_end;
      }
    }
 
    gtk_tree_path_free(path);
  }
 
  if (removed) {
    objbind_hash_remove(pp->objbind_table, object_id);
    return;
  }
 
  if (ob == property_page_get_focused_objbind(pp)) {
    property_page_objprop_iterate(pp, op) {
      objprop_refresh_widget(op, ob);
    } property_page_objprop_iterate_end;
  }
}
 
/************************************************************************/
static void property_page_object_created(struct property_page *pp,
                                         int tag, int object_id)
{
  gpointer object;
  enum editor_object_type objtype;
 
  if (!property_page_tag_is_known(pp, tag)) {
    return;
  }
  property_page_remove_creation_tag(pp, tag);
 
  objtype = property_page_get_objtype(pp);
  object = objtype_get_object_from_id(objtype, object_id);
 
  if (!object) {
    return;
  }
 
  property_page_add_objbind(pp, object);
  property_page_fill_widgets(pp);
}
 
/************************************************************************/
static void property_page_add_extviewer(struct property_page *pp,
                                        struct extviewer *ev)
{
  GtkWidget *w;
 
  if (!pp || !ev) {
    return;
  }
 
  w = extviewer_get_view_widget(ev);
  if (!w) {
    return;
  }
  gtk_notebook_append_page(GTK_NOTEBOOK(pp->extviewer_notebook), w, NULL);
}
 
/************************************************************************/
static void property_page_show_extviewer(struct property_page *pp,
                                         struct extviewer *ev)
{
  GtkWidget *w;
  GtkNotebook *notebook;
  int page;
 
  if (!pp || !ev) {
    return;
  }
 
  w = extviewer_get_view_widget(ev);
  if (!w) {
    return;
  }
 
  notebook = GTK_NOTEBOOK(pp->extviewer_notebook);
  page = gtk_notebook_page_num(notebook, w);
  gtk_notebook_set_current_page(notebook, page);
}
 
/************************************************************************/
static void property_page_store_creation_tag(struct property_page *pp,
                                             int tag, int count)
{
  if (!pp || !pp->tag_table) {
    return;
  }
 
  if (stored_tag_hash_lookup(pp->tag_table, tag, NULL)) {
    log_error("Attempted to insert object creation tag %d "
              "twice into tag table for property page %p (%d %s).",
              tag, pp, property_page_get_objtype(pp),
              property_page_get_name(pp));
    return;
  }
 
  stored_tag_hash_insert(pp->tag_table, tag, count);
}
 
/************************************************************************/
static void property_page_remove_creation_tag(struct property_page *pp,
                                              int tag)
{
  int count;
 
  if (!pp || !pp->tag_table) {
    return;
  }
 
  if (stored_tag_hash_lookup(pp->tag_table, tag, &count)) {
    if (0 >= --count) {
      stored_tag_hash_remove(pp->tag_table, tag);
    }
  }
}
 
/************************************************************************/
static bool property_page_tag_is_known(struct property_page *pp, int tag)
{
  if (!pp || !pp->tag_table) {
    return FALSE;
  }
  return stored_tag_hash_lookup(pp->tag_table, tag, NULL);
}
 
/************************************************************************/
static void property_page_clear_tags(struct property_page *pp)
{
  if (!pp || !pp->tag_table) {
    return;
  }
  stored_tag_hash_clear(pp->tag_table);
}
 
/************************************************************************/
static void property_page_apply_button_clicked(GtkButton *button,
                                               gpointer userdata)
{
  struct property_page *pp = userdata;
  property_page_send_values(pp);
}
 
/************************************************************************/
static void property_page_refresh_button_clicked(GtkButton *button,
                                                 gpointer userdata)
{
  struct property_page *pp = userdata;
  property_page_reset_objbinds(pp);
}
 
/************************************************************************/
static void property_page_create_button_clicked(GtkButton *button,
                                                gpointer userdata)
{
  struct property_page *pp = userdata, *tile_pp;
  struct tile_list *tiles = NULL;
  struct tile *ptile;
 
  if (!pp) {
    return;
  }
 
  tile_pp = property_editor_get_page(pp->pe_parent, OBJTYPE_TILE);
  tiles = tile_list_new();
 
  property_page_objbind_iterate(tile_pp, ob) {
    ptile = objbind_get_object(ob);
    if (ptile) {
      tile_list_append(tiles, ptile);
    }
  } property_page_objbind_iterate_end;
 
  property_page_create_objects(pp, tiles);
  tile_list_destroy(tiles);
}
 
/************************************************************************/
static void property_page_destroy_button_clicked(GtkButton *button,
                                                 gpointer userdata)
{
  struct property_page *pp = userdata;
  property_page_destroy_objects(pp);
}
 
/************************************************************************/
static bool property_editor_add_page(struct property_editor *pe,
                                     enum editor_object_type objtype)
{
  struct property_page *pp;
  GtkWidget *label;
  const char *name;
 
  if (!pe || !pe->notebook) {
    return FALSE;
  }
 
  if (!(objtype < NUM_OBJTYPES)) {
    return FALSE;
  }
 
  pp = property_page_new(objtype, pe);
  if (!pp) {
    return FALSE;
  }
 
  name = property_page_get_name(pp);
  label = gtk_label_new(name);
  gtk_notebook_append_page(GTK_NOTEBOOK(pe->notebook),
                           pp->widget, label);
 
  pe->property_pages[objtype] = pp;
 
  return TRUE;
}
 
/************************************************************************/
static struct property_page *
property_editor_get_page(struct property_editor *pe,
                         enum editor_object_type objtype)
{
  if (!pe || !(objtype < NUM_OBJTYPES)) {
    return NULL;
  }
 
  return pe->property_pages[objtype];
}
 
/************************************************************************/
static struct property_editor *property_editor_new(void)
{
  struct property_editor *pe;
  GtkWidget *win, *notebook, *vgrid;
  enum editor_object_type objtype;
  int grid_row = 0;
 
  pe = fc_calloc(1, sizeof(*pe));
 
  /* The property editor dialog window. */
 
  win = gtk_window_new();
  gtk_window_set_title(GTK_WINDOW(win), _("Property Editor"));
  gtk_window_set_resizable(GTK_WINDOW(win), TRUE);
  gtk_window_set_default_size(GTK_WINDOW(win), 780, 560);
  gtk_window_set_transient_for(GTK_WINDOW(win), GTK_WINDOW(toplevel));
  gtk_window_set_destroy_with_parent(GTK_WINDOW(win), TRUE);
  gtk_widget_set_margin_start(win, 4);
  gtk_widget_set_margin_end(win, 4);
  gtk_widget_set_margin_top(win, 4);
  gtk_widget_set_margin_bottom(win, 4);
  gtk_window_set_hide_on_close(GTK_WINDOW(win), TRUE);
  pe->widget = win;
 
  vgrid = gtk_grid_new();
  gtk_window_set_child(GTK_WINDOW(win), vgrid);
 
  /* Property pages. */
 
  notebook = gtk_notebook_new();
  gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), TRUE);
  gtk_grid_attach(GTK_GRID(vgrid), notebook, 0, grid_row++, 1, 1);
  pe->notebook = notebook;
 
  for (objtype = 0; objtype < NUM_OBJTYPES; objtype++) {
    property_editor_add_page(pe, objtype);
  }
 
  return pe;
}
 
/************************************************************************/
struct property_editor *editprop_get_property_editor(void)
{
  if (!the_property_editor) {
    the_property_editor = property_editor_new();
  }
  return the_property_editor;
}
 
/************************************************************************/
void property_editor_load_tiles(struct property_editor *pe,
                                const struct tile_list *tiles)
{
  struct property_page *pp;
  enum editor_object_type objtype;
  int i;
  const enum editor_object_type preferred[] = {
    OBJTYPE_CITY,
    OBJTYPE_UNIT,
    OBJTYPE_STARTPOS,
    OBJTYPE_TILE
  };
 
  if (!pe || !tiles) {
    return;
  }
 
  for (objtype = 0; objtype < NUM_OBJTYPES; objtype++) {
    pp = property_editor_get_page(pe, objtype);
    property_page_load_tiles(pp, tiles);
  }
 
  for (i = 0; i < ARRAY_SIZE(preferred) - 1; i++) {
    pp = property_editor_get_page(pe, preferred[i]);
    if (property_page_get_num_objbinds(pp) > 0) {
      break;
    }
  }
  objtype = preferred[i];
  gtk_notebook_set_current_page(GTK_NOTEBOOK(pe->notebook), objtype);
}
 
/************************************************************************/
void property_editor_popup(struct property_editor *pe,
                           enum editor_object_type objtype)
{
  if (pe == nullptr || pe->widget == nullptr) {
    return;
  }
 
  gtk_widget_set_visible(pe->widget, TRUE);
 
  gtk_window_present(GTK_WINDOW(pe->widget));
  if (objtype < NUM_OBJTYPES) {
    gtk_notebook_set_current_page(GTK_NOTEBOOK(pe->notebook), objtype);
  }
}
 
/************************************************************************/
void property_editor_popdown(struct property_editor *pe)
{
  if (pe == nullptr || pe->widget == nullptr) {
    return;
  }
 
  gtk_widget_set_visible(pe->widget, FALSE);
}
 
/************************************************************************/
void property_editor_handle_object_changed(struct property_editor *pe,
                                           enum editor_object_type objtype,
                                           int object_id,
                                           bool remove)
{
  struct property_page *pp;
 
  if (!pe) {
    return;
  }
 
  if (!(objtype < NUM_OBJTYPES)) {
    return;
  }
 
  pp = property_editor_get_page(pe, objtype);
  property_page_object_changed(pp, object_id, remove);
}
 
/************************************************************************/
void property_editor_handle_object_created(struct property_editor *pe,
                                           int tag, int object_id)
{
  enum editor_object_type objtype;
  struct property_page *pp;
 
  for (objtype = 0; objtype < NUM_OBJTYPES; objtype++) {
    if (objtype_is_conserved(objtype)) {
      continue;
    }
    pp = property_editor_get_page(pe, objtype);
    property_page_object_created(pp, tag, object_id);
  }
}
 
/************************************************************************/
void property_editor_clear(struct property_editor *pe)
{
  enum editor_object_type objtype;
  struct property_page *pp;
 
  if (!pe) {
    return;
  }
 
  for (objtype = 0; objtype < NUM_OBJTYPES; objtype++) {
    pp = property_editor_get_page(pe, objtype);
    property_page_clear_objbinds(pp);
    property_page_clear_tags(pp);
  }
}
 
/************************************************************************/
void property_editor_reload(struct property_editor *pe,
                            enum editor_object_type objtype)
{
  struct property_page *pp;
 
  if (!pe) {
    return;
  }
 
  pp = property_editor_get_page(pe, objtype);
  if (!pp) {
    return;
  }
 
  property_page_clear_objbinds(pp);
 
  switch (objtype) {
  case OBJTYPE_PLAYER:
    players_iterate(pplayer) {
      property_page_add_objbind(pp, pplayer);
    } players_iterate_end;
    break;
  case OBJTYPE_GAME:
    property_page_add_objbind(pp, &game);
    break;
  case OBJTYPE_TILE:
  case OBJTYPE_STARTPOS:
  case OBJTYPE_UNIT:
  case OBJTYPE_CITY:
  case NUM_OBJTYPES:
    break;
  }
 
  property_page_fill_widgets(pp);
  gtk_notebook_set_current_page(GTK_NOTEBOOK(pe->notebook), objtype);
}
 
/************************************************************************/
static struct property_filter *property_filter_new(const char *filter)
{
  struct property_filter *pf;
  struct pf_conjunction *pfc;
  struct pf_pattern *pfp;
  int or_clause_count, and_clause_count;
  char *or_clauses[PF_MAX_CLAUSES], *and_clauses[PF_MAX_CLAUSES];
  const char *pattern;
  int i, j;
 
  pf = fc_calloc(1, sizeof(*pf));
 
  if (!filter || filter[0] == '\0') {
    return pf;
  }
 
  or_clause_count = get_tokens(filter, or_clauses,
                               PF_MAX_CLAUSES,
                               PF_DISJUNCTION_SEPARATOR);
 
  for (i = 0; i < or_clause_count; i++) {
    if (or_clauses[i][0] == '\0') {
      continue;
    }
    pfc = &pf->disjunction[pf->count];
 
    and_clause_count = get_tokens(or_clauses[i], and_clauses,
                                  PF_MAX_CLAUSES,
                                  PF_CONJUNCTION_SEPARATOR);
 
    for (j = 0; j < and_clause_count; j++) {
      if (and_clauses[j][0] == '\0') {
        continue;
      }
      pfp = &pfc->conjunction[pfc->count];
      pattern = and_clauses[j];
 
      switch (pattern[0]) {
      case '!':
        pfp->negate = TRUE;
        pfp->text = fc_strdup(pattern + 1);
        break;
      default:
        pfp->text = fc_strdup(pattern);
        break;
      }
      pfc->count++;
    }
    free_tokens(and_clauses, and_clause_count);
    pf->count++;
  }
 
  free_tokens(or_clauses, or_clause_count);
 
  return pf;
}
 
/************************************************************************/
static bool property_filter_match(struct property_filter *pf,
                                  const struct objprop *op)
{
  struct pf_pattern *pfp;
  struct pf_conjunction *pfc;
  const char *name;
  bool match, or_result, and_result;
  int i, j;
 
  if (!pf) {
    return TRUE;
  }
  if (!op) {
    return FALSE;
  }
 
  name = objprop_get_name(op);
  if (!name) {
    return FALSE;
  }
 
  if (pf->count < 1) {
    return TRUE;
  }
 
  or_result = FALSE;
 
  for (i = 0; i < pf->count; i++) {
    pfc = &pf->disjunction[i];
    and_result = TRUE;
    for (j = 0; j < pfc->count; j++) {
      pfp = &pfc->conjunction[j];
      match = (pfp->text[0] == '\0'
               || fc_strcasestr(name, pfp->text));
      if (pfp->negate) {
        match = !match;
      }
      and_result = and_result && match;
      if (!and_result) {
        break;
      }
    }
    or_result = or_result || and_result;
    if (or_result) {
      break;
    }
  }
 
  return or_result;
}
 
/************************************************************************/
static void property_filter_free(struct property_filter *pf)
{
  struct pf_pattern *pfp;
  struct pf_conjunction *pfc;
  int i, j;
 
  if (!pf) {
    return;
  }
 
  for (i = 0; i < pf->count; i++) {
    pfc = &pf->disjunction[i];
    for (j = 0; j < pfc->count; j++) {
      pfp = &pfc->conjunction[j];
      if (pfp->text != NULL) {
        free(pfp->text);
        pfp->text = NULL;
      }
    }
    pfc->count = 0;
  }
  pf->count = 0;
  free(pf);
}
 
/************************************************************************/
const char *vision_layer_get_name(enum vision_layer vl)
{
  switch (vl) {
  case V_MAIN:
    /* TRANS: Vision layer name. Feel free to leave untranslated. */
    return _("Seen (Main)");
  case V_INVIS:
    /* TRANS: Vision layer name. Feel free to leave untranslated. */
    return _("Seen (Invis)");
  case V_SUBSURFACE:
    /* TRANS: Vision layer name. Feel free to leave untranslated. */
    return _("Seen (Subsurface)");
  case V_COUNT:
    break;
  }
 
  log_error("%s(): Unrecognized vision layer %d.", __FUNCTION__, vl);
  return _("Unknown");
}