← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to gfxmenu/widget-box.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

Show diffs side-by-side

added added

removed removed

Lines of Context:
gfxmenu/widget-box.c
1
 
/* widget_box.c - Pixmap-stylized box widget. */
2
 
/*
3
 
 *  GRUB  --  GRand Unified Bootloader
4
 
 *  Copyright (C) 2008,2009  Free Software Foundation, Inc.
5
 
 *
6
 
 *  GRUB is free software: you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation, either version 3 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  GRUB is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
18
 
 */
19
 
 
20
 
#include <grub/types.h>
21
 
#include <grub/misc.h>
22
 
#include <grub/mm.h>
23
 
#include <grub/err.h>
24
 
#include <grub/video.h>
25
 
#include <grub/bitmap.h>
26
 
#include <grub/bitmap_scale.h>
27
 
#include <grub/gfxwidgets.h>
28
 
 
29
 
enum box_pixmaps
30
 
{
31
 
  BOX_PIXMAP_NW, BOX_PIXMAP_NE, BOX_PIXMAP_SE, BOX_PIXMAP_SW,
32
 
  BOX_PIXMAP_N, BOX_PIXMAP_E, BOX_PIXMAP_S, BOX_PIXMAP_W,
33
 
  BOX_PIXMAP_CENTER
34
 
};
35
 
 
36
 
static const char *box_pixmap_names[] = {
37
 
  /* Corners: */
38
 
  "nw", "ne", "se", "sw",
39
 
  /* Sides: */
40
 
  "n", "e", "s", "w",
41
 
  /* Center: */
42
 
  "c"
43
 
};
44
 
 
45
 
#define BOX_NUM_PIXMAPS (sizeof(box_pixmap_names)/sizeof(*box_pixmap_names))
46
 
 
47
 
static int
48
 
get_height (struct grub_video_bitmap *bitmap)
49
 
{
50
 
  if (bitmap)
51
 
    return grub_video_bitmap_get_height (bitmap);
52
 
  else
53
 
    return 0;
54
 
}
55
 
 
56
 
static int
57
 
get_width (struct grub_video_bitmap *bitmap)
58
 
{
59
 
  if (bitmap)
60
 
    return grub_video_bitmap_get_width (bitmap);
61
 
  else
62
 
    return 0;
63
 
}
64
 
 
65
 
static void
66
 
blit (grub_gfxmenu_box_t self, int pixmap_index, int x, int y)
67
 
{
68
 
  struct grub_video_bitmap *bitmap;
69
 
  bitmap = self->scaled_pixmaps[pixmap_index];
70
 
  if (! bitmap)
71
 
    return;
72
 
  grub_video_blit_bitmap (bitmap, GRUB_VIDEO_BLIT_BLEND,
73
 
                          x, y, 0, 0,
74
 
                          grub_video_bitmap_get_width (bitmap),
75
 
                          grub_video_bitmap_get_height (bitmap));
76
 
}
77
 
 
78
 
static void
79
 
draw (grub_gfxmenu_box_t self, int x, int y)
80
 
{
81
 
  int height_n;
82
 
  int height_s;
83
 
  int height_e;
84
 
  int height_w;
85
 
  int width_n;
86
 
  int width_s;
87
 
  int width_e;
88
 
  int width_w;
89
 
 
90
 
  height_n = get_height (self->scaled_pixmaps[BOX_PIXMAP_N]);
91
 
  height_s = get_height (self->scaled_pixmaps[BOX_PIXMAP_S]);
92
 
  height_e = get_height (self->scaled_pixmaps[BOX_PIXMAP_E]);
93
 
  height_w = get_height (self->scaled_pixmaps[BOX_PIXMAP_W]);
94
 
  width_n = get_width (self->scaled_pixmaps[BOX_PIXMAP_N]);
95
 
  width_s = get_width (self->scaled_pixmaps[BOX_PIXMAP_S]);
96
 
  width_e = get_width (self->scaled_pixmaps[BOX_PIXMAP_E]);
97
 
  width_w = get_width (self->scaled_pixmaps[BOX_PIXMAP_W]);
98
 
 
99
 
  /* Draw sides.  */
100
 
  blit (self, BOX_PIXMAP_N, x + width_w, y);
101
 
  blit (self, BOX_PIXMAP_S, x + width_w, y + height_n + self->content_height);
102
 
  blit (self, BOX_PIXMAP_E, x + width_w + self->content_width, y + height_n);
103
 
  blit (self, BOX_PIXMAP_W, x, y + height_n);
104
 
 
105
 
  /* Draw corners.  */
106
 
  blit (self, BOX_PIXMAP_NW, x, y);
107
 
  blit (self, BOX_PIXMAP_NE, x + width_w + self->content_width, y);
108
 
  blit (self, BOX_PIXMAP_SE,
109
 
        x + width_w + self->content_width,
110
 
        y + height_n + self->content_height);
111
 
  blit (self, BOX_PIXMAP_SW, x, y + height_n + self->content_height);
112
 
 
113
 
  /* Draw center.  */
114
 
  blit (self, BOX_PIXMAP_CENTER, x + width_w, y + height_n);
115
 
}
116
 
 
117
 
