vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Initial effort for gfxmenu on multiterm branch

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2009-12-26 01:49:57 +01:00
commit bee140683a
68 changed files with 5067 additions and 2577 deletions
Download patch file Download diff file Expand all files Collapse all files

189
gfxmenu/gfxmenu.c
View file

@ -37,199 +37,58 @@
#include <grub/gfxmenu_view.h>
#include <grub/time.h>
static void switch_to_text_menu (void)
void
grub_gfxmenu_viewer_fini (void *data)
{
grub_env_set ("menuviewer", "text");
grub_gfxmenu_view_t view = data;
grub_gfxmenu_view_destroy (view);
}
static void
process_key_press (int c,
grub_gfxmenu_model_t model,
grub_gfxmenu_view_t view,
int nested,
int *should_exit)
/* FIXME: 't' and 'c'. */
grub_err_t
grub_gfxmenu_try (int entry, grub_menu_t menu, int nested)
{
/* When a key is pressed, stop the timeout. */
grub_gfxmenu_model_clear_timeout (model);
switch (c)
{
case 'j':
case GRUB_TERM_DOWN:
{
int i = grub_gfxmenu_model_get_selected_index (model);
int num_items = grub_gfxmenu_model_get_num_entries (model);
if (i < num_items - 1)
{
i++;
grub_gfxmenu_model_set_selected_index (model, i);
grub_gfxmenu_redraw_menu (view);
}
}
break;
case 'k':
case GRUB_TERM_UP:
{
int i = grub_gfxmenu_model_get_selected_index (model);
if (i > 0)
{
i--;
grub_gfxmenu_model_set_selected_index (model, i);
grub_gfxmenu_redraw_menu (view);
}
}
break;
case '\r':
case '\n':
case GRUB_TERM_RIGHT:
{
int selected = grub_gfxmenu_model_get_selected_index (model);
int num_entries = grub_gfxmenu_model_get_num_entries (model);
if (selected >= 0 && selected < num_entries)
{
grub_menu_entry_t entry =
grub_gfxmenu_model_get_entry (model, selected);
grub_gfxmenu_view_execute_entry (view, entry);
}
}
break;
case 'c':
grub_gfxmenu_view_run_terminal (view);
break;
case 't':
/* The write hook for 'menuviewer' will cause
* grub_menu_viewer_should_return to return nonzero. */
switch_to_text_menu ();
*should_exit = 1;
break;
case GRUB_TERM_ESC:
if (nested)
*should_exit = 1;
break;
}
if (grub_errno != GRUB_ERR_NONE)
*should_exit = 1;
}
static void
handle_key_events (grub_gfxmenu_model_t model,
grub_gfxmenu_view_t view,
int nested,
int *should_exit)
{
while ((! *should_exit) && (grub_checkkey () != -1))
{
int key = grub_getkey ();
int c = GRUB_TERM_ASCII_CHAR (key);
process_key_press (c, model, view, nested, should_exit);
}
}
static grub_err_t
show_menu (grub_menu_t menu, int nested)
{
grub_gfxmenu_model_t model;
grub_gfxmenu_view_t view;
const char *theme_path;
struct grub_menu_viewer *instance;
theme_path = grub_env_get ("theme");
if (! theme_path)
{
switch_to_text_menu ();
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "no theme specified");
}
return grub_error (GRUB_ERR_FILE_NOT_FOUND, "no theme specified");
model = grub_gfxmenu_model_new (menu);
if (! model)
{
switch_to_text_menu ();
return grub_errno;
}
instance = grub_zalloc (sizeof (*instance));
if (!instance)
return grub_errno;
/* Create the view. */
view = grub_gfxmenu_view_new (theme_path, model);
view = grub_gfxmenu_view_new (theme_path, menu, entry, nested);
if (! view)
{
grub_print_error ();
grub_gfxmenu_model_destroy (model);
switch_to_text_menu ();
grub_free (instance);
return grub_errno;
}
/* Initially select the default menu entry. */
int default_index = grub_menu_get_default_entry_index (menu);
grub_gfxmenu_model_set_selected_index (model, default_index);
/* Start the timer to execute the default entry. */
grub_gfxmenu_model_set_timeout (model);
/* Main event loop. */
int exit_requested = 0;
grub_gfxmenu_view_draw (view);
grub_video_swap_buffers ();
if (view->double_repaint)
grub_gfxmenu_view_draw (view);
while ((! exit_requested) && (! grub_menu_viewer_should_return ()))
{
grub_gfxmenu_redraw_timeout (view);
if (grub_gfxmenu_model_timeout_expired (model))
{
grub_gfxmenu_model_clear_timeout (model);
int i = grub_gfxmenu_model_get_selected_index (model);
grub_menu_entry_t e = grub_gfxmenu_model_get_entry (model, i);
grub_gfxmenu_view_execute_with_fallback (view, e);
continue;
}
instance->data = view;
instance->set_chosen_entry = grub_gfxmenu_set_chosen_entry;
instance->fini = grub_gfxmenu_viewer_fini;
instance->print_timeout = grub_gfxmenu_print_timeout;
instance->clear_timeout = grub_gfxmenu_clear_timeout;
handle_key_events (model, view, nested, &exit_requested);
grub_cpu_idle ();
}
grub_menu_register_viewer (instance);
grub_gfxmenu_view_destroy (view);
grub_gfxmenu_model_destroy (model);
return grub_errno;
return GRUB_ERR_NONE;
}
static grub_err_t
grub_cmd_gfxmenu (grub_command_t cmd __attribute__ ((unused)),
int argc __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
grub_menu_t menu = grub_env_get_data_slot ("menu");
if (! menu)
return grub_error (GRUB_ERR_MENU, "no menu context");
return show_menu (menu, 1);
}
static struct grub_menu_viewer menu_viewer =
{
.name = "gfxmenu",
.show_menu = show_menu
};
static grub_command_t cmd;
GRUB_MOD_INIT (gfxmenu)
{
(void) mod; /* To stop warning. */
grub_menu_viewer_register (&menu_viewer);
cmd = grub_register_command ("gfxmenu", grub_cmd_gfxmenu,
"gfxmenu",
"Show graphical menu interface");
grub_gfxmenu_try_hook = grub_gfxmenu_try;
}
GRUB_MOD_FINI (gfxmenu)
{
grub_unregister_command (cmd);
grub_gfxmenu_try_hook = NULL;
}

