gui_interface.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   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
 
/* client */
#include "client_main.h"
#include "editgui_g.h"
#include "options.h"
 
#include "chatline_g.h"
#include "citydlg_g.h"
#include "connectdlg_g.h"
#include "dialogs_g.h"
#include "diplodlg_g.h"
#include "editgui_g.h"
#include "graphics_g.h"
#include "gui_main_g.h"
#include "mapview_g.h"
#include "themes_g.h"
 
#include "gui_interface.h"
 
static struct gui_funcs funcs;
 
/**********************************************************************/
struct gui_funcs *get_gui_funcs(void)
{
  return &funcs;
}
 
/**********************************************************************/
void ui_init(void)
{
  funcs.ui_init();
}
 
/**********************************************************************/
int ui_main(int argc, char *argv[])
{
  return funcs.ui_main(argc, argv);
}
 
/**********************************************************************/
void ui_exit(void)
{
  funcs.ui_exit();
}
 
/**********************************************************************/
void version_message(const char *vertext)
{
  funcs.version_message(vertext);
}
 
/**********************************************************************/
void real_output_window_append(const char *astring,
                               const struct text_tag_list *tags,
                               int conn_id)
{
  funcs.real_output_window_append(astring, tags, conn_id);
}
 
/**********************************************************************/
enum gui_type get_gui_type(void)
{
  return funcs.get_gui_type();
}
 
/**********************************************************************/
void insert_client_build_info(char *outbuf, size_t outlen)
{
  funcs.insert_client_build_info(outbuf, outlen);
}
 
/**********************************************************************/
bool is_view_supported(enum ts_type type)
{
  return funcs.is_view_supported(type);
}
 
/**********************************************************************/
void tileset_type_set(enum ts_type type)
{
  funcs.tileset_type_set(type);
}
 
/**********************************************************************/
struct sprite *load_gfxfile(const char *filename, bool svgflag)
{
  return funcs.load_gfxfile(filename, svgflag);
}
 
/**********************************************************************/
struct sprite *load_gfxnumber(int num)
{
  return funcs.load_gfxnumber(num);
}
 
/**********************************************************************/
struct sprite *create_sprite(int width, int height, struct color *pcolor)
{
  return funcs.create_sprite(width, height, pcolor);
}
 
/**********************************************************************/
void get_sprite_dimensions(struct sprite *sprite, int *width, int *height)
{
  funcs.get_sprite_dimensions(sprite, width, height);
}
 
/**********************************************************************/
struct sprite *crop_sprite(struct sprite *source,
                           int x, int y, int width, int height,
                           struct sprite *mask, int mask_offset_x, int mask_offset_y,
               float scale, bool smooth)
{
  return funcs.crop_sprite(source, x, y, width, height, mask,
                           mask_offset_x, mask_offset_y, scale, smooth);
}
 
/**********************************************************************/
void free_sprite(struct sprite *s)
{
  funcs.free_sprite(s);
}
 
/**********************************************************************/
struct color *color_alloc(int r, int g, int b)
{
  return funcs.color_alloc(r, g, b);
}
 
/**********************************************************************/
void color_free(struct color *pcolor)
{
  return funcs.color_free(pcolor);
}
 
/**********************************************************************/
struct canvas *canvas_create(int width, int height)
{
  return funcs.canvas_create(width, height);
}
 
/**********************************************************************/
void canvas_free(struct canvas *store)
{
  funcs.canvas_free(store);
}
 
/**********************************************************************/
void canvas_set_zoom(struct canvas *store, float zoom)
{
  funcs.canvas_set_zoom(store, zoom);
}
 
/**********************************************************************/
bool has_zoom_support(void)
{
  return funcs.has_zoom_support();
}
 
/**********************************************************************/
void canvas_mapview_init(struct canvas *store)
{
  funcs.canvas_mapview_init(store);
}
 
/**********************************************************************/
void canvas_copy(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height)
{
  funcs.canvas_copy(dest, src, src_x, src_y, dest_x, dest_y, width, height);
}
 
/**********************************************************************/
void canvas_put_sprite(struct canvas *pcanvas,
                       int canvas_x, int canvas_y,
                       struct sprite *psprite,
                       int offset_x, int offset_y, int width, int height)
{
  funcs.canvas_put_sprite(pcanvas, canvas_x, canvas_y, psprite,
                          offset_x, offset_y, width, height);
}
 
/**********************************************************************/
void canvas_put_sprite_full(struct canvas *pcanvas,
                            int canvas_x, int canvas_y,
                            struct sprite *psprite)
{
  funcs.canvas_put_sprite_full(pcanvas, canvas_x, canvas_y, psprite);
}
 