static grub_err_t
118
 
scale_pixmap (grub_gfxmenu_box_t self, int i, int w, int h)
119
 
{
120
 
  struct grub_video_bitmap **scaled = &self->scaled_pixmaps[i];
121
 
  struct grub_video_bitmap *raw = self->raw_pixmaps[i];
122
 
 
123
 
  if (raw == 0)
124
 
    return grub_errno;
125
 
 
126
 
  if (w == -1)
127
 
    w = grub_video_bitmap_get_width (raw);
128
 
  if (h == -1)
129
 
    h = grub_video_bitmap_get_height (raw);
130
 
 
131
 
  if (*scaled == 0
132
 
      || ((int) grub_video_bitmap_get_width (*scaled) != w)
133
 
      || ((int) grub_video_bitmap_get_height (*scaled) != h))
134
 
    {
135
 
      if (*scaled)
136
 
        {
137
 
          grub_video_bitmap_destroy (*scaled);
138
 
          *scaled = 0;
139
 
        }
140
 
 
141
 
      /* Don't try to create a bitmap with a zero dimension.  */
142
 
      if (w != 0 && h != 0)
143
 
        grub_video_bitmap_create_scaled (scaled, w, h, raw,
144
 
                                         GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST);
145
 
      if (grub_errno != GRUB_ERR_NONE)
146
 
        {
147
 
          grub_error_push ();
148
 
          grub_error (grub_errno,
149
 
                      "failed to scale bitmap for styled box pixmap #%d", i);
150
 
        }
151
 
    }
152
 
 
153
 
  return grub_errno;
154
 
}
155
 
 
156
 
static void
157
 
set_content_size (grub_gfxmenu_box_t self,
158
 
                  int width, int height)
159
 
{
160
 
  self->content_width = width;
161
 
  self->content_height = height;
162
 
 
163
 
  /* Resize sides to match the width and height.  */
164
 
  /* It is assumed that the corners width/height match the adjacent sides.  */
165
 
 
166
 
  /* Resize N and S sides to match width.  */
167
 
  if (scale_pixmap(self, BOX_PIXMAP_N, width, -1) != GRUB_ERR_NONE)
168
 
    return;
169
 
  if (scale_pixmap(self, BOX_PIXMAP_S, width, -1) != GRUB_ERR_NONE)
170
 
    return;
171
 
 
172
 
  /* Resize E and W sides to match height.  */
173
 
  if (scale_pixmap(self, BOX_PIXMAP_E, -1, height) != GRUB_ERR_NONE)
174
 
      return;
175
 
  if (scale_pixmap(self, BOX_PIXMAP_W, -1, height) != GRUB_ERR_NONE)
176
 
    return;
177
 
 
178
 
  /* Don't scale the corners--they are assumed to match the sides. */
179
 
  if (scale_pixmap(self, BOX_PIXMAP_NW, -1, -1) != GRUB_ERR_NONE)
180
 
    return;
181
 
  if (scale_pixmap(self, BOX_PIXMAP_SW, -1, -1) != GRUB_ERR_NONE)
182
 
    return;
183
 
  if (scale_pixmap(self, BOX_PIXMAP_NE, -1, -1) != GRUB_ERR_NONE)
184
 
    return;
185
 
  if (scale_pixmap(self, BOX_PIXMAP_SE, -1, -1) != GRUB_ERR_NONE)
186
 
    return;
187
 
 
188
 
  /* Scale the center area. */
189
 
  if (scale_pixmap(self, BOX_PIXMAP_CENTER, width, height) != GRUB_ERR_NONE)
190
 
    return;
191
 
}
192
 
 
193
 
static int
194
 
get_left_pad (grub_gfxmenu_box_t self)
195
 
{
196
 
  return get_width (self->raw_pixmaps[BOX_PIXMAP_W]);
197
 
}
198
 
 
199
 
static int
200
 
get_top_pad (grub_gfxmenu_box_t self)
201
 
{
202
 
  return get_height (self->raw_pixmaps[BOX_PIXMAP_N]);
203
 
}
204
 
 
205
 
static int
206
 
get_right_pad (grub_gfxmenu_box_t self)
207
 
