/* gui_circular_process.c - GUI circular progress indicator component. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008,2009 Free Software Foundation, Inc.
*
* GRUB 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 3 of the License, or
* (at your option) any later version.
*
* GRUB 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.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
struct grub_gui_circular_progress
{
struct grub_gui_component_ops *circprog_ops;
grub_gui_container_t parent;
grub_video_rect_t bounds;
char *id;
int preferred_width;
int preferred_height;
int visible;
int start;
int end;
int value;
int num_ticks;
int start_angle;
int ticks_disappear;
char *theme_dir;
int need_to_load_pixmaps;
char *center_file;
char *tick_file;
struct grub_video_bitmap *center_bitmap;
struct grub_video_bitmap *tick_bitmap;
};
typedef struct grub_gui_circular_progress *circular_progress_t;
static void
circprog_destroy (void *vself)
{
circular_progress_t self = vself;
grub_free (self);
}
static const char *
circprog_get_id (void *vself)
{
circular_progress_t self = vself;
return self->id;
}
static int
circprog_is_instance (void *vself __attribute__((unused)), const char *type)
{
return grub_strcmp (type, "component") == 0;
}
static struct grub_video_bitmap *
load_bitmap (const char *dir, const char *file)
{
struct grub_video_bitmap *bitmap;
char *abspath;
/* Check arguments. */
if (! dir || ! file)
return 0;
/* Resolve to an absolute path. */
abspath = grub_resolve_relative_path (dir, file);
if (! abspath)
return 0;
/* Load the image. */
grub_errno = GRUB_ERR_NONE;
grub_video_bitmap_load (&bitmap, abspath);
grub_errno = GRUB_ERR_NONE;
grub_free (abspath);
return bitmap;
}
static int
check_pixmaps (circular_progress_t self)
{
if (self->need_to_load_pixmaps)
{
if (self->center_bitmap)
grub_video_bitmap_destroy (self->center_bitmap);
self->center_bitmap = load_bitmap (self->theme_dir, self->center_file);
self->tick_bitmap = load_bitmap (self->theme_dir, self->tick_file);
self->need_to_load_pixmaps = 0;
}
return (self->center_bitmap != 0 && self->tick_bitmap != 0);
}
static void
circprog_paint (void *vself, const grub_video_rect_t *region)
{
circular_progress_t self = vself;
if (! self->visible)
return;
if (!grub_video_have_common_points (region, &self->bounds))
return;
if (! check_pixmaps (self))
return;
grub_video_rect_t vpsave;
grub_gui_set_viewport (&self->bounds, &vpsave);
int width = self->bounds.width;
int height = self->bounds.height;
int center_width = grub_video_bitmap_get_width (self->center_bitmap);
int center_height = grub_video_bitmap_get_height (self->center_bitmap);
int tick_width = grub_video_bitmap_get_width (self->tick_bitmap);
int tick_height = grub_video_bitmap_get_height (self->tick_bitmap);
grub_video_blit_bitmap (self->center_bitmap, GRUB_VIDEO_BLIT_BLEND,
(width - center_width) / 2,
(height - center_height) / 2, 0, 0,
center_width, center_height);
int radius = width / 2 - tick_width / 2 - 1;
int nticks;
int tick_begin;
int tick_end;
if (self->end == self->start)
nticks = 0;
else
nticks = (self->num_ticks
* (self->value - self->start)
/ (self->end - self->start));
/* Do ticks appear or disappear as the value approached the end? */
if (self->ticks_disappear)
{
tick_begin = nticks;
tick_end = self->num_ticks - 1;
}
else
{
tick_begin = 0;
tick_end = nticks - 1;
}
int i;
for (i = tick_begin; i < tick_end; i++)
{
int x;
int y;
int angle;
/* Calculate the location of the tick. */
angle = self->start_angle + i * GRUB_TRIG_ANGLE_MAX / self->num_ticks;
x = width / 2 + (grub_cos (angle) * radius / GRUB_TRIG_FRACTION_SCALE);
y = height / 2 + (grub_sin (angle) * radius / GRUB_TRIG_FRACTION_SCALE);
/* Adjust (x,y) so the tick is centered. */
x -= tick_width / 2;
y -= tick_height / 2;
/* Draw the tick. */
grub_video_blit_bitmap (self->tick_bitmap, GRUB_VIDEO_BLIT_BLEND,
x, y, 0, 0, tick_width, tick_height);
}
grub_gui_restore_viewport (&vpsave);
}
static void
circprog_set_parent (void *vself, grub_gui_container_t parent)
{
circular_progress_t self = vself;
self->parent = parent;
}
static grub_gui_container_t
circprog_get_parent (void *vself)
{
circular_progress_t self = vself;
return self->parent;
}
static void
circprog_set_bounds (void *vself, const grub_video_rect_t *bounds)
{
circular_progress_t self = vself;
self->bounds = *bounds;
}
static void
circprog_get_bounds (void *vself, grub_video_rect_t *bounds)
{
circular_progress_t self = vself;
*bounds = self->bounds;
}
static void
circprog_get_preferred_size (void *vself, int *width, int *height)
{
circular_progress_t self = vself;
*width = 0;
*height = 0;
/* Allow preferred dimensions to override the circprog dimensions. */
if (self->preferred_width >= 0)
*width = self->preferred_width;
if (self->preferred_height >= 0)
*height = self->preferred_height;
}
static grub_err_t
circprog_set_property (void *vself, const char *name, const char *value)
{
circular_progress_t self = vself;
if (grub_strcmp (name, "value") == 0)
{
self->value = grub_strtol (value, 0, 10);
}
else if (grub_strcmp (name, "start") == 0)
{
self->start = grub_strtol (value, 0, 10);
}
else if (grub_strcmp (name, "end") == 0)
{
self->end = grub_strtol (value, 0, 10);
}
else if (grub_strcmp (name, "num_ticks") == 0)
{
self->num_ticks = grub_strtol (value, 0, 10);
}
else if (grub_strcmp (name, "start_angle") == 0)
{
self->start_angle = grub_strtol (value, 0, 10);
}
else if (grub_strcmp (name, "ticks_disappear") == 0)
{
self->ticks_disappear = grub_strcmp (value, "false") != 0;
}
else if (grub_strcmp (name, "center_bitmap") == 0)
{
self->need_to_load_pixmaps = 1;
grub_free (self->center_file);
self->center_file = value ? grub_strdup (value) : 0;
}
else if (grub_strcmp (name, "tick_bitmap") == 0)
{
self->need_to_load_pixmaps = 1;
grub_free (self->tick_file);
self->tick_file = value ? grub_strdup (value) : 0;
}
else if (grub_strcmp (name, "theme_dir") == 0)
{
self->need_to_load_pixmaps = 1;
grub_free (self->theme_dir);
self->theme_dir = value ? grub_strdup (value) : 0;
}
else if (grub_strcmp (name, "preferred_size") == 0)
{
int w;
int h;
if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE)
return grub_errno;
self->preferred_width = w;
self->preferred_height = h;
}
else if (grub_strcmp (name, "visible") == 0)
{
self->visible = grub_strcmp (value, "false") != 0;
}
else if (grub_strcmp (name, "id") == 0)
{
grub_free (self->id);
if (value)
self->id = grub_strdup (value);
else
self->id = 0;
}
return grub_errno;
}
static struct grub_gui_component_ops circprog_ops =
{
.destroy = circprog_destroy,
.get_id = circprog_get_id,
.is_instance = circprog_is_instance,
.paint = circprog_paint,
.set_parent = circprog_set_parent,
.get_parent = circprog_get_parent,
.set_bounds = circprog_set_bounds,
.get_bounds = circprog_get_bounds,
.get_preferred_size = circprog_get_preferred_size,
.set_property = circprog_set_property
};
grub_gui_component_t
grub_gui_circular_progress_new (void)
{
circular_progress_t self;
self = grub_malloc (sizeof (*self));
if (! self)
return 0;
self->circprog_ops = &circprog_ops;
self->parent = 0;
self->bounds.x = 0;
self->bounds.y = 0;
self->bounds.width = 0;
self->bounds.height = 0;
self->id = 0;
self->preferred_width = -1;
self->preferred_height = -1;
self->visible = 1;
self->start = 0;
self->end = 0;
self->value = 0;
self->num_ticks = 64;
self->start_angle = -64;
self->ticks_disappear = 0;
self->theme_dir = 0;
self->need_to_load_pixmaps = 0;
self->center_file = 0;
self->tick_file = 0;
self->center_bitmap = 0;
self->tick_bitmap = 0;
return (grub_gui_component_t) self;
}