10
gfxmenu/gui_circular_progress.c
View file

@ -140,11 +140,15 @@ circprog_paint (void *vself, const grub_video_rect_t *region)
center_width, center_height);
int radius = width / 2 - tick_width / 2 - 1;
int nticks = (self->num_ticks
* (self->value - self->start)
/ (self->end - self->start));
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)
{

24
gfxmenu/gui_list.c
View file

@ -67,7 +67,8 @@ struct grub_gui_list_impl
grub_gfxmenu_box_t selected_item_box;
grub_gfxmenu_icon_manager_t icon_manager;
grub_gfxmenu_model_t menu;
grub_gfxmenu_view_t view;
};
typedef struct grub_gui_list_impl *list_impl_t;
@ -93,7 +94,7 @@ list_destroy (void *vself)
static int
get_num_shown_items (list_impl_t self)
{
int n = grub_gfxmenu_model_get_num_entries (self->menu);
int n = self->view->menu->size;
if (self->min_items_shown != -1 && n < self->min_items_shown)
n = self->min_items_shown;
if (self->max_items_shown != -1 && n > self->max_items_shown)
@ -157,7 +158,7 @@ static struct grub_video_bitmap *
get_item_icon (list_impl_t self, int item_index)
{
grub_menu_entry_t entry;
entry = grub_gfxmenu_model_get_entry (self->menu, item_index);
entry = grub_menu_get_entry (self->view->menu, item_index);
if (! entry)
return 0;
@ -167,7 +168,7 @@ get_item_icon (list_impl_t self, int item_index)
static void
make_selected_item_visible (list_impl_t self)
{
int selected_index = grub_gfxmenu_model_get_selected_index (self->menu);
int selected_index = self->view->selected;
if (selected_index < 0)
return; /* No item is selected. */
int num_shown_items = get_num_shown_items (self);
@ -222,7 +223,7 @@ draw_menu (list_impl_t self)
int descent = grub_font_get_descent (self->item_font);
int item_height = self->item_height;
int total_num_items = grub_gfxmenu_model_get_num_entries (self->menu);
int total_num_items = self->view->menu->size;
int num_shown_items = get_num_shown_items (self);
grub_gfxmenu_box_t box = self->menu_box;
int width = self->bounds.width;
@ -256,8 +257,7 @@ draw_menu (list_impl_t self)
visible_index < num_shown_items && menu_index < total_num_items;
visible_index++, menu_index++)
{
int is_selected =
(menu_index == grub_gfxmenu_model_get_selected_index (self->menu));
int is_selected = (menu_index == self->view->selected);
if (is_selected)
{
@ -282,7 +282,7 @@ draw_menu (list_impl_t self)
0, 0, self->icon_width, self->icon_height);
const char *item_title =
grub_gfxmenu_model_get_entry_title (self->menu, menu_index);
grub_menu_get_entry (self->view->menu, menu_index)->title;
grub_font_t font =
(is_selected && self->selected_item_font
? self->selected_item_font
@ -530,12 +530,12 @@ list_set_property (void *vself, const char *name, const char *value)
/* Set necessary information that the gfxmenu view provides. */
static void
list_set_view_info (void *vself,
const char *theme_path,
grub_gfxmenu_model_t menu)
grub_gfxmenu_view_t view)
{
list_impl_t self = vself;
grub_gfxmenu_icon_manager_set_theme_path (self->icon_manager, theme_path);
self->menu = menu;
grub_gfxmenu_icon_manager_set_theme_path (self->icon_manager,
view->theme_path);
self->view = view;
}
static struct grub_gui_list_ops list_ops =

14
gfxmenu/gui_progress_bar.c
View file

@ -139,11 +139,16 @@ draw_pixmap_bar (grub_gui_progress_bar_t self)
int bar_v_pad = bar_t_pad + bar_b_pad;
int tracklen = w - bar_h_pad;
int trackheight = h - bar_v_pad;
int barwidth;
if (self->end == self->start)
return;
bar->set_content_size (bar, tracklen, trackheight);
int barwidth = (tracklen
* (self->value - self->start)
/ (self->end - self->start));
barwidth = (tracklen * (self->value - self->start)
/ (self->end - self->start));
hl->set_content_size (hl, barwidth, h - bar_v_pad);
bar->draw (bar, 0, 0);
@ -174,12 +179,13 @@ static void
progress_bar_paint (void *vself, const grub_video_rect_t *region)
{
grub_gui_progress_bar_t self = vself;
grub_video_rect_t vpsave;
if (! self->visible)
return;
if (!grub_video_have_common_points (region, &self->bounds))
return;
grub_video_rect_t vpsave;
grub_gui_set_viewport (&self->bounds, &vpsave);
if (check_pixmaps (self))

191
gfxmenu/model.c
View file

@ -1,191 +0,0 @@
/* model.c - Graphical menu interface MVC model. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008 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 <http://www.gnu.org/licenses/>.
*/
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/err.h>
#include <grub/normal.h>
#include <grub/menu.h>
#include <grub/time.h>
#include <grub/gfxmenu_model.h>
/* Model type definition. */
struct grub_gfxmenu_model
{
grub_menu_t menu;
int num_entries;
grub_menu_entry_t *entries;
int selected_entry_index;
int timeout_set;
grub_uint64_t timeout_start;
grub_uint64_t timeout_at;
};
grub_gfxmenu_model_t
grub_gfxmenu_model_new (grub_menu_t menu)
{
grub_gfxmenu_model_t model;
model = grub_malloc (sizeof (*model));
if (! model)
return 0;
model->menu = menu;
model->num_entries = menu->size;
model->entries = 0;
model->selected_entry_index = 0;
model->timeout_set = 0;
model->timeout_at = 0;
if (model->num_entries > 0)
{
model->entries = grub_malloc (model->num_entries
* sizeof (*model->entries));
if (! model->entries)
goto fail_and_free;
int i;
grub_menu_entry_t cur;
for (i = 0, cur = menu->entry_list;
i < model->num_entries;
i++, cur = cur->next)
{
model->entries[i] = cur;
}
}
return model;
fail_and_free:
grub_free (model->entries);
grub_free (model);
return 0;
}
void
grub_gfxmenu_model_destroy (grub_gfxmenu_model_t model)
{
if (! model)
return;
grub_free (model->entries);
model->entries = 0;
grub_free (model);
}
grub_menu_t
grub_gfxmenu_model_get_menu (grub_gfxmenu_model_t model)
{
return model->menu;
}
void
grub_gfxmenu_model_set_timeout (grub_gfxmenu_model_t model)
{
int timeout_sec = grub_menu_get_timeout ();
if (timeout_sec >= 0)
{
model->timeout_start = grub_get_time_ms ();
model->timeout_at = model->timeout_start + timeout_sec * 1000;
model->timeout_set = 1;
}
else
{
model->timeout_set = 0;
}
}
void
grub_gfxmenu_model_clear_timeout (grub_gfxmenu_model_t model)
{
model->timeout_set = 0;
grub_menu_set_timeout (-1);
}
int
grub_gfxmenu_model_get_timeout_ms (grub_gfxmenu_model_t model)
{
if (!model->timeout_set)
return -1;
return model->timeout_at - model->timeout_start;
}
int
grub_gfxmenu_model_get_timeout_remaining_ms (grub_gfxmenu_model_t model)
{
if (!model->timeout_set)
return -1;
return model->timeout_at - grub_get_time_ms ();
}
int
grub_gfxmenu_model_timeout_expired (grub_gfxmenu_model_t model)
{
if (model->timeout_set
&& grub_get_time_ms () >= model->timeout_at)
return 1;
return 0;
}
int
grub_gfxmenu_model_get_num_entries (grub_gfxmenu_model_t model)
{
return model->num_entries;
}
int
grub_gfxmenu_model_get_selected_index (grub_gfxmenu_model_t model)
{
return model->selected_entry_index;
}
void
grub_gfxmenu_model_set_selected_index (grub_gfxmenu_model_t model, int index)
{
model->selected_entry_index = index;
}
const char *
grub_gfxmenu_model_get_entry_title (grub_gfxmenu_model_t model, int index)
{
if (index < 0 || index >= model->num_entries)
{
grub_error (GRUB_ERR_OUT_OF_RANGE, "invalid menu index");
return 0;
}
return model->entries[index]->title;
}
grub_menu_entry_t
grub_gfxmenu_model_get_entry (grub_gfxmenu_model_t model, int index)
{
if (index < 0 || index >= model->num_entries)
{
grub_error (GRUB_ERR_OUT_OF_RANGE, "invalid menu index");
return 0;
}
return model->entries[index];
}

182
gfxmenu/view.c
View file

@ -25,7 +25,6 @@
#include <grub/dl.h>
#include <grub/normal.h>
#include <grub/video.h>
#include <grub/gui_string_util.h>
#include <grub/gfxterm.h>
#include <grub/bitmap.h>
#include <grub/bitmap_scale.h>
@ -35,24 +34,25 @@
#include <grub/menu.h>
#include <grub/menu_viewer.h>
#include <grub/gfxmenu_view.h>
#include <grub/gui.h>
#include <grub/gui_string_util.h>
#include <grub/icon_manager.h>
/* The component ID identifying GUI components to be updated as the timeout
status changes. */
#define TIMEOUT_COMPONENT_ID "__timeout__"
#if 0
static grub_gfxmenu_view_t term_view;
#endif
static void init_terminal (grub_gfxmenu_view_t view);
static void destroy_terminal (void);
static grub_err_t set_graphics_mode (void);
static grub_err_t set_text_mode (void);
/* Create a new view object, loading the theme specified by THEME_PATH and
associating MODEL with the view. */
grub_gfxmenu_view_t
grub_gfxmenu_view_new (const char *theme_path, grub_gfxmenu_model_t model)
grub_gfxmenu_view_new (const char *theme_path, grub_menu_t menu, int entry,
int nested)
{
grub_gfxmenu_view_t view;
grub_err_t err;
@ -96,8 +96,11 @@ grub_gfxmenu_view_new (const char *theme_path, grub_gfxmenu_model_t model)
default_fg_color = grub_gui_color_rgb (0, 0, 0);
default_bg_color = grub_gui_color_rgb (255, 255, 255);
view->model = model;
view->canvas = 0;
view->selected = entry;
view->menu = menu;
view->nested = nested;
view->first_timeout = -1;
view->title_font = default_font;
view->message_font = default_font;
@ -111,7 +114,6 @@ grub_gfxmenu_view_new (const char *theme_path, grub_gfxmenu_model_t model)
view->title_text = grub_strdup ("GRUB Boot Menu");
view->progress_message_text = 0;
view->theme_path = 0;
view->last_seconds_remaining = -2;
/* Set the timeout bar's frame. */
view->progress_message_frame.width = view->screen.width * 4 / 5;
@ -127,7 +129,9 @@ grub_gfxmenu_view_new (const char *theme_path, grub_gfxmenu_model_t model)
return 0;
}
#if 0
init_terminal (view);
#endif
return view;
}
@ -148,9 +152,12 @@ grub_gfxmenu_view_destroy (grub_gfxmenu_view_t view)
grub_free (view);
set_text_mode ();
#if 0
destroy_terminal ();
#endif
}
#if 0
/* Sets MESSAGE as the progress message for the view.
MESSAGE can be 0, in which case no message is displayed. */
static void
@ -162,6 +169,7 @@ set_progress_message (grub_gfxmenu_view_t view, const char *message)
else
view->progress_message_text = 0;
}
#endif
static void
redraw_background (grub_gfxmenu_view_t view,
@ -224,18 +232,15 @@ update_timeout_visit (grub_gui_component_t component,
component->ops->set_property (component, "text", pv->text);
}
static inline void
update_timeout (grub_gfxmenu_view_t view, int is_init)
void
grub_gfxmenu_print_timeout (int timeout, void *data)
{
char startbuf[20];
char valuebuf[20];
char valuebuf[sizeof ("-XXXXXXXXXXX")];
char startbuf[sizeof ("-XXXXXXXXXXX")];
char msgbuf[120];
struct grub_gfxmenu_view *view = data;
int timeout;
int remaining;
struct progress_value_data pv;
int seconds_remaining_rounded_up;
auto void redraw_timeout_visit (grub_gui_component_t component,
void *userdata __attribute__ ((unused)));
@ -248,52 +253,62 @@ update_timeout (grub_gfxmenu_view_t view, int is_init)
grub_gfxmenu_view_redraw (view, &bounds);
}
timeout = grub_gfxmenu_model_get_timeout_ms (view->model);
if (timeout > 0)
{
remaining = grub_gfxmenu_model_get_timeout_remaining_ms (view->model);
seconds_remaining_rounded_up = (remaining + 999) / 1000;
}
else
{
seconds_remaining_rounded_up = -1;
remaining = -1;
}
if (view->first_timeout == -1)
view->first_timeout = timeout;
if (view->last_seconds_remaining == seconds_remaining_rounded_up && !is_init)
return;
view->last_seconds_remaining = seconds_remaining_rounded_up;
pv.visible = timeout > 0 ? "true" : "false";
grub_sprintf (startbuf, "%d", -timeout);
pv.visible = "true";
grub_sprintf (startbuf, "%d", -(view->first_timeout + 1));
pv.start = startbuf;
pv.end = "0";
grub_sprintf (valuebuf, "%d", remaining > 0 ? -remaining : 0);
grub_sprintf (valuebuf, "%d", -timeout);
pv.value = valuebuf;
grub_sprintf (msgbuf,
"The highlighted entry will be booted automatically in %d s.",
seconds_remaining_rounded_up);
timeout);
pv.text = msgbuf;
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, update_timeout_visit, &pv);
if (!is_init)
{
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
grub_video_swap_buffers ();
if (view->double_repaint)
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
}
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
grub_video_swap_buffers ();
if (view->double_repaint)
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
}
void
grub_gfxmenu_redraw_timeout (grub_gfxmenu_view_t view)
void
grub_gfxmenu_clear_timeout (void *data)
{
update_timeout (view, 0);
struct progress_value_data pv;
struct grub_gfxmenu_view *view = data;
auto void redraw_timeout_visit (grub_gui_component_t component,
void *userdata __attribute__ ((unused)));
auto void redraw_timeout_visit (grub_gui_component_t component,
void *userdata __attribute__ ((unused)))
{
grub_video_rect_t bounds;
component->ops->get_bounds (component, &bounds);
grub_gfxmenu_view_redraw (view, &bounds);
}
pv.visible = "false";
pv.start = "1";
pv.end = "0";
pv.value = "0";
pv.text = "";
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, update_timeout_visit, &pv);
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
grub_video_swap_buffers ();
if (view->double_repaint)
grub_gui_find_by_id ((grub_gui_component_t) view->canvas,
TIMEOUT_COMPONENT_ID, redraw_timeout_visit, &pv);
}
static void
@ -305,7 +320,7 @@ update_menu_visit (grub_gui_component_t component,
if (component->ops->is_instance (component, "list"))
{
grub_gui_list_t list = (grub_gui_list_t) component;
list->ops->set_view_info (list, view->theme_path, view->model);
list->ops->set_view_info (list, view);
}
}
@ -361,7 +376,6 @@ grub_gfxmenu_view_redraw (grub_gfxmenu_view_t view,
void
grub_gfxmenu_view_draw (grub_gfxmenu_view_t view)
{
update_timeout (view, 1);
update_menu_components (view);
grub_gfxmenu_view_redraw (view, &view->screen);
@ -402,6 +416,16 @@ grub_gfxmenu_redraw_menu (grub_gfxmenu_view_t view)
}
}
void
grub_gfxmenu_set_chosen_entry (int entry, void *data)
{
grub_gfxmenu_view_t view = data;
view->selected = entry;
grub_gfxmenu_redraw_menu (view);
}
static grub_err_t
set_graphics_mode (void)
{
@ -417,6 +441,8 @@ set_text_mode (void)
return grub_video_restore ();
}
/* FIXME */
#if 0
static int term_target_width;
static int term_target_height;
static int term_initialized;
@ -487,7 +513,6 @@ static void destroy_terminal (void)
grub_term_set_current_output (term_original);
}
static void
notify_booting (grub_menu_entry_t entry, void *userdata)
{
@ -537,59 +562,4 @@ static struct grub_menu_execute_callback execute_callback =
.notify_failure = notify_execution_failure
};
int
grub_gfxmenu_view_execute_with_fallback (grub_gfxmenu_view_t view,
grub_menu_entry_t entry)
{
draw_terminal_box (view);
grub_menu_execute_with_fallback (grub_gfxmenu_model_get_menu (view->model),
entry, &execute_callback, (void *) view);
if (set_graphics_mode () != GRUB_ERR_NONE)
return 0; /* Failure. */
/* If we returned, there was a failure. */
set_progress_message (view,
"Unable to automatically boot. "
"Press SPACE to continue.");
grub_gfxmenu_view_draw (view);
while (GRUB_TERM_ASCII_CHAR(grub_getkey ()) != ' ')
{
/* Wait for SPACE to be pressed. */
}
set_progress_message (view, 0); /* Clear the message. */
grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
grub_video_swap_buffers ();
if (view->double_repaint)
grub_gfxmenu_view_redraw (view, &view->progress_message_frame);
return 1; /* Ok. */
}
int
grub_gfxmenu_view_execute_entry (grub_gfxmenu_view_t view,
grub_menu_entry_t entry)
{
draw_terminal_box (view);
grub_menu_execute_entry (entry);
if (grub_errno != GRUB_ERR_NONE)
grub_wait_after_message ();
if (set_graphics_mode () != GRUB_ERR_NONE)
return 0; /* Failure. */
grub_gfxmenu_view_draw (view);
return 1; /* Ok. */
}
void
grub_gfxmenu_view_run_terminal (grub_gfxmenu_view_t view)
{
draw_terminal_box (view);
grub_cmdline_run (1);
grub_gfxmenu_view_draw (view);
}
#endif