/**********************************************************************/
void canvas_put_sprite_full_scaled(struct canvas *pcanvas,
                                   int canvas_x, int canvas_y,
                                   int canvas_w, int canvas_h,
                                   struct sprite *psprite)
{
  funcs.canvas_put_sprite_full_scaled(pcanvas, canvas_x, canvas_y,
                                      canvas_w, canvas_h, psprite);
}
 
/**********************************************************************/
void canvas_put_sprite_fogged(struct canvas *pcanvas,
                              int canvas_x, int canvas_y,
                              struct sprite *psprite,
                              bool fog, int fog_x, int fog_y)
{
  funcs.canvas_put_sprite_fogged(pcanvas, canvas_x, canvas_y,
                                 psprite, fog, fog_x, fog_y);
}
 
/**********************************************************************/
void canvas_put_rectangle(struct canvas *pcanvas,
                          struct color *pcolor,
                          int canvas_x, int canvas_y, int width, int height)
{
  funcs.canvas_put_rectangle(pcanvas, pcolor, canvas_x, canvas_y,
                             width, height);
}
 
/**********************************************************************/
void canvas_fill_sprite_area(struct canvas *pcanvas,
                             struct sprite *psprite, struct color *pcolor,
                             int canvas_x, int canvas_y)
{
  funcs.canvas_fill_sprite_area(pcanvas, psprite, pcolor, canvas_x, canvas_y);
}
 
/**********************************************************************/
void canvas_put_line(struct canvas *pcanvas, struct color *pcolor,
                     enum line_type ltype, int start_x, int start_y,
                     int dx, int dy)
{
  funcs.canvas_put_line(pcanvas, pcolor, ltype, start_x, start_y, dx, dy);
}
 
/**********************************************************************/
void canvas_put_curved_line(struct canvas *pcanvas, struct color *pcolor,
                            enum line_type ltype, int start_x, int start_y,
                            int dx, int dy)
{
  funcs.canvas_put_curved_line(pcanvas, pcolor, ltype, start_x, start_y,
                               dx, dy);
}
 
/**********************************************************************/
void get_text_size(int *width, int *height,
                   enum client_font font, const char *text)
{
  funcs.get_text_size(width, height, font, text);
}
 
/**********************************************************************/
void canvas_put_text(struct canvas *pcanvas, int canvas_x, int canvas_y,
                     enum client_font font, struct color *pcolor,
                     const char *text)
{
  funcs.canvas_put_text(pcanvas, canvas_x, canvas_y, font, pcolor, text);
}
 
/**********************************************************************/
void map_canvas_size_refresh(void)
{
  funcs.map_canvas_size_refresh();
}
 
/**********************************************************************/
void set_rulesets(int num_rulesets, char **rulesets)
{
  funcs.set_rulesets(num_rulesets, rulesets);
}
 
/**********************************************************************/
void options_extra_init(void)
{
  funcs.options_extra_init();
}
 
/**********************************************************************/
void server_connect(void)
{
  funcs.server_connect();
}
 
/**********************************************************************/
void add_net_input(int sock)
{
  funcs.add_net_input(sock);
}
 
/**********************************************************************/
void remove_net_input(void)
{
  funcs.remove_net_input();
}
 
/**********************************************************************/
void real_conn_list_dialog_update(void *unused)
{
  funcs.real_conn_list_dialog_update(NULL);
}
 
/**********************************************************************/
void close_connection_dialog(void)
{
  funcs.close_connection_dialog();
}
 
/**********************************************************************/
void add_idle_callback(void (callback)(void *), void *data)
{
  funcs.add_idle_callback(callback, data);
}
 
/**********************************************************************/
void sound_bell(void)
{
  funcs.sound_bell();
}
 
/**********************************************************************/
void real_set_client_page(enum client_pages page)
{
  funcs.real_set_client_page(page);
}
 
/**********************************************************************/
enum client_pages get_current_client_page(void)
{
  return funcs.get_current_client_page();
}
 
/**********************************************************************/
void set_unit_icon(int idx, struct unit *punit)
{
  funcs.set_unit_icon(idx, punit);
}
 
/**********************************************************************/
void real_focus_units_changed(void)
{
  funcs.real_focus_units_changed();
}
 
/**********************************************************************/
void set_unit_icons_more_arrow(bool onoff)
{
  funcs.set_unit_icons_more_arrow(onoff);
}
 
/**********************************************************************/
void gui_update_font(const char *font_name, const char *font_value)
{
  funcs.gui_update_font(font_name, font_value);
}
 
/**********************************************************************/
void editgui_refresh(void)
{
  funcs.editgui_refresh();
}
 