{
208
 
  return get_width (self->raw_pixmaps[BOX_PIXMAP_E]);
209
 
}
210
 
 
211
 
static int
212
 
get_bottom_pad (grub_gfxmenu_box_t self)
213
 
{
214
 
  return get_height (self->raw_pixmaps[BOX_PIXMAP_S]);
215
 
}
216
 
 
217
 
static void
218
 
destroy (grub_gfxmenu_box_t self)
219
 
{
220
 
  unsigned i;
221
 
  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
222
 
    {
223
 
      if (self->raw_pixmaps[i])
224
 
        grub_video_bitmap_destroy(self->raw_pixmaps[i]);
225
 
      self->raw_pixmaps[i] = 0;
226
 
 
227
 
      if (self->scaled_pixmaps[i])
228
 
        grub_video_bitmap_destroy(self->scaled_pixmaps[i]);
229
 
      self->scaled_pixmaps[i] = 0;
230
 
    }
231
 
  grub_free (self->raw_pixmaps);
232
 
  self->raw_pixmaps = 0;
233
 
  grub_free (self->scaled_pixmaps);
234
 
  self->scaled_pixmaps = 0;
235
 
 
236
 
  /* Free self:  must be the last step!  */
237
 
  grub_free (self);
238
 
}
239
 
 
240
 
 
241
 
/* Create a new box.  If PIXMAPS_PREFIX and PIXMAPS_SUFFIX are both non-null,
242
 
   then an attempt is made to load the north, south, east, west, northwest,
243
 
   northeast, southeast, southwest, and center pixmaps.
244
 
   If either PIXMAPS_PREFIX or PIXMAPS_SUFFIX is 0, then no pixmaps are
245
 
   loaded, and the box has zero-width borders and is drawn transparent.  */
246
 
grub_gfxmenu_box_t
247
 
grub_gfxmenu_create_box (const char *pixmaps_prefix,
248
 
                         const char *pixmaps_suffix)
249
 
{
250
 
  unsigned i;
251
 
  grub_gfxmenu_box_t box;
252
 
 
253
 
  box = (grub_gfxmenu_box_t) grub_malloc (sizeof (*box));
254
 
  if (! box)
255
 
    return 0;
256
 
 
257
 
  box->content_width = 0;
258
 
  box->content_height = 0;
259
 
  box->raw_pixmaps =
260
 
    (struct grub_video_bitmap **)
261
 
    grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *));
262
 
  box->scaled_pixmaps =
263
 
    (struct grub_video_bitmap **)
264
 
    grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *));
265
 
 
266
 
  /* Initialize all pixmap pointers to NULL so that proper destruction can
267
 
     be performed if an error is encountered partway through construction.  */
268
 
  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
269
 
      box->raw_pixmaps[i] = 0;
270
 
  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
271
 
      box->scaled_pixmaps[i] = 0;
272
 
 
273
 
  /* Load the pixmaps.  */
274
 
  for (i = 0; i < BOX_NUM_PIXMAPS; i++)
275
 
    {
276
 
      if (pixmaps_prefix && pixmaps_suffix)
277
 
        {
278
 
          char *path;
279
 
          char *path_end;
280
 
 
281
 
          path = grub_malloc (grub_strlen (pixmaps_prefix)
282
 
                              + grub_strlen (box_pixmap_names[i])
283
 
                              + grub_strlen (pixmaps_suffix)
284
 
                              + 1);
285
 
          if (! path)
286
 
            goto fail_and_destroy;
287
 
 
288
 
          /* Construct the specific path for this pixmap.  */
289
 
          path_end = grub_stpcpy (path, pixmaps_prefix);
290
 
          path_end = grub_stpcpy (path_end, box_pixmap_names[i]);
291
 
          path_end = grub_stpcpy (path_end, pixmaps_suffix);
292
 
 
293
 
          grub_video_bitmap_load (&box->raw_pixmaps[i], path);
294
 
          grub_free (path);
295
 
 
296
 
          /* Ignore missing pixmaps.  */
297
 
          grub_errno = GRUB_ERR_NONE;
298
 
        }
299
 
    }
300
 
 
301
 
  box->draw = draw;
302
 
  box->set_content_size = set_content_size;
303
 
  box->get_left_pad = get_left_pad;
304
 
  box->get_top_pad = get_top_pad;
305
 
  box->get_right_pad = get_right_pad;
306
 
  box->get_bottom_pad = get_bottom_pad;
307
 
  box->destroy = destroy;
308
 
  return box;
309
 
 
310
 
fail_and_destroy:
311
 
  destroy (box);
312
 
  return 0;
313
 
}