Complete.Org: Mailing Lists: Archives: freeciv-dev: March 2004:
[Freeciv-Dev] Re: (PR#7517) Move canvas_store functions into client/gui-
Home

[Freeciv-Dev] Re: (PR#7517) Move canvas_store functions into client/gui-

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: use_less@xxxxxxxxxxx
Subject: [Freeciv-Dev] Re: (PR#7517) Move canvas_store functions into client/gui-.../graphics.c
From: "Jason Short" <jdorje@xxxxxxxxxxxxxxxxxxxxx>
Date: Sat, 6 Mar 2004 13:02:03 -0800
Reply-to: rt@xxxxxxxxxxx

<URL: http://rt.freeciv.org/Ticket/Display.html?id=7517 >

Jason Short wrote:
> <URL: http://rt.freeciv.org/Ticket/Display.html?id=7517 >
> 
>>[use_less - Wed Mar 03 02:58:21 2004]:
>>
>>oops, wrong version
>>
> 
> 
> I get the following compilation error in gui-gtk-2.0:
> 
> graphics.h:66: error: parse error before "GtkPixcomm"
> graphics.h:66: warning: no semicolon at end of struct or union
> 
> I spent a while trying to figure out what was causing this, but couldn't.

Well, back to step one...

This patch:

- Renames "struct canvas" as "struct mapview_canvas".
- Renames "struct canvas_store" as "struct canvas".
- Renames numerous "pcanvas_store" variables as "pcanvas".

It's large but quite straightforward.  It should be a first step toward 
the overall renaming & moving.

Compiled under gtk2, gtk, xaw, win32 clients.  gui-sdl and gui-stub are 
also supported.

jason

Index: client/citydlg_common.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/citydlg_common.c,v
retrieving revision 1.28
diff -u -r1.28 citydlg_common.c
--- client/citydlg_common.c     5 Mar 2004 18:16:01 -0000       1.28
+++ client/citydlg_common.c     6 Mar 2004 20:18:30 -0000
@@ -123,12 +123,12 @@
   and orthogonal views.
 ****************************************************************************/
 void city_dialog_redraw_map(struct city *pcity,
-                           struct canvas_store *pcanvas_store)
+                           struct canvas *pcanvas)
 {
   int city_x, city_y;
 
   /* First make it all black. */
-  gui_put_rectangle(pcanvas_store, COLOR_STD_BLACK, 0, 0,
+  gui_put_rectangle(pcanvas, COLOR_STD_BLACK, 0, 0,
                    get_citydlg_canvas_width(), get_citydlg_canvas_height());
 
   /* We have to draw the tiles in a particular order, so its best
@@ -142,14 +142,14 @@
          && tile_get_known(map_x, map_y)
          && city_to_canvas_pos(&canvas_x, &canvas_y, city_x, city_y)) {
        if (is_isometric) {
-         put_one_tile_iso(pcanvas_store, map_x, map_y,
+         put_one_tile_iso(pcanvas, map_x, map_y,
                           canvas_x, canvas_y,
                           0, 0, 0,
                           NORMAL_TILE_WIDTH, NORMAL_TILE_HEIGHT,
                           UNIT_TILE_HEIGHT,
                           D_FULL, TRUE);
        } else {
-         put_one_tile(pcanvas_store, map_x, map_y,
+         put_one_tile(pcanvas, map_x, map_y,
                       canvas_x, canvas_y, TRUE);
        }
       }
@@ -164,7 +164,7 @@
     if (tile_get_known(map_x, map_y)
        && city_to_canvas_pos(&canvas_x, &canvas_y, x, y)
        && pcity->city_map[x][y] == C_TILE_WORKER) {
-      put_city_tile_output(pcity, x, y, pcanvas_store, canvas_x, canvas_y);
+      put_city_tile_output(pcity, x, y, pcanvas, canvas_x, canvas_y);
     }
   } city_map_checked_iterate_end;
 
@@ -178,7 +178,7 @@
     if (tile_get_known(map_x, map_y)
        && city_to_canvas_pos(&canvas_x, &canvas_y, x, y)
        && pcity->city_map[x][y] == C_TILE_UNAVAILABLE) {
-      put_red_frame_tile(pcanvas_store, canvas_x, canvas_y);
+      put_red_frame_tile(pcanvas, canvas_x, canvas_y);
     }
   } city_map_checked_iterate_end;
 }
Index: client/citydlg_common.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/citydlg_common.h,v
retrieving revision 1.18
diff -u -r1.18 citydlg_common.h
--- client/citydlg_common.h     5 Mar 2004 18:16:01 -0000       1.18
+++ client/citydlg_common.h     6 Mar 2004 20:18:30 -0000
@@ -21,7 +21,7 @@
 #include "shared.h"            /* bool type */
 
 struct city;
-struct canvas_store;
+struct canvas;
 
 enum citizen_type {
   CITIZEN_ELVIS,
@@ -42,7 +42,7 @@
 bool canvas_to_city_pos(int *city_x, int *city_y,
                        int canvas_x, int canvas_y);
 void city_dialog_redraw_map(struct city *pcity,
-                           struct canvas_store *pcanvas_store);
+                           struct canvas *pcanvas);
 
 void get_city_dialog_production(struct city *pcity,
                                 char *buffer, size_t buffer_len);
Index: client/mapview_common.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/mapview_common.c,v
retrieving revision 1.85
diff -u -r1.85 mapview_common.c
--- client/mapview_common.c     5 Mar 2004 18:16:01 -0000       1.85
+++ client/mapview_common.c     6 Mar 2004 20:18:30 -0000
@@ -33,7 +33,7 @@
 #include "mapview_common.h"
 #include "tilespec.h"
 
-struct canvas mapview_canvas;
+struct mapview_canvas mapview_canvas;
 struct overview overview;
 
 /*
@@ -620,7 +620,7 @@
   in iso-view to draw only part of the tile.  Non-iso view should use
   put_unit_full instead.
 **************************************************************************/
-void put_unit(struct unit *punit, struct canvas_store *pcanvas_store,
+void put_unit(struct unit *punit, struct canvas *pcanvas,
              int canvas_x, int canvas_y,
              int unit_offset_x, int unit_offset_y,
              int unit_width, int unit_height)
@@ -631,7 +631,7 @@
   int i;
 
   if (!is_isometric && solid_bg) {
-    gui_put_rectangle(pcanvas_store, player_color(unit_owner(punit)),
+    gui_put_rectangle(pcanvas, player_color(unit_owner(punit)),
                      canvas_x, canvas_y, UNIT_TILE_WIDTH, UNIT_TILE_HEIGHT);
   }
 
@@ -640,7 +640,7 @@
       int ox = drawn_sprites[i].offset_x, oy = drawn_sprites[i].offset_y;
 
       /* units are never fogged */
-      gui_put_sprite(pcanvas_store, canvas_x + ox, canvas_y + oy,
+      gui_put_sprite(pcanvas, canvas_x + ox, canvas_y + oy,
                     drawn_sprites[i].sprite,
                     unit_offset_x - ox, unit_offset_y - oy,
                     unit_width - ox, unit_height - oy);
@@ -648,7 +648,7 @@
   }
 
   if (punit->occupy) {
-    gui_put_sprite(pcanvas_store, canvas_x, canvas_y,
+    gui_put_sprite(pcanvas, canvas_x, canvas_y,
                   sprites.unit.stack,
                   unit_offset_x, unit_offset_y, unit_width, unit_height);
   }
@@ -657,10 +657,10 @@
 /**************************************************************************
   Draw the given unit onto the canvas store at the given location.
 **************************************************************************/
-void put_unit_full(struct unit *punit, struct canvas_store *pcanvas_store,
+void put_unit_full(struct unit *punit, struct canvas *pcanvas,
                   int canvas_x, int canvas_y)
 {
-  put_unit(punit, pcanvas_store, canvas_x, canvas_y,
+  put_unit(punit, pcanvas, canvas_x, canvas_y,
           0, 0, UNIT_TILE_WIDTH, UNIT_TILE_HEIGHT);
 }
 
@@ -672,7 +672,7 @@
   sprites (limiting the number of combinations).
 ****************************************************************************/
 void put_city_tile_output(struct city *pcity, int city_x, int city_y,
-                         struct canvas_store *pcanvas_store,
+                         struct canvas *pcanvas,
                          int canvas_x, int canvas_y)
 {
   int food = city_get_food_tile(city_x, city_y, pcity);
@@ -690,11 +690,11 @@
     canvas_y -= NORMAL_TILE_HEIGHT / 3;
   }
 
-  gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                      sprites.city.tile_foodnum[food]);
-  gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                      sprites.city.tile_shieldnum[shields]);
-  gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                      sprites.city.tile_tradenum[trade]);
 }
 
@@ -706,7 +706,7 @@
   sprites (limiting the number of combinations).
 ****************************************************************************/
 void put_unit_city_overlays(struct unit *punit,
-                           struct canvas_store *pcanvas_store,
+                           struct canvas *pcanvas,
                            int canvas_x, int canvas_y)
 {
   int upkeep_food = CLIP(0, punit->upkeep_food, 2);
@@ -715,19 +715,19 @@
 
   /* draw overlay pixmaps */
   if (punit->upkeep > 0) {
-    gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+    gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                        sprites.upkeep.shield);
   }
   if (upkeep_food > 0) {
-    gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+    gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                        sprites.upkeep.food[upkeep_food - 1]);
   }
   if (upkeep_gold > 0) {
-    gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+    gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                        sprites.upkeep.gold[upkeep_gold - 1]);
   }
   if (unhappy > 0) {
-    gui_put_sprite_full(pcanvas_store, canvas_x, canvas_y,
+    gui_put_sprite_full(pcanvas, canvas_x, canvas_y,
                        sprites.upkeep.unhappy[unhappy - 1]);
   }
 }
@@ -735,33 +735,33 @@
 /****************************************************************************
   Draw a red frame around the tile.  (canvas_x, canvas_y) is the tile origin.
 ****************************************************************************/
-void put_red_frame_tile(struct canvas_store *pcanvas_store,
+void put_red_frame_tile(struct canvas *pcanvas,
                        int canvas_x, int canvas_y)
 {
   if (is_isometric) {
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_TILE_FRAME,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_TILE_FRAME,
                 canvas_x + NORMAL_TILE_WIDTH / 2 - 1, canvas_y,
                 NORMAL_TILE_WIDTH / 2, NORMAL_TILE_HEIGHT / 2 - 1);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_TILE_FRAME,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_TILE_FRAME,
                 canvas_x + NORMAL_TILE_WIDTH - 1,
                 canvas_y + NORMAL_TILE_HEIGHT / 2 - 1,
                 -NORMAL_TILE_WIDTH / 2, NORMAL_TILE_HEIGHT / 2);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_TILE_FRAME,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_TILE_FRAME,
                 canvas_x + NORMAL_TILE_WIDTH / 2 - 1,
                 canvas_y + NORMAL_TILE_HEIGHT - 1,
                 -(NORMAL_TILE_WIDTH / 2 - 1), -NORMAL_TILE_HEIGHT / 2);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_TILE_FRAME,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_TILE_FRAME,
                 canvas_x, canvas_y + NORMAL_TILE_HEIGHT / 2 - 1,
                 NORMAL_TILE_WIDTH / 2 - 1, -(NORMAL_TILE_HEIGHT / 2 - 1));
   } else {
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_NORMAL,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_NORMAL,
                 canvas_x, canvas_y, NORMAL_TILE_WIDTH - 1, 0);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_NORMAL,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_NORMAL,
                 canvas_x + NORMAL_TILE_WIDTH - 1, canvas_y,
                 0, NORMAL_TILE_HEIGHT - 1);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_NORMAL,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_NORMAL,
                 canvas_x, canvas_y, 0, NORMAL_TILE_HEIGHT - 1);
-    gui_put_line(pcanvas_store, COLOR_STD_RED, LINE_NORMAL,
+    gui_put_line(pcanvas, COLOR_STD_RED, LINE_NORMAL,
                 canvas_x, canvas_y + NORMAL_TILE_HEIGHT - 1,
                 NORMAL_TILE_WIDTH - 1, 0);
   }
@@ -800,7 +800,7 @@
    Draw the borders of the given map tile at the given canvas position
    in non-isometric view.
 **************************************************************************/
-static void tile_draw_borders(struct canvas_store *pcanvas_store,
+static void tile_draw_borders(struct canvas *pcanvas,
                              int map_x, int map_y,
                              int canvas_x, int canvas_y)
 {
@@ -816,7 +816,7 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)
       && this_owner) {
-    gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+    gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                 canvas_x + 1, canvas_y + 1,
                 0, NORMAL_TILE_HEIGHT - 1);
   }
@@ -826,7 +826,7 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)
       && this_owner) {
-    gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+    gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                 canvas_x + 1, canvas_y + 1, NORMAL_TILE_WIDTH - 1, 0);
   }
 
@@ -835,7 +835,7 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)
       && this_owner) {
-    gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+    gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                 canvas_x + NORMAL_TILE_WIDTH - 1, canvas_y + 1,
                 0, NORMAL_TILE_HEIGHT - 1);
   }
@@ -845,7 +845,7 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)
       && this_owner) {
-    gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+    gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                 canvas_x + 1, canvas_y + NORMAL_TILE_HEIGHT - 1,
                 NORMAL_TILE_WIDTH - 1, 0);
   }
@@ -855,7 +855,7 @@
   Draw the given map tile at the given canvas position in non-isometric
   view.
 **************************************************************************/
-void put_one_tile(struct canvas_store *pcanvas_store, int map_x, int map_y,
+void put_one_tile(struct canvas *pcanvas, int map_x, int map_y,
                  int canvas_x, int canvas_y, bool citymode)
 {
   struct drawn_sprite tile_sprs[80];
@@ -871,13 +871,13 @@
     if (solid_bg) {
       enum color_std color = pplayer ? player_color(pplayer)
              : COLOR_STD_BACKGROUND;
-      gui_put_rectangle(pcanvas_store, color, canvas_x, canvas_y,
+      gui_put_rectangle(pcanvas, color, canvas_x, canvas_y,
                         NORMAL_TILE_WIDTH, NORMAL_TILE_HEIGHT);
     }
 
     for (i = 0; i < count; i++) {
       if (tile_sprs[i].sprite) {
-       gui_put_sprite_full(pcanvas_store,
+       gui_put_sprite_full(pcanvas,
                            canvas_x + tile_sprs[i].offset_x,
                            canvas_y + tile_sprs[i].offset_y,
                            tile_sprs[i].sprite);
@@ -891,43 +891,43 @@
 
       if (!draw_map_grid) { /* it would be overwritten below */
         /* left side... */
-        gui_put_line(pcanvas_store, hilitecolor, LINE_NORMAL,
+        gui_put_line(pcanvas, hilitecolor, LINE_NORMAL,
             canvas_x, canvas_y,
             0, NORMAL_TILE_HEIGHT - 1);
 
         /* top side... */
-        gui_put_line(pcanvas_store, hilitecolor, LINE_NORMAL,
+        gui_put_line(pcanvas, hilitecolor, LINE_NORMAL,
             canvas_x, canvas_y,
             NORMAL_TILE_WIDTH - 1, 0);
       }
 
       /* right side... */
-      gui_put_line(pcanvas_store, hilitecolor, LINE_NORMAL,
+      gui_put_line(pcanvas, hilitecolor, LINE_NORMAL,
           canvas_x + NORMAL_TILE_WIDTH - 1, canvas_y,
           0, NORMAL_TILE_HEIGHT - 1);
 
       /* bottom side... */
-      gui_put_line(pcanvas_store, hilitecolor, LINE_NORMAL,
+      gui_put_line(pcanvas, hilitecolor, LINE_NORMAL,
           canvas_x, canvas_y + NORMAL_TILE_HEIGHT - 1,
           NORMAL_TILE_WIDTH - 1, 0);
     }
 
     if (draw_map_grid && !citymode) {
       /* left side... */
-      gui_put_line(pcanvas_store,
+      gui_put_line(pcanvas,
                   get_grid_color(map_x, map_y, map_x - 1, map_y),
                   LINE_NORMAL,
                   canvas_x, canvas_y, 0, NORMAL_TILE_HEIGHT);
 
       /* top side... */
-      gui_put_line(pcanvas_store,
+      gui_put_line(pcanvas,
                   get_grid_color(map_x, map_y, map_x, map_y - 1),
                   LINE_NORMAL,
                   canvas_x, canvas_y, NORMAL_TILE_WIDTH, 0);
     }
 
     /* Draw national borders. */
-    tile_draw_borders(pcanvas_store, map_x, map_y, canvas_x, canvas_y);
+    tile_draw_borders(pcanvas, map_x, map_y, canvas_x, canvas_y);
 
     if (draw_coastline && !draw_terrain) {
       enum tile_terrain_type t1 = map_get_terrain(map_x, map_y), t2;
@@ -937,7 +937,7 @@
       if (MAPSTEP(x1, y1, map_x, map_y, DIR8_WEST)) {
        t2 = map_get_terrain(x1, y1);
        if (is_ocean(t1) ^ is_ocean(t2)) {
-         gui_put_line(pcanvas_store, COLOR_STD_OCEAN, LINE_NORMAL,
+         gui_put_line(pcanvas, COLOR_STD_OCEAN, LINE_NORMAL,
                       canvas_x, canvas_y, 0, NORMAL_TILE_HEIGHT);
        }
       }
@@ -946,14 +946,14 @@
       if (MAPSTEP(x1, y1, map_x, map_y, DIR8_NORTH)) {
        t2 = map_get_terrain(x1, y1);
        if (is_ocean(t1) ^ is_ocean(t2)) {
-         gui_put_line(pcanvas_store, COLOR_STD_OCEAN, LINE_NORMAL,
+         gui_put_line(pcanvas, COLOR_STD_OCEAN, LINE_NORMAL,
                       canvas_x, canvas_y, NORMAL_TILE_WIDTH, 0);
        }
       }
     }
   } else {
     /* tile is unknown */
-    gui_put_rectangle(pcanvas_store, COLOR_STD_BLACK,
+    gui_put_rectangle(pcanvas, COLOR_STD_BLACK,
                      canvas_x, canvas_y,
                      NORMAL_TILE_WIDTH, NORMAL_TILE_HEIGHT);
   }
@@ -1003,7 +1003,7 @@
    Draw the borders of the given map tile at the given canvas position
    in isometric view.
 **************************************************************************/
-void tile_draw_borders_iso(struct canvas_store *pcanvas_store,
+void tile_draw_borders_iso(struct canvas *pcanvas,
                           int map_x, int map_y,
                           int canvas_x, int canvas_y,
                           enum draw_type draw)
@@ -1020,14 +1020,14 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)) {
     if (adjc_owner) {
-      gui_put_line(pcanvas_store, player_color(adjc_owner), LINE_BORDER,
+      gui_put_line(pcanvas, player_color(adjc_owner), LINE_BORDER,
                   canvas_x,
                   canvas_y + NORMAL_TILE_HEIGHT / 2 - 1,
                   NORMAL_TILE_WIDTH / 2,
                    -NORMAL_TILE_HEIGHT / 2);
     }
     if (this_owner) {
-      gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+      gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                   canvas_x,
                   canvas_y + NORMAL_TILE_HEIGHT / 2 + 1,
                   NORMAL_TILE_WIDTH / 2,
@@ -1040,14 +1040,14 @@
       && this_owner != (adjc_owner = map_get_owner(x1, y1))
       && tile_get_known(x1, y1)) {
     if (adjc_owner) {
-      gui_put_line(pcanvas_store, player_color(adjc_owner), LINE_BORDER,
+      gui_put_line(pcanvas, player_color(adjc_owner), LINE_BORDER,
                   canvas_x + NORMAL_TILE_WIDTH / 2,
                   canvas_y - 1,
                   NORMAL_TILE_WIDTH / 2,
                   NORMAL_TILE_HEIGHT / 2);
     }
     if (this_owner) {
-      gui_put_line(pcanvas_store, player_color(this_owner), LINE_BORDER,
+      gui_put_line(pcanvas, player_color(this_owner), LINE_BORDER,
                   canvas_x + NORMAL_TILE_WIDTH / 2,
                   canvas_y + 1,
                   NORMAL_TILE_WIDTH / 2,
@@ -1714,14 +1714,14 @@
 **************************************************************************/
 static void redraw_overview(void)
 {
-  struct canvas_store *dest = get_overview_window();
+  struct canvas *dest = get_overview_window();
 
   if (!dest || !overview.store) {
     return;
   }
 
   {
-    struct canvas_store *src = overview.store;
+    struct canvas *src = overview.store;
     int x = overview.map_x0 * OVERVIEW_TILE_WIDTH;
     int y = overview.map_y0 * OVERVIEW_TILE_HEIGHT;
     int ix = overview.width - x;
Index: client/mapview_common.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/mapview_common.h,v
retrieving revision 1.48
diff -u -r1.48 mapview_common.h
--- client/mapview_common.h     27 Feb 2004 16:30:31 -0000      1.48
+++ client/mapview_common.h     6 Mar 2004 20:18:30 -0000
@@ -20,13 +20,13 @@
 
 struct unit;
 
-struct canvas_store;           /* opaque type, real type is gui-dep */
+struct canvas; /* Opaque type; real type is gui-dependent. */
 
-struct canvas {
+struct mapview_canvas {
   int map_x0, map_y0;
   int width, height;           /* Size in pixels. */
   int tile_width, tile_height; /* Size in tiles. Rounded up. */
-  struct canvas_store *store;
+  struct canvas *store;
 };
 
 /* Holds all information about the overview aka minimap. */
@@ -34,10 +34,10 @@
   /* The following fields are controlled by mapview_common.c. */
   int map_x0, map_y0;
   int width, height;           /* Size in pixels. */
-  struct canvas_store *store;
+  struct canvas *store;
 };
 
-extern struct canvas mapview_canvas;
+extern struct mapview_canvas mapview_canvas;
 extern struct overview overview;
 
 /*
@@ -156,27 +156,27 @@
 bool tile_visible_mapcanvas(int map_x, int map_y);
 bool tile_visible_and_not_on_border_mapcanvas(int map_x, int map_y);
 
-void put_unit(struct unit *punit, struct canvas_store *pcanvas_store,
+void put_unit(struct unit *punit, struct canvas *pcanvas,
              int canvas_x, int canvas_y,
              int unit_offset_x, int unit_offset_y,
              int unit_width, int unit_height);
-void put_unit_full(struct unit *punit, struct canvas_store *pcanvas_store,
+void put_unit_full(struct unit *punit, struct canvas *pcanvas,
                   int canvas_x, int canvas_y);
 
 void put_city_tile_output(struct city *pcity, int city_x, int city_y,
-                         struct canvas_store *pcanvas_store,
+                         struct canvas *pcanvas,
                          int canvas_x, int canvas_y);
 void put_unit_city_overlays(struct unit *punit,
-                           struct canvas_store *pcanvas_store,
+                           struct canvas *pcanvas,
                            int canvas_x, int canvas_y);
-void put_red_frame_tile(struct canvas_store *pcanvas_store,
+void put_red_frame_tile(struct canvas *pcanvas,
                        int canvas_x, int canvas_y);
 
 void put_nuke_mushroom_pixmaps(int map_x, int map_y);
 
-void put_one_tile(struct canvas_store *pcanvas_store, int map_x, int map_y,
+void put_one_tile(struct canvas *pcanvas, int map_x, int map_y,
                  int canvas_x, int canvas_y, bool citymode);
-void tile_draw_borders_iso(struct canvas_store *pcanvas_store,
+void tile_draw_borders_iso(struct canvas *pcanvas,
                           int map_x, int map_y,
                           int canvas_x, int canvas_y,
                           enum draw_type draw);
Index: client/gui-gtk/citydlg.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk/citydlg.c,v
retrieving revision 1.179
diff -u -r1.179 citydlg.c
--- client/gui-gtk/citydlg.c    5 Mar 2004 18:16:01 -0000       1.179
+++ client/gui-gtk/citydlg.c    6 Mar 2004 20:18:30 -0000
@@ -1758,7 +1758,7 @@
 *****************************************************************/
 static void city_dialog_update_map(struct city_dialog *pdialog)
 {
-  struct canvas_store store = {pdialog->map_canvas_store};
+  struct canvas store = {pdialog->map_canvas_store};
 
   city_dialog_redraw_map(pdialog->pcity, &store);
 
Index: client/gui-gtk/gui_main.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk/gui_main.h,v
retrieving revision 1.14
diff -u -r1.14 gui_main.h
--- client/gui-gtk/gui_main.h   18 Feb 2004 02:20:51 -0000      1.14
+++ client/gui-gtk/gui_main.h   6 Mar 2004 20:18:31 -0000
@@ -18,7 +18,7 @@
 #include "gtkpixcomm.h"
 #include "gui_main_g.h"
 
-struct canvas_store
+struct canvas
 {
   GdkPixmap *pixmap;   /* if NULL, the pixcomm is drawn to instead. */
   GtkPixcomm *pixcomm;
Index: client/gui-gtk/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk/mapview.c,v
retrieving revision 1.201
diff -u -r1.201 mapview.c
--- client/gui-gtk/mapview.c    5 Mar 2004 18:16:01 -0000       1.201
+++ client/gui-gtk/mapview.c    6 Mar 2004 20:18:31 -0000
@@ -135,7 +135,7 @@
       } else {
        /* Not isometric. */
        /* FIXME: maybe do as described in the above comment. */
-       struct canvas_store store = {single_tile_pixmap};
+       struct canvas store = {single_tile_pixmap};
 
        put_one_tile(&store, losing_unit->x, losing_unit->y,
                     0, 0, FALSE);
@@ -355,7 +355,7 @@
                               int old_canvas_x, int old_canvas_y,
                               int new_canvas_x, int new_canvas_y)
 {
-  struct canvas_store store = {single_tile_pixmap};
+  struct canvas store = {single_tile_pixmap};
 
   /* Clear old sprite. */
   gdk_draw_pixmap(map_canvas->window, civ_gc, map_canvas_store, old_canvas_x,
@@ -387,9 +387,9 @@
 /**************************************************************************
 ...
 **************************************************************************/
-struct canvas_store *canvas_store_create(int width, int height)
+struct canvas *canvas_store_create(int width, int height)
 {
-  struct canvas_store *result = fc_malloc(sizeof(*result));
+  struct canvas *result = fc_malloc(sizeof(*result));
 
   result->pixmap = gdk_pixmap_new(root_window, width, height, -1);
   result->pixcomm = NULL;
@@ -399,7 +399,7 @@
 /**************************************************************************
 ...
 **************************************************************************/
-void canvas_store_free(struct canvas_store *store)
+void canvas_store_free(struct canvas *store)
 {
   gdk_pixmap_unref(store->pixmap);
   assert(store->pixcomm == NULL);
@@ -409,9 +409,9 @@
 /****************************************************************************
   Return a canvas that is the overview window.
 ****************************************************************************/
-struct canvas_store *get_overview_window(void)
+struct canvas *get_overview_window(void)
 {
-  static struct canvas_store store;
+  static struct canvas store;
 
   store.pixmap = overview_canvas->window;
 
@@ -438,7 +438,7 @@
 /**************************************************************************
 ...
 **************************************************************************/
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height)
 {
@@ -528,14 +528,14 @@
 /**************************************************************************
   Draw some or all of a tile onto the canvas.
 **************************************************************************/
-void put_one_tile_iso(struct canvas_store *pcanvas_store,
+void put_one_tile_iso(struct canvas *pcanvas,
                      int map_x, int map_y,
                      int canvas_x, int canvas_y,
                      int offset_x, int offset_y, int offset_y_unit,
                      int width, int height, int height_unit,
                      enum draw_type draw, bool citymode)
 {
-  pixmap_put_tile_iso(pcanvas_store->pixmap,
+  pixmap_put_tile_iso(pcanvas->pixmap,
                      map_x, map_y, canvas_x, canvas_y,
                      citymode,
                      offset_x, offset_y, offset_y_unit,
@@ -713,7 +713,7 @@
 **************************************************************************/
 void put_unit_gpixmap(struct unit *punit, GtkPixcomm *p)
 {
-  struct canvas_store canvas_store = {NULL, p};
+  struct canvas canvas_store = {NULL, p};
 
   put_unit_full(punit, &canvas_store, 0, 0);
 
@@ -728,7 +728,7 @@
 **************************************************************************/
 void put_unit_gpixmap_city_overlays(struct unit *punit, GtkPixcomm *p)
 {
-  struct canvas_store store = {NULL, p};
+  struct canvas store = {NULL, p};
 
   put_unit_city_overlays(punit, &store, 0, NORMAL_TILE_HEIGHT);
 }
@@ -779,16 +779,16 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
 {
-  if (pcanvas_store->pixmap) {
-    pixmap_put_sprite(pcanvas_store->pixmap, canvas_x, canvas_y,
+  if (pcanvas->pixmap) {
+    pixmap_put_sprite(pcanvas->pixmap, canvas_x, canvas_y,
                      sprite, offset_x, offset_y, width, height);
   } else {
-    gtk_pixcomm_copyto(pcanvas_store->pixcomm, sprite,
+    gtk_pixcomm_copyto(pcanvas->pixcomm, sprite,
                       canvas_x, canvas_y, FALSE);
   }
 }
@@ -796,11 +796,11 @@
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
-  gui_put_sprite(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite(pcanvas, canvas_x, canvas_y,
                 sprite,
                 0, 0, sprite->width, sprite->height);
 }
@@ -819,23 +819,23 @@
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
-  if (pcanvas_store->pixmap) {
+  if (pcanvas->pixmap) {
     gdk_gc_set_foreground(fill_bg_gc, colors_standard[color]);
-    gdk_draw_rectangle(pcanvas_store->pixmap, fill_bg_gc, TRUE,
+    gdk_draw_rectangle(pcanvas->pixmap, fill_bg_gc, TRUE,
                       canvas_x, canvas_y, width, height);
   } else {
-    gtk_pixcomm_fill(pcanvas_store->pixcomm, colors_standard[color], FALSE);
+    gtk_pixcomm_fill(pcanvas->pixcomm, colors_standard[color], FALSE);
   }
 }
 
 /**************************************************************************
   Draw a colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
@@ -854,7 +854,7 @@
   }
 
   gdk_gc_set_foreground(gc, colors_standard[color]);
-  gdk_draw_line(pcanvas_store->pixmap, gc,
+  gdk_draw_line(pcanvas->pixmap, gc,
                start_x, start_y, start_x + dx, start_y + dy);
 }
 
@@ -912,7 +912,7 @@
 {
   int canvas_x, canvas_y;
   static struct city *last_pcity=NULL;
-  struct canvas_store store = {map_canvas->window, NULL};
+  struct canvas store = {map_canvas->window, NULL};
 
   if (color==-1) {
     if (pcity!=last_pcity)
@@ -1297,7 +1297,7 @@
   enum tile_special_type special;
   int count, i = 0, dither_count;
   bool solid_bg, fog, tile_hilited;
-  struct canvas_store canvas_store = {pm};
+  struct canvas canvas_store = {pm};
 
   if (!width || !(height || height_unit))
     return;
Index: client/gui-gtk-2.0/citydlg.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk-2.0/citydlg.c,v
retrieving revision 1.76
diff -u -r1.76 citydlg.c
--- client/gui-gtk-2.0/citydlg.c        5 Mar 2004 18:16:01 -0000       1.76
+++ client/gui-gtk-2.0/citydlg.c        6 Mar 2004 20:18:31 -0000
@@ -1359,7 +1359,7 @@
 *****************************************************************/
 static void city_dialog_update_map(struct city_dialog *pdialog)
 {
-  struct canvas_store store = {pdialog->map_canvas_store};
+  struct canvas store = {pdialog->map_canvas_store};
 
   city_dialog_redraw_map(pdialog->pcity, &store);
 
Index: client/gui-gtk-2.0/gui_main.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk-2.0/gui_main.h,v
retrieving revision 1.10
diff -u -r1.10 gui_main.h
--- client/gui-gtk-2.0/gui_main.h       18 Feb 2004 02:20:51 -0000      1.10
+++ client/gui-gtk-2.0/gui_main.h       6 Mar 2004 20:18:31 -0000
@@ -18,7 +18,7 @@
 #include "gtkpixcomm.h"
 #include "gui_main_g.h"
 
-struct canvas_store
+struct canvas
 {
   GdkPixmap *pixmap;   /* if NULL, the pixcomm is drawn to instead. */
   GtkPixcomm *pixcomm;
Index: client/gui-gtk-2.0/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-gtk-2.0/mapview.c,v
retrieving revision 1.101
diff -u -r1.101 mapview.c
--- client/gui-gtk-2.0/mapview.c        5 Mar 2004 18:16:01 -0000       1.101
+++ client/gui-gtk-2.0/mapview.c        6 Mar 2004 20:18:31 -0000
@@ -136,7 +136,7 @@
       } else {
        /* Not isometric. */
        /* FIXME: maybe do as described in the above comment. */
-       struct canvas_store store = {single_tile_pixmap};
+       struct canvas store = {single_tile_pixmap};
 
        put_one_tile(&store, losing_unit->x, losing_unit->y,
                     0, 0, FALSE);
@@ -399,7 +399,7 @@
                               int old_canvas_x, int old_canvas_y,
                               int new_canvas_x, int new_canvas_y)
 {
-  struct canvas_store store = {single_tile_pixmap};
+  struct canvas store = {single_tile_pixmap};
 
   /* Clear old sprite. */
   gdk_draw_drawable(map_canvas->window, civ_gc, map_canvas_store, old_canvas_x,
@@ -433,9 +433,9 @@
 /**************************************************************************
 ...
 **************************************************************************/
-struct canvas_store *canvas_store_create(int width, int height)
+struct canvas *canvas_store_create(int width, int height)
 {
-  struct canvas_store *result = fc_malloc(sizeof(*result));
+  struct canvas *result = fc_malloc(sizeof(*result));
 
   result->pixmap = gdk_pixmap_new(root_window, width, height, -1);
   result->pixcomm = NULL;
@@ -445,7 +445,7 @@
 /**************************************************************************
 ...
 **************************************************************************/
-void canvas_store_free(struct canvas_store *store)
+void canvas_store_free(struct canvas *store)
 {
   g_object_unref(store->pixmap);
   assert(store->pixcomm == NULL);
@@ -455,9 +455,9 @@
 /****************************************************************************
   Return a canvas that is the overview window.
 ****************************************************************************/
-struct canvas_store *get_overview_window(void)
+struct canvas *get_overview_window(void)
 {
-  static struct canvas_store store;
+  static struct canvas store;
 
   store.pixmap = overview_canvas->window;
 
@@ -594,14 +594,14 @@
 /**************************************************************************
   Draw some or all of a tile onto the canvas.
 **************************************************************************/
-void put_one_tile_iso(struct canvas_store *pcanvas_store,
+void put_one_tile_iso(struct canvas *pcanvas,
                      int map_x, int map_y,
                      int canvas_x, int canvas_y,
                      int offset_x, int offset_y, int offset_y_unit,
                      int width, int height, int height_unit,
                      enum draw_type draw, bool citymode)
 {
-  pixmap_put_tile_iso(pcanvas_store->pixmap,
+  pixmap_put_tile_iso(pcanvas->pixmap,
                      map_x, map_y, canvas_x, canvas_y,
                      citymode,
                      offset_x, offset_y, offset_y_unit,
@@ -775,7 +775,7 @@
 **************************************************************************/
 void put_unit_gpixmap(struct unit *punit, GtkPixcomm *p)
 {
-  struct canvas_store canvas_store = {NULL, p};
+  struct canvas canvas_store = {NULL, p};
 
   gtk_pixcomm_freeze(p);
   gtk_pixcomm_clear(p);
@@ -794,7 +794,7 @@
 **************************************************************************/
 void put_unit_gpixmap_city_overlays(struct unit *punit, GtkPixcomm *p)
 {
-  struct canvas_store store = {NULL, p};
+  struct canvas store = {NULL, p};
  
   gtk_pixcomm_freeze(p);
 
@@ -849,28 +849,28 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
 {
-  if (pcanvas_store->pixmap) {
-    pixmap_put_sprite(pcanvas_store->pixmap, canvas_x, canvas_y,
+  if (pcanvas->pixmap) {
+    pixmap_put_sprite(pcanvas->pixmap, canvas_x, canvas_y,
                      sprite, offset_x, offset_y, width, height);
   } else {
-    gtk_pixcomm_copyto(pcanvas_store->pixcomm, sprite, canvas_x, canvas_y);
+    gtk_pixcomm_copyto(pcanvas->pixcomm, sprite, canvas_x, canvas_y);
   }
 } 
 
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
     assert(sprite->pixmap);
-  gui_put_sprite(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite(pcanvas, canvas_x, canvas_y,
                 sprite,
                 0, 0, sprite->width, sprite->height);
 }
@@ -889,23 +889,23 @@
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
-  if (pcanvas_store->pixmap) {
+  if (pcanvas->pixmap) {
     gdk_gc_set_foreground(fill_bg_gc, colors_standard[color]);
-    gdk_draw_rectangle(pcanvas_store->pixmap, fill_bg_gc, TRUE,
+    gdk_draw_rectangle(pcanvas->pixmap, fill_bg_gc, TRUE,
                       canvas_x, canvas_y, width, height);
   } else {
-    gtk_pixcomm_fill(pcanvas_store->pixcomm, colors_standard[color]);
+    gtk_pixcomm_fill(pcanvas->pixcomm, colors_standard[color]);
   }
 }
 
 /**************************************************************************
   Draw a colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
@@ -924,14 +924,14 @@
   }
 
   gdk_gc_set_foreground(gc, colors_standard[color]);
-  gdk_draw_line(pcanvas_store->pixmap, gc,
+  gdk_draw_line(pcanvas->pixmap, gc,
                start_x, start_y, start_x + dx, start_y + dy);
 }
 
 /**************************************************************************
 ...
 **************************************************************************/
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height)
 {
@@ -993,7 +993,7 @@
 {
   int canvas_x, canvas_y;
   static struct city *last_pcity=NULL;
-  struct canvas_store store = {map_canvas->window, NULL};
+  struct canvas store = {map_canvas->window, NULL};
 
   if (color==-1) {
     if (pcity!=last_pcity)
@@ -1378,7 +1378,7 @@
   enum tile_special_type special;
   int count, i = 0, dither_count;
   bool solid_bg, fog, tile_hilited;
-  struct canvas_store canvas_store = {pm};
+  struct canvas canvas_store = {pm};
 
   if (!width || !(height || height_unit))
     return;
Index: client/gui-sdl/graphics.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-sdl/graphics.c,v
retrieving revision 1.29
diff -u -r1.29 graphics.c
--- client/gui-sdl/graphics.c   2 Oct 2003 21:37:44 -0000       1.29
+++ client/gui-sdl/graphics.c   6 Mar 2004 20:18:32 -0000
@@ -73,7 +73,7 @@
 #include "patrol_cursor.xbm"
 #include "patrol_cursor_mask.xbm"
 
-struct canvas_store Main;
+struct canvas Main;
 
 static SDL_Surface *pIntro_gfx = NULL;
 
Index: client/gui-sdl/graphics.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-sdl/graphics.h,v
retrieving revision 1.16
diff -u -r1.16 graphics.h
--- client/gui-sdl/graphics.h   31 Aug 2003 22:00:18 -0000      1.16
+++ client/gui-sdl/graphics.h   6 Mar 2004 20:18:32 -0000
@@ -170,7 +170,7 @@
 
 #define GET_SURF(m_sprite)     (m_sprite->psurface)
 
-struct canvas_store {
+struct canvas {
   int rects_count;             /* update rect. array counter */
   int guis_count;              /* gui buffers array counter */
   SDL_Rect rects[RECT_LIMIT];  /* update rect. list */
Index: client/gui-sdl/gui_main.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-sdl/gui_main.h,v
retrieving revision 1.21
diff -u -r1.21 gui_main.h
--- client/gui-sdl/gui_main.h   27 Sep 2003 15:02:32 -0000      1.21
+++ client/gui-sdl/gui_main.h   6 Mar 2004 20:18:32 -0000
@@ -53,7 +53,7 @@
 #define CF_DRAW_PLAYERS_ALLIANCE_STATUS        (1<<22)
 #define CF_DRAW_PLAYERS_NEUTRAL_STATUS (1<<23)
 
-extern struct canvas_store Main;
+extern struct canvas Main;
 extern struct GUI *pSellected_Widget;
 extern Uint32 SDL_Client_Flags;
 extern bool LSHIFT;
Index: client/gui-sdl/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-sdl/mapview.c,v
retrieving revision 1.65
diff -u -r1.65 mapview.c
--- client/gui-sdl/mapview.c    5 Jan 2004 00:18:30 -0000       1.65
+++ client/gui-sdl/mapview.c    6 Mar 2004 20:18:33 -0000
@@ -153,48 +153,48 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pCanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
 {
   SDL_Rect src = {offset_x, offset_y, width, height};
   SDL_Rect dst = {canvas_x + offset_x, canvas_y + offset_y, 0, 0};
-  SDL_BlitSurface(GET_SURF(sprite), &src, pCanvas_store->map, &dst);
+  SDL_BlitSurface(GET_SURF(sprite), &src, pcanvas->map, &dst);
 }
 
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pCanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
   SDL_Rect dst = {canvas_x, canvas_y, 0, 0};
-  SDL_BlitSurface(GET_SURF(sprite), NULL, pCanvas_store->map, &dst);
+  SDL_BlitSurface(GET_SURF(sprite), NULL, pcanvas->map, &dst);
 }
 
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pCanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
   SDL_Rect dst = {canvas_x, canvas_y, width, height};
-  SDL_FillRect(pCanvas_store->map, &dst,
-           get_game_color(color, pCanvas_store->map));
+  SDL_FillRect(pcanvas->map, &dst,
+           get_game_color(color, pcanvas->map));
 }
 
 /**************************************************************************
   Draw a 1-pixel-width colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pCanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
-  putline(pCanvas_store->map, start_x, start_y, start_x + dx, start_y + dy,
-                               get_game_color(color, pCanvas_store->map));
+  putline(pcanvas->map, start_x, start_y, start_x + dx, start_y + dy,
+                               get_game_color(color, pcanvas->map));
 }
 
 static bool is_flush_queued = FALSE;
@@ -3120,7 +3120,7 @@
   int city_x, city_y;
   int map_x, map_y, canvas_x, canvas_y;
   int draw_units_backup = draw_units;
-  struct canvas_store store;
+  struct canvas store;
   SDL_Surface *pDest = create_surf(get_citydlg_canvas_width(),
                                   get_citydlg_canvas_height(), SDL_SWSURFACE);
 
Index: client/gui-stub/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-stub/mapview.c,v
retrieving revision 1.37
diff -u -r1.37 mapview.c
--- client/gui-stub/mapview.c   23 Feb 2004 20:03:56 -0000      1.37
+++ client/gui-stub/mapview.c   6 Mar 2004 20:18:33 -0000
@@ -139,7 +139,7 @@
 /**************************************************************************
   Create a canvas of the given size.
 **************************************************************************/
-struct canvas_store *canvas_store_create(int width, int height)
+struct canvas *canvas_store_create(int width, int height)
 {
   /* PORTME */
   return NULL;
@@ -149,7 +149,7 @@
   Free any resources associated with this canvas and the canvas struct
   itself.
 **************************************************************************/
-void canvas_store_free(struct canvas_store *store)
+void canvas_store_free(struct canvas *store)
 {
   /* PORTME */
 }
@@ -169,7 +169,7 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
@@ -180,7 +180,7 @@
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
@@ -190,7 +190,7 @@
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
@@ -200,7 +200,7 @@
 /**************************************************************************
   Draw a 1-pixel-width colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
@@ -210,7 +210,7 @@
 /**************************************************************************
   Copies an area from the source canvas to the destination canvas.
 **************************************************************************/
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height)
 {
Index: client/gui-win32/citydlg.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-win32/citydlg.c,v
retrieving revision 1.73
diff -u -r1.73 citydlg.c
--- client/gui-win32/citydlg.c  5 Mar 2004 18:16:01 -0000       1.73
+++ client/gui-win32/citydlg.c  6 Mar 2004 20:18:34 -0000
@@ -294,7 +294,8 @@
   struct unit_list *plist;
   struct genlist_link *myiter;
   struct unit *punit;
-  struct canvas_store canvas_store = {hdc, NULL};
+  struct canvas canvas_store = {hdc, NULL};
+
   if(unitid) {
     for(i=0; i<NUM_UNITS_SHOWN; i++)
       if(pdialog->present_unit_ids[i]==unitid)
@@ -350,7 +351,8 @@
   struct unit_list *plist;
   struct genlist_link *myiter;
   struct unit *punit;    
-  struct canvas_store canvas_store = {hdc, NULL};
+  struct canvas canvas_store = {hdc, NULL};
+
   if(unitid) {
     for(i=0; i<NUM_UNITS_SHOWN; i++)
       if(pdialog->support_unit_ids[i]==unitid)
@@ -368,7 +370,7 @@
   for(i=0; i<NUM_UNITS_SHOWN&&ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter),i++)
     {
       RECT rc;
-      struct canvas_store store = {hdc, NULL};
+      struct canvas store = {hdc, NULL};
 
       punit=(struct unit*)ITERATOR_PTR(myiter);
       if(unitid && punit->id!=unitid)
@@ -499,7 +501,7 @@
 void city_dialog_update_map(HDC hdc,struct city_dialog *pdialog)
 {
   HBITMAP oldbit;
-  struct canvas_store store;
+  struct canvas store;
 
   oldbit=SelectObject(citydlgdc,pdialog->map_bmp);
   BitBlt(citydlgdc,0,0,pdialog->map_w,pdialog->map_h,
Index: client/gui-win32/dialogs.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-win32/dialogs.c,v
retrieving revision 1.42
diff -u -r1.42 dialogs.c
--- client/gui-win32/dialogs.c  8 Feb 2004 21:56:51 -0000       1.42
+++ client/gui-win32/dialogs.c  6 Mar 2004 20:18:34 -0000
@@ -772,7 +772,7 @@
   max_height+=4;
   for (i=0;i<n;i++)
     {
-      struct canvas_store canvas_store={unitsel_dc, NULL};
+      struct canvas canvas_store = {unitsel_dc, NULL};
       struct unit *punit=unit_list_get(&ptile->units, i);
       struct unit_type *punittemp=unit_type(punit);
       struct city *pcity;
Index: client/gui-win32/graphics.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-win32/graphics.h,v
retrieving revision 1.6
diff -u -r1.6 graphics.h
--- client/gui-win32/graphics.h 20 Feb 2003 23:14:33 -0000      1.6
+++ client/gui-win32/graphics.h 6 Mar 2004 20:18:34 -0000
@@ -36,7 +36,7 @@
   int cache_id;
 };
 
-struct canvas_store
+struct canvas
 {
   HDC hdc;
   HBITMAP bitmap;
Index: client/gui-win32/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-win32/mapview.c,v
retrieving revision 1.98
diff -u -r1.98 mapview.c
--- client/gui-win32/mapview.c  5 Mar 2004 18:16:01 -0000       1.98
+++ client/gui-win32/mapview.c  6 Mar 2004 20:18:34 -0000
@@ -87,9 +87,9 @@
 /***************************************************************************
  ...
 ***************************************************************************/
-struct canvas_store *canvas_store_create(int width, int height)
+struct canvas *canvas_store_create(int width, int height)
 {
-  struct canvas_store *result = fc_malloc(sizeof(*result));
+  struct canvas *result = fc_malloc(sizeof(*result));
   HDC hdc;
   hdc = GetDC(root_window);
   result->bitmap = CreateCompatibleBitmap(hdc, width, height);
@@ -101,18 +101,18 @@
 /***************************************************************************
   ...
 ***************************************************************************/
-void canvas_store_free(struct canvas_store *store)
+void canvas_store_free(struct canvas *store)
 {
   DeleteObject(store->bitmap);
   free(store);
 }
 
-static struct canvas_store overview_store;
+static struct canvas overview_store;
 
 /****************************************************************************
   Return a canvas that is the overview window.
 ****************************************************************************/
-struct canvas_store *get_overview_window(void)
+struct canvas *get_overview_window(void)
 {
   return &overview_store;
 }
@@ -120,7 +120,7 @@
 /***************************************************************************
    ...
 ***************************************************************************/
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                                     int src_x, int src_y, int dest_x, int 
dest_y, int width,
                                                          int height)
 {
@@ -688,7 +688,7 @@
 {
   static HDC mapstoredc, hdc, hdcwin;
   static HBITMAP old, oldbmp;
-  static struct canvas_store canvas_store;
+  static struct canvas canvas_store;
   /* Create extra backing store.  This should be done statically. */
   if (first_frame) {
     mapstoredc = CreateCompatibleDC(NULL);
@@ -780,7 +780,7 @@
             NORMAL_TILE_WIDTH,NORMAL_TILE_HEIGHT,
             hdc,0,0,SRCCOPY);
     } else {
-      struct canvas_store store = {NULL, single_tile_pixmap};
+      struct canvas store = {NULL, single_tile_pixmap};
 
       put_one_tile(&store, losing_unit->x, losing_unit->y, 0, 0, FALSE);
       put_unit_full(losing_unit, &store, 0, 0);
@@ -1082,14 +1082,14 @@
 /**************************************************************************
   Draw some or all of a tile onto the canvas.
 **************************************************************************/
-void put_one_tile_iso(struct canvas_store *pcanvas_store,
+void put_one_tile_iso(struct canvas *pcanvas,
                      int map_x, int map_y,
                      int canvas_x, int canvas_y,
                      int offset_x, int offset_y, int offset_y_unit,
                      int width, int height, int height_unit,
                      enum draw_type draw, bool citymode)
 {
-  pixmap_put_tile_iso(pcanvas_store->hdc, map_x, map_y,
+  pixmap_put_tile_iso(pcanvas->hdc, map_x, map_y,
                      canvas_x, canvas_y, 0,
                      offset_x, offset_y, offset_y_unit,
                      width, height, height_unit,
@@ -1099,7 +1099,7 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
@@ -1108,16 +1108,16 @@
   HBITMAP old = NULL; /*Remove warning*/
 
   /* FIXME: we don't want to have to recreate the hdc each time! */
-  if (pcanvas_store->bitmap) {
-    hdc = CreateCompatibleDC(pcanvas_store->hdc);
-    old = SelectObject(hdc, pcanvas_store->bitmap);
+  if (pcanvas->bitmap) {
+    hdc = CreateCompatibleDC(pcanvas->hdc);
+    old = SelectObject(hdc, pcanvas->bitmap);
   } else {
-    hdc = pcanvas_store->hdc;
+    hdc = pcanvas->hdc;
   }
   pixmap_put_overlay_tile_draw(hdc, canvas_x, canvas_y,
                               sprite, offset_x, offset_y,
                               width, height, 0);
-  if (pcanvas_store->bitmap) {
+  if (pcanvas->bitmap) {
     SelectObject(hdc, old);
     DeleteDC(hdc);
   }
@@ -1126,18 +1126,18 @@
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
-  gui_put_sprite(pcanvas_store, canvas_x, canvas_y, sprite,
+  gui_put_sprite(pcanvas, canvas_x, canvas_y, sprite,
                 0, 0, sprite->width, sprite->height);
 }
 
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
@@ -1145,11 +1145,11 @@
   HBITMAP old = NULL; /*Remove warning*/
   RECT rect;
 
-  if (pcanvas_store->bitmap) {
-    hdc = CreateCompatibleDC(pcanvas_store->hdc);
-    old = SelectObject(hdc, pcanvas_store->bitmap);
+  if (pcanvas->bitmap) {
+    hdc = CreateCompatibleDC(pcanvas->hdc);
+    old = SelectObject(hdc, pcanvas->bitmap);
   } else {
-    hdc = pcanvas_store->hdc;
+    hdc = pcanvas->hdc;
   }
 
   /*"+1"s are needed because FillRect doesn't fill bottom and right edges*/
@@ -1158,7 +1158,7 @@
 
   FillRect(hdc, &rect, brush_std[color]);
 
-  if (pcanvas_store->bitmap) {
+  if (pcanvas->bitmap) {
     SelectObject(hdc, old);
     DeleteDC(hdc);
   }
@@ -1167,7 +1167,7 @@
 /**************************************************************************
   Draw a 1-pixel-width colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
@@ -1175,11 +1175,11 @@
   HBITMAP old = NULL; /*Remove warning*/
   HPEN old_pen;
 
-  if (pcanvas_store->hdc) {
-    hdc = pcanvas_store->hdc;
-  } else if (pcanvas_store->bitmap) {
-    hdc = CreateCompatibleDC(pcanvas_store->hdc);
-    old = SelectObject(hdc, pcanvas_store->bitmap);
+  if (pcanvas->hdc) {
+    hdc = pcanvas->hdc;
+  } else if (pcanvas->bitmap) {
+    hdc = CreateCompatibleDC(pcanvas->hdc);
+    old = SelectObject(hdc, pcanvas->bitmap);
   } else {
     hdc = GetDC(root_window);
   }
@@ -1189,8 +1189,8 @@
   LineTo(hdc, start_x + dx, start_y + dy);
   SelectObject(hdc, old_pen);
 
-  if (!pcanvas_store->hdc) {
-    if (pcanvas_store->bitmap) {
+  if (!pcanvas->hdc) {
+    if (pcanvas->bitmap) {
       SelectObject(hdc, old);
       DeleteDC(hdc);
     } else {
@@ -1263,7 +1263,7 @@
   struct Sprite *dither[4];
   struct city *pcity;
   struct unit *punit, *pfocus;
-  struct canvas_store canvas_store={hdc,NULL};
+  struct canvas canvas_store={hdc,NULL};
   enum tile_special_type special;
   int count, i = 0, dither_count;
   bool fog, solid_bg, is_real;
Index: client/gui-xaw/citydlg.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-xaw/citydlg.c,v
retrieving revision 1.112
diff -u -r1.112 citydlg.c
--- client/gui-xaw/citydlg.c    5 Mar 2004 18:16:01 -0000       1.112
+++ client/gui-xaw/citydlg.c    6 Mar 2004 20:18:34 -0000
@@ -354,7 +354,7 @@
   struct city_dialog *pdialog;
   
   if((pdialog=get_city_dialog(pcity))) {
-    struct canvas_store store = {XtWindow(pdialog->map_canvas)};
+    struct canvas store = {XtWindow(pdialog->map_canvas)};
 
     city_dialog_update_improvement_list(pdialog);
     city_dialog_update_title(pdialog);
@@ -464,7 +464,7 @@
                                   void *client_data)
 {
   struct city_dialog *pdialog = client_data;
-  struct canvas_store store = {XtWindow(pdialog->map_canvas)};
+  struct canvas store = {XtWindow(pdialog->map_canvas)};
   
   city_dialog_redraw_map(pdialog->pcity, &store);
 }
@@ -1682,7 +1682,7 @@
   i = 0; /* number of displayed units */
   j = 0; /* index into list */
   unit_list_iterate(*plist, punit) {
-    struct canvas_store store;
+    struct canvas store;
 
     if (j++ < pdialog->support_unit_base) {
       continue;
@@ -1746,7 +1746,7 @@
   i = 0; /* number of displayed units */
   j = 0; /* index into list */
   unit_list_iterate(*plist, punit) {
-    struct canvas_store store;
+    struct canvas store;
 
     if (j++ < pdialog->present_unit_base) {
       continue;
Index: client/gui-xaw/dialogs.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-xaw/dialogs.c,v
retrieving revision 1.91
diff -u -r1.91 dialogs.c
--- client/gui-xaw/dialogs.c    31 Jan 2004 14:56:24 -0000      1.91
+++ client/gui-xaw/dialogs.c    6 Mar 2004 20:18:34 -0000
@@ -1577,7 +1577,7 @@
     struct unit *punit=unit_list_get(&ptile->units, i);
     struct unit_type *punittemp=unit_type(punit);
     struct city *pcity;
-    struct canvas_store store;
+    struct canvas store;
     
     if(!(i%r))  {
       nargs=0;
Index: client/gui-xaw/graphics.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-xaw/graphics.h,v
retrieving revision 1.9
diff -u -r1.9 graphics.h
--- client/gui-xaw/graphics.h   20 Feb 2003 23:14:33 -0000      1.9
+++ client/gui-xaw/graphics.h   6 Mar 2004 20:18:34 -0000
@@ -24,7 +24,7 @@
   int has_mask;
 };
 
-struct canvas_store {
+struct canvas {
   Pixmap pixmap;
 };
 
Index: client/gui-xaw/gui_main.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-xaw/gui_main.c,v
retrieving revision 1.88
diff -u -r1.88 gui_main.c
--- client/gui-xaw/gui_main.c   26 Feb 2004 13:38:45 -0000      1.88
+++ client/gui-xaw/gui_main.c   6 Mar 2004 20:18:34 -0000
@@ -843,7 +843,7 @@
   
   XawPixcommClear(w);
   if (punit) {
-    struct canvas_store store = {XawPixcommPixmap(w)};
+    struct canvas store = {XawPixcommPixmap(w)};
 
     put_unit_full(punit, &store, 0, 0);
     xaw_expose_now(w);
Index: client/gui-xaw/mapview.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/gui-xaw/mapview.c,v
retrieving revision 1.164
diff -u -r1.164 mapview.c
--- client/gui-xaw/mapview.c    5 Mar 2004 18:16:01 -0000       1.164
+++ client/gui-xaw/mapview.c    6 Mar 2004 20:18:35 -0000
@@ -100,7 +100,7 @@
   if (map_to_canvas_pos(&canvas_x, &canvas_y,
                        losing_unit->x, losing_unit->y)) {
     for (i = 0; i < num_tiles_explode_unit; i++) {
-      struct canvas_store store = {single_tile_pixmap};
+      struct canvas store = {single_tile_pixmap};
 
       anim_timer = renew_timer_start(anim_timer, TIMER_USER, TIMER_ACTIVE);
 
@@ -145,9 +145,9 @@
 /**************************************************************************
 ...
 **************************************************************************/
-struct canvas_store *canvas_store_create(int width, int height)
+struct canvas *canvas_store_create(int width, int height)
 {
-  struct canvas_store *result = fc_malloc(sizeof(*result));
+  struct canvas *result = fc_malloc(sizeof(*result));
 
   result->pixmap =
       XCreatePixmap(display, root_window, width, height, display_depth);
@@ -157,7 +157,7 @@
 /**************************************************************************
 ...
 **************************************************************************/
-void canvas_store_free(struct canvas_store *store)
+void canvas_store_free(struct canvas *store)
 {
   XFreePixmap(display, store->pixmap);
   free(store);
@@ -166,9 +166,9 @@
 /****************************************************************************
   Return a canvas that is the overview window.
 ****************************************************************************/
-struct canvas_store *get_overview_window(void)
+struct canvas *get_overview_window(void)
 {
-  static struct canvas_store store;
+  static struct canvas store;
 
   store.pixmap = XtWindow(overview_canvas);
 
@@ -362,7 +362,7 @@
                               int old_canvas_x, int old_canvas_y,
                               int new_canvas_x, int new_canvas_y)
 {
-  struct canvas_store store = {single_tile_pixmap};
+  struct canvas store = {single_tile_pixmap};
 
   /* Clear old sprite. */
   XCopyArea(display, map_canvas_store, XtWindow(map_canvas), civ_gc,
@@ -410,7 +410,7 @@
 /**************************************************************************
 ...
 **************************************************************************/
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height)
 {
@@ -475,7 +475,7 @@
 /**************************************************************************
   Draw some or all of a tile onto the canvas.
 **************************************************************************/
-void put_one_tile_iso(struct canvas_store *pcanvas_store,
+void put_one_tile_iso(struct canvas *pcanvas,
                      int map_x, int map_y,
                      int canvas_x, int canvas_y,
                      int offset_x, int offset_y, int offset_y_unit,
@@ -514,42 +514,42 @@
 /**************************************************************************
   Draw some or all of a sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y, int width, int height)
 {
-  pixmap_put_sprite(pcanvas_store->pixmap, canvas_x, canvas_y,
+  pixmap_put_sprite(pcanvas->pixmap, canvas_x, canvas_y,
                    sprite, offset_x, offset_y, width, height);
 }
 
 /**************************************************************************
   Draw a full sprite onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite)
 {
-  gui_put_sprite(pcanvas_store, canvas_x, canvas_y,
+  gui_put_sprite(pcanvas, canvas_x, canvas_y,
                 sprite, 0, 0, sprite->width, sprite->height);
 }
 
 /**************************************************************************
   Draw a filled-in colored rectangle onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height)
 {
   XSetForeground(display, fill_bg_gc, colors_standard[color]);
-  XFillRectangle(display, pcanvas_store->pixmap, fill_bg_gc,
+  XFillRectangle(display, pcanvas->pixmap, fill_bg_gc,
                 canvas_x, canvas_y, width, height);
 }
 
 /**************************************************************************
   Draw a 1-pixel-width colored line onto the mapview or citydialog canvas.
 **************************************************************************/
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy)
 {
@@ -557,7 +557,7 @@
 
   gc = (ltype == LINE_BORDER ? border_line_gc : civ_gc);
   XSetForeground(display, gc, colors_standard[color]);
-  XDrawLine(display, pcanvas_store->pixmap, gc,
+  XDrawLine(display, pcanvas->pixmap, gc,
            start_x, start_y, start_x + dx, start_y + dy);
 }
 
@@ -781,7 +781,7 @@
 **************************************************************************/
 void put_unit_pixmap_city_overlays(struct unit *punit, Pixmap pm)
 {
-  struct canvas_store store = {pm};
+  struct canvas store = {pm};
  
   /* wipe the slate clean */
   XSetForeground(display, fill_bg_gc, colors_standard[COLOR_STD_WHITE]);
@@ -836,7 +836,7 @@
 {
   int canvas_x, canvas_y;
   static struct city *last_pcity = NULL;
-  struct canvas_store store = {XtWindow(map_canvas)};
+  struct canvas store = {XtWindow(map_canvas)};
 
   if (color == -1) {
     if (pcity != last_pcity)
Index: client/include/mapview_g.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/include/mapview_g.h,v
retrieving revision 1.46
diff -u -r1.46 mapview_g.h
--- client/include/mapview_g.h  5 Mar 2004 18:16:01 -0000       1.46
+++ client/include/mapview_g.h  6 Mar 2004 20:18:35 -0000
@@ -29,34 +29,34 @@
 void set_indicator_icons(int bulb, int sol, int flake, int gov);
 
 void map_size_changed(void);
-struct canvas_store *canvas_store_create(int width, int height);
-void canvas_store_free(struct canvas_store *store);
-struct canvas_store *get_overview_window(void);
+struct canvas *canvas_store_create(int width, int height);
+void canvas_store_free(struct canvas *store);
+struct canvas *get_overview_window(void);
 
 void show_city_desc(struct city *pcity, int canvas_x, int canvas_y);
 void prepare_show_city_descriptions(void);
 
-void put_one_tile_iso(struct canvas_store *pcanvas_store,
+void put_one_tile_iso(struct canvas *pcanvas,
                      int map_x, int map_y,
                      int canvas_x, int canvas_y,
                      int offset_x, int offset_y, int offset_y_unit,
                      int width, int height, int height_unit,
                      enum draw_type draw, bool citymode);
-void gui_put_sprite(struct canvas_store *pcanvas_store,
+void gui_put_sprite(struct canvas *pcanvas,
                    int canvas_x, int canvas_y,
                    struct Sprite *sprite,
                    int offset_x, int offset_y,
                    int width, int height);
-void gui_put_sprite_full(struct canvas_store *pcanvas_store,
+void gui_put_sprite_full(struct canvas *pcanvas,
                         int canvas_x, int canvas_y,
                         struct Sprite *sprite);
-void gui_put_rectangle(struct canvas_store *pcanvas_store,
+void gui_put_rectangle(struct canvas *pcanvas,
                       enum color_std color,
                       int canvas_x, int canvas_y, int width, int height);
-void gui_put_line(struct canvas_store *pcanvas_store, enum color_std color,
+void gui_put_line(struct canvas *pcanvas, enum color_std color,
                  enum line_type ltype, int start_x, int start_y,
                  int dx, int dy);
-void gui_copy_canvas(struct canvas_store *dest, struct canvas_store *src,
+void gui_copy_canvas(struct canvas *dest, struct canvas *src,
                     int src_x, int src_y, int dest_x, int dest_y, int width,
                     int height);
 

[Prev in Thread] Current Thread [Next in Thread]