/**********************************************************************/
void editgui_notify_object_created(int tag, int id)
{
  funcs.editgui_notify_object_created(tag, id);
}
 
/**********************************************************************/
void editgui_notify_object_changed(int objtype, int object_id, bool removal)
{
  funcs.editgui_notify_object_changed(objtype, object_id, removal);
}
 
/**********************************************************************/
void editgui_popup_properties(const struct tile_list *tiles, int objtype)
{
  funcs.editgui_popup_properties(tiles, objtype);
}
 
/**********************************************************************/
void editgui_tileset_changed(void)
{
  funcs.editgui_tileset_changed();
}
 
/**********************************************************************/
void editgui_popdown_all(void)
{
  funcs.editgui_popdown_all();
}
 
/**********************************************************************/
void popup_combat_info(int attacker_unit_id, int defender_unit_id,
                       int attacker_hp, int defender_hp,
                       bool make_att_veteran, bool make_def_veteran)
{
  funcs.popup_combat_info(attacker_unit_id, defender_unit_id,
                          attacker_hp, defender_hp, make_att_veteran,
                          make_def_veteran);
}
 
/**********************************************************************/
void update_timeout_label(void)
{
  funcs.update_timeout_label();
}
 
/**********************************************************************/
void start_turn(void)
{
  funcs.start_turn();
}
 
/**********************************************************************/
void real_city_dialog_popup(struct city *pcity)
{
  funcs.real_city_dialog_popup(pcity);
}
 
/**********************************************************************/
void real_city_dialog_refresh(struct city *pcity)
{
  funcs.real_city_dialog_refresh(pcity);
}
 
/**********************************************************************/
void popdown_city_dialog(struct city *pcity)
{
  funcs.popdown_city_dialog(pcity);
}
 
/**********************************************************************/
void popdown_all_city_dialogs(void)
{
  funcs.popdown_all_city_dialogs();
}
 
/**********************************************************************/
bool handmade_scenario_warning(void)
{
  return funcs.handmade_scenario_warning();
}
 
/**********************************************************************/
void refresh_unit_city_dialogs(struct unit *punit)
{
  funcs.refresh_unit_city_dialogs(punit);
}
 
/**********************************************************************/
bool city_dialog_is_open(struct city *pcity)
{
  return funcs.city_dialog_is_open(pcity);
}
 
/**********************************************************************/
bool request_transport(struct unit *pcargo, struct tile *ptile)
{
  return funcs.request_transport(pcargo, ptile);
}
 
/**********************************************************************/
void update_infra_dialog(void)
{
  funcs.update_infra_dialog();
}
 
/**********************************************************************/
void gui_load_theme(const char *directory, const char *theme_name)
{
  funcs.gui_load_theme(directory, theme_name);
}
 
/**********************************************************************/
void gui_clear_theme(void)
{
  funcs.gui_clear_theme();
}
 
/**********************************************************************/
char **get_gui_specific_themes_directories(int *count)
{
  return funcs.get_gui_specific_themes_directories(count);
}
 
/**********************************************************************/
char **get_usable_themes_in_directory(const char *directory, int *count)
{
  return funcs.get_usable_themes_in_directory(directory, count);
}
 
/**********************************************************************/
void gui_init_meeting(struct Treaty *ptreaty, struct player *they,
                      struct player *initiator)
{
  funcs.gui_init_meeting(ptreaty, they, initiator);
}
 
/**********************************************************************/
void gui_recv_cancel_meeting(struct Treaty *ptreaty, struct player *they,
                             struct player *initiator)
{
  funcs.gui_recv_cancel_meeting(ptreaty, they, initiator);
}
 
/**********************************************************************/
void gui_prepare_clause_updt(struct Treaty *ptreaty, struct player *they)
{
  funcs.gui_prepare_clause_updt(ptreaty, they);
}
 
/**********************************************************************/
void gui_recv_create_clause(struct Treaty *ptreaty, struct player *they)
{
  funcs.gui_recv_create_clause(ptreaty, they);
}
 
/**********************************************************************/
void gui_recv_remove_clause(struct Treaty *ptreaty, struct player *they)
{
  funcs.gui_recv_remove_clause(ptreaty, they);
}
 
/**********************************************************************/
void gui_recv_accept_treaty(struct Treaty *ptreaty, struct player *they)
{
  funcs.gui_recv_accept_treaty(ptreaty, they);
}
 
/**********************************************************************/
void request_action_confirmation(const char *expl,
                                 struct act_confirmation_data *data)
{
  funcs.request_action_confirmation(expl, data);
}
 
/**********************************************************************/
void popup_image(const char *tag)
{
  funcs.popup_image(tag